diff --git a/.changeset/small-geckos-brake.md b/.changeset/small-geckos-brake.md new file mode 100644 index 00000000..ff30f481 --- /dev/null +++ b/.changeset/small-geckos-brake.md @@ -0,0 +1,6 @@ +--- +"@macalinao/coda-visitors": patch +"@macalinao/clients-quarry": patch +--- + +Add more defaults to Quarry client diff --git a/clients/quarry/coda.config.mjs b/clients/quarry/coda.config.mjs index 036be45e..baf9d732 100644 --- a/clients/quarry/coda.config.mjs +++ b/clients/quarry/coda.config.mjs @@ -1,8 +1,15 @@ import { + accountValueNode, addPdasVisitor, + associatedTokenAccountValueNode, constantPdaSeedNodeFromString, defineConfig, + pdaLinkNode, + pdaSeedValueNode, + pdaValueNode, publicKeyTypeNode, + setInstructionAccountDefaultValuesVisitor, + updateAccountsVisitor, variablePdaSeedNode, } from "@macalinao/coda"; import { renameVisitor } from "@macalinao/codama-rename-visitor"; @@ -14,10 +21,56 @@ export default defineConfig({ }, visitors: [ + updateAccountsVisitor({ + // quarryMine accounts + rewarder: { + pda: pdaLinkNode("rewarder"), + }, + quarry: { + pda: pdaLinkNode("quarry"), + }, + miner: { + pda: pdaLinkNode("miner"), + }, + + // quarryMergeMine accounts + mergePool: { + pda: pdaLinkNode("mergePool"), + }, + mergeMiner: { + pda: pdaLinkNode("mergeMiner"), + }, + + // quarryMintWrapper accounts + mintWrapper: { + pda: pdaLinkNode("mintWrapper"), + }, + minter: { + pda: pdaLinkNode("minter"), + }, + + // quarryOperator accounts + operator: { + pda: pdaLinkNode("operator"), + }, + + // quarryRedeemer accounts + redeemer: { + pda: pdaLinkNode("redeemer"), + }, + + // quarryRegistry accounts + registry: { + pda: pdaLinkNode("registry"), + }, + }), addPdasVisitor({ quarryMine: [ { name: "rewarder", + docs: [ + "Rewarder account that manages reward distribution for quarries", + ], seeds: [ constantPdaSeedNodeFromString("utf8", "Rewarder"), variablePdaSeedNode("base", publicKeyTypeNode()), @@ -25,6 +78,7 @@ export default defineConfig({ }, { name: "quarry", + docs: ["Individual quarry (staking pool) for a specific token mint"], seeds: [ constantPdaSeedNodeFromString("utf8", "Quarry"), variablePdaSeedNode("rewarder", publicKeyTypeNode()), @@ -33,6 +87,9 @@ export default defineConfig({ }, { name: "miner", + docs: [ + "Miner account representing a user's staking position in a quarry", + ], seeds: [ constantPdaSeedNodeFromString("utf8", "Miner"), variablePdaSeedNode("quarry", publicKeyTypeNode()), @@ -43,6 +100,9 @@ export default defineConfig({ quarryMergeMine: [ { name: "mergePool", + docs: [ + "Merge pool that allows staking multiple quarry rewards as one", + ], seeds: [ constantPdaSeedNodeFromString("utf8", "MergePool"), variablePdaSeedNode("primaryMint", publicKeyTypeNode()), @@ -50,6 +110,7 @@ export default defineConfig({ }, { name: "replicaMint", + docs: ["Replica mint token for the merge pool"], seeds: [ constantPdaSeedNodeFromString("utf8", "ReplicaMint"), variablePdaSeedNode("pool", publicKeyTypeNode()), @@ -57,6 +118,7 @@ export default defineConfig({ }, { name: "mergeMiner", + docs: ["Merge miner account for a user in a merge pool"], seeds: [ constantPdaSeedNodeFromString("utf8", "MergeMiner"), variablePdaSeedNode("pool", publicKeyTypeNode()), @@ -67,6 +129,7 @@ export default defineConfig({ quarryMintWrapper: [ { name: "mintWrapper", + docs: ["Mint wrapper that controls minting of wrapped tokens"], seeds: [ constantPdaSeedNodeFromString("utf8", "MintWrapper"), variablePdaSeedNode("base", publicKeyTypeNode()), @@ -74,6 +137,7 @@ export default defineConfig({ }, { name: "minter", + docs: ["Minter authority for a specific mint wrapper"], seeds: [ constantPdaSeedNodeFromString("utf8", "MintWrapperMinter"), variablePdaSeedNode("wrapper", publicKeyTypeNode()), @@ -84,6 +148,9 @@ export default defineConfig({ quarryOperator: [ { name: "operator", + docs: [ + "Operator account with delegated authority to manage quarries", + ], seeds: [ constantPdaSeedNodeFromString("utf8", "Operator"), variablePdaSeedNode("base", publicKeyTypeNode()), @@ -93,6 +160,9 @@ export default defineConfig({ quarryRedeemer: [ { name: "redeemer", + docs: [ + "Redeemer account for exchanging IOU tokens for redemption tokens", + ], seeds: [ constantPdaSeedNodeFromString("utf8", "Redeemer"), variablePdaSeedNode("iouMint", publicKeyTypeNode()), @@ -103,6 +173,7 @@ export default defineConfig({ quarryRegistry: [ { name: "registry", + docs: ["Registry tracking all quarries for a rewarder"], seeds: [ constantPdaSeedNodeFromString("utf8", "QuarryRegistry"), variablePdaSeedNode("rewarder", publicKeyTypeNode()), @@ -125,5 +196,178 @@ export default defineConfig({ }, }, }), + setInstructionAccountDefaultValuesVisitor([ + // Operator + { + account: "operator", + instruction: "createOperator", + defaultValue: pdaValueNode(pdaLinkNode("operator"), [ + pdaSeedValueNode("base", accountValueNode("base")), + ]), + }, + { + account: "operator", + instruction: "createOperatorV2", + defaultValue: pdaValueNode(pdaLinkNode("operator"), [ + pdaSeedValueNode("base", accountValueNode("base")), + ]), + }, + + ...[ + "delegateCreateQuarry", + "delegateCreateQuarryV2", + "createQuarry", + "createQuarryV2", + ].map((instruction) => ({ + account: "quarry", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("quarry"), [ + pdaSeedValueNode("rewarder", accountValueNode("rewarder")), + pdaSeedValueNode("tokenMint", accountValueNode("tokenMint")), + ]), + })), + + ...[ + "createMiner", + "createMinerV2", + "claimRewards", + "claimRewardsV2", + "withdrawTokens", + "stakeTokens", + ].map((instruction) => ({ + account: "miner", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("miner"), [ + pdaSeedValueNode("quarry", accountValueNode("quarry")), + pdaSeedValueNode("authority", accountValueNode("authority")), + ]), + })), + + ...["claimRewardsMM", "claimRewards", "claimRewardsV2"].flatMap( + (instruction) => [ + { + account: "minter", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("minter"), [ + pdaSeedValueNode("wrapper", accountValueNode("mintWrapper")), + pdaSeedValueNode("authority", accountValueNode("rewarder")), + ]), + }, + { + account: "claimFeeTokenAccount", + instruction, + defaultValue: associatedTokenAccountValueNode({ + owner: accountValueNode("rewarder"), + mint: accountValueNode("rewardsTokenMint"), + }), + }, + ], + ), + + ...["claimRewardsMM", "stakePrimaryMiner", "stakeReplicaMiner"].map( + (instruction) => ({ + account: "miner", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("miner"), [ + pdaSeedValueNode("quarry", accountValueNode("quarry")), + pdaSeedValueNode("authority", accountValueNode("mm")), + ]), + }), + ), + + ...["newRewarder", "newRewarderV2"].flatMap((instruction) => [ + { + account: "rewarder", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("rewarder"), [ + pdaSeedValueNode("base", accountValueNode("base")), + ]), + }, + { + account: "initialAuthority", + instruction, + defaultValue: accountValueNode("payer"), + }, + ]), + + ...["stakePrimaryMiner", "stakeReplicaMiner"].flatMap((instruction) => [ + { + account: "mm", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("mergeMiner"), [ + pdaSeedValueNode("pool", accountValueNode("pool")), + pdaSeedValueNode("owner", accountValueNode("mmOwner")), + ]), + }, + ]), + ...["withdrawTokensMM", "initMergeMiner", "initMergeMinerV2"].flatMap( + (instruction) => [ + { + account: "mm", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("mergeMiner"), [ + pdaSeedValueNode("pool", accountValueNode("pool")), + pdaSeedValueNode("owner", accountValueNode("owner")), + ]), + }, + ], + ), + + { + account: "iouSource", + defaultValue: associatedTokenAccountValueNode({ + owner: accountValueNode("sourceAuthority"), + mint: accountValueNode("iouMint"), + }), + }, + { + account: "mmTokenAccount", + defaultValue: associatedTokenAccountValueNode({ + owner: accountValueNode("mm"), + mint: accountValueNode("withdrawMint"), + }), + }, + { + account: "rewardsTokenAccount", + defaultValue: associatedTokenAccountValueNode({ + owner: accountValueNode("mm"), + mint: accountValueNode("rewardsTokenMint"), + }), + }, + + ...["newWrapper", "newWrapperV2"].flatMap((instruction) => [ + { + account: "mintWrapper", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("mintWrapper"), [ + pdaSeedValueNode("base", accountValueNode("base")), + ]), + }, + { + account: "admin", + instruction, + defaultValue: accountValueNode("payer"), + }, + ]), + + ...["newMinter", "newMinterV2"].flatMap((instruction) => [ + { + account: "minter", + instruction, + defaultValue: pdaValueNode(pdaLinkNode("minter"), [ + pdaSeedValueNode("wrapper", accountValueNode("mintWrapper")), + pdaSeedValueNode( + "authority", + accountValueNode("newMinterAuthority"), + ), + ]), + }, + { + account: "newMinterAuthority", + instruction, + defaultValue: accountValueNode("payer"), + }, + ]), + ]), ], }); diff --git a/clients/quarry/src/generated/accounts/mergeMiner.ts b/clients/quarry/src/generated/accounts/mergeMiner.ts index 6c1abbff..bed22d2b 100644 --- a/clients/quarry/src/generated/accounts/mergeMiner.ts +++ b/clients/quarry/src/generated/accounts/mergeMiner.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { MergeMinerSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -40,6 +41,7 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMergeMinerPda } from "../pdas/index.js"; export const MERGE_MINER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 243, 97, 253, 80, 19, 210, 148, 120, @@ -154,3 +156,23 @@ export async function fetchAllMaybeMergeMiner( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeMergeMiner(maybeAccount)); } + +export async function fetchMergeMinerFromSeeds( + rpc: Parameters[0], + seeds: MergeMinerSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeMergeMinerFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeMergeMinerFromSeeds( + rpc: Parameters[0], + seeds: MergeMinerSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findMergeMinerPda(seeds, { programAddress }); + return await fetchMaybeMergeMiner(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/mergePool.ts b/clients/quarry/src/generated/accounts/mergePool.ts index a491ed2e..f64f83d0 100644 --- a/clients/quarry/src/generated/accounts/mergePool.ts +++ b/clients/quarry/src/generated/accounts/mergePool.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { MergePoolSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -42,6 +43,7 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMergePoolPda } from "../pdas/index.js"; export const MERGE_POOL_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 15, 189, 242, 87, 188, 75, 64, 244, @@ -157,3 +159,23 @@ export async function fetchAllMaybeMergePool( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeMergePool(maybeAccount)); } + +export async function fetchMergePoolFromSeeds( + rpc: Parameters[0], + seeds: MergePoolSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeMergePoolFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeMergePoolFromSeeds( + rpc: Parameters[0], + seeds: MergePoolSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findMergePoolPda(seeds, { programAddress }); + return await fetchMaybeMergePool(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/miner.ts b/clients/quarry/src/generated/accounts/miner.ts index ba1344d2..de1abfab 100644 --- a/clients/quarry/src/generated/accounts/miner.ts +++ b/clients/quarry/src/generated/accounts/miner.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { MinerSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -42,6 +43,7 @@ import { getU128Encoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda } from "../pdas/index.js"; export const MINER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 223, 113, 15, 54, 123, 122, 140, 100, @@ -161,3 +163,23 @@ export async function fetchAllMaybeMiner( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeMiner(maybeAccount)); } + +export async function fetchMinerFromSeeds( + rpc: Parameters[0], + seeds: MinerSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeMinerFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeMinerFromSeeds( + rpc: Parameters[0], + seeds: MinerSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findMinerPda(seeds, { programAddress }); + return await fetchMaybeMiner(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/mintWrapper.ts b/clients/quarry/src/generated/accounts/mintWrapper.ts index 74bb9d57..b2ae3271 100644 --- a/clients/quarry/src/generated/accounts/mintWrapper.ts +++ b/clients/quarry/src/generated/accounts/mintWrapper.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { MintWrapperSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -40,6 +41,7 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMintWrapperPda } from "../pdas/index.js"; export const MINT_WRAPPER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 154, 166, 64, 239, 170, 99, 74, 158, @@ -168,3 +170,23 @@ export async function fetchAllMaybeMintWrapper( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeMintWrapper(maybeAccount)); } + +export async function fetchMintWrapperFromSeeds( + rpc: Parameters[0], + seeds: MintWrapperSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeMintWrapperFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeMintWrapperFromSeeds( + rpc: Parameters[0], + seeds: MintWrapperSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findMintWrapperPda(seeds, { programAddress }); + return await fetchMaybeMintWrapper(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/minter.ts b/clients/quarry/src/generated/accounts/minter.ts index 7a9472c7..2ee2f30b 100644 --- a/clients/quarry/src/generated/accounts/minter.ts +++ b/clients/quarry/src/generated/accounts/minter.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { MinterSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -40,6 +41,7 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMinterPda } from "../pdas/index.js"; export const MINTER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 28, 69, 107, 166, 41, 139, 205, 247, @@ -151,3 +153,23 @@ export async function fetchAllMaybeMinter( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeMinter(maybeAccount)); } + +export async function fetchMinterFromSeeds( + rpc: Parameters[0], + seeds: MinterSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeMinterFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeMinterFromSeeds( + rpc: Parameters[0], + seeds: MinterSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findMinterPda(seeds, { programAddress }); + return await fetchMaybeMinter(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/operator.ts b/clients/quarry/src/generated/accounts/operator.ts index 393a8d67..59dc69b6 100644 --- a/clients/quarry/src/generated/accounts/operator.ts +++ b/clients/quarry/src/generated/accounts/operator.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { OperatorSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -42,6 +43,7 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findOperatorPda } from "../pdas/index.js"; export const OPERATOR_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 219, 31, 188, 145, 69, 139, 204, 117, @@ -165,3 +167,23 @@ export async function fetchAllMaybeOperator( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeOperator(maybeAccount)); } + +export async function fetchOperatorFromSeeds( + rpc: Parameters[0], + seeds: OperatorSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeOperatorFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeOperatorFromSeeds( + rpc: Parameters[0], + seeds: OperatorSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findOperatorPda(seeds, { programAddress }); + return await fetchMaybeOperator(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/quarry.ts b/clients/quarry/src/generated/accounts/quarry.ts index 426ed670..bbede5cf 100644 --- a/clients/quarry/src/generated/accounts/quarry.ts +++ b/clients/quarry/src/generated/accounts/quarry.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { QuarrySeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -46,6 +47,7 @@ import { getU128Encoder, transformEncoder, } from "@solana/kit"; +import { findQuarryPda } from "../pdas/index.js"; export const QUARRY_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 243, 248, 54, 182, 240, 85, 9, 77, @@ -181,3 +183,23 @@ export async function fetchAllMaybeQuarry( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeQuarry(maybeAccount)); } + +export async function fetchQuarryFromSeeds( + rpc: Parameters[0], + seeds: QuarrySeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeQuarryFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeQuarryFromSeeds( + rpc: Parameters[0], + seeds: QuarrySeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findQuarryPda(seeds, { programAddress }); + return await fetchMaybeQuarry(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/redeemer.ts b/clients/quarry/src/generated/accounts/redeemer.ts index 8d002040..6f2debd5 100644 --- a/clients/quarry/src/generated/accounts/redeemer.ts +++ b/clients/quarry/src/generated/accounts/redeemer.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { RedeemerSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -40,6 +41,7 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findRedeemerPda } from "../pdas/index.js"; export const REDEEMER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 41, 191, 197, 8, 98, 64, 17, 99, @@ -143,3 +145,23 @@ export async function fetchAllMaybeRedeemer( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeRedeemer(maybeAccount)); } + +export async function fetchRedeemerFromSeeds( + rpc: Parameters[0], + seeds: RedeemerSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeRedeemerFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeRedeemerFromSeeds( + rpc: Parameters[0], + seeds: RedeemerSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findRedeemerPda(seeds, { programAddress }); + return await fetchMaybeRedeemer(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/registry.ts b/clients/quarry/src/generated/accounts/registry.ts index 9498af8c..cee928a3 100644 --- a/clients/quarry/src/generated/accounts/registry.ts +++ b/clients/quarry/src/generated/accounts/registry.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { RegistrySeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -40,6 +41,7 @@ import { getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findRegistryPda } from "../pdas/index.js"; export const REGISTRY_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 47, 174, 110, 246, 184, 182, 252, 218, @@ -139,3 +141,23 @@ export async function fetchAllMaybeRegistry( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeRegistry(maybeAccount)); } + +export async function fetchRegistryFromSeeds( + rpc: Parameters[0], + seeds: RegistrySeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeRegistryFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeRegistryFromSeeds( + rpc: Parameters[0], + seeds: RegistrySeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findRegistryPda(seeds, { programAddress }); + return await fetchMaybeRegistry(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/accounts/rewarder.ts b/clients/quarry/src/generated/accounts/rewarder.ts index 268f1641..c8e28893 100644 --- a/clients/quarry/src/generated/accounts/rewarder.ts +++ b/clients/quarry/src/generated/accounts/rewarder.ts @@ -19,6 +19,7 @@ import type { MaybeEncodedAccount, ReadonlyUint8Array, } from "@solana/kit"; +import type { RewarderSeeds } from "../pdas/index.js"; import { assertAccountExists, assertAccountsExist, @@ -44,6 +45,7 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findRewarderPda } from "../pdas/index.js"; export const REWARDER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 83, 3, 203, 174, 244, 30, 172, 198, @@ -183,3 +185,23 @@ export async function fetchAllMaybeRewarder( const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config); return maybeAccounts.map((maybeAccount) => decodeRewarder(maybeAccount)); } + +export async function fetchRewarderFromSeeds( + rpc: Parameters[0], + seeds: RewarderSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const maybeAccount = await fetchMaybeRewarderFromSeeds(rpc, seeds, config); + assertAccountExists(maybeAccount); + return maybeAccount; +} + +export async function fetchMaybeRewarderFromSeeds( + rpc: Parameters[0], + seeds: RewarderSeeds, + config: FetchAccountConfig & { programAddress?: Address } = {}, +): Promise> { + const { programAddress, ...fetchConfig } = config; + const [address] = await findRewarderPda(seeds, { programAddress }); + return await fetchMaybeRewarder(rpc, address, fetchConfig); +} diff --git a/clients/quarry/src/generated/instructions/claimRewards.ts b/clients/quarry/src/generated/instructions/claimRewards.ts index a8732195..3ce14edf 100644 --- a/clients/quarry/src/generated/instructions/claimRewards.ts +++ b/clients/quarry/src/generated/instructions/claimRewards.ts @@ -24,17 +24,21 @@ import type { } from "@solana/kit"; import type { ResolvedAccount } from "../shared/index.js"; import { + address, combineCodec, fixDecoderSize, fixEncoderSize, + getAddressEncoder, getBytesDecoder, getBytesEncoder, + getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda, findMinterPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const CLAIM_REWARDS_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 4, 144, 132, 71, 116, 23, 151, 80, @@ -143,6 +147,202 @@ export function getClaimRewardsInstructionDataCodec(): FixedSizeCodec< ); } +export interface ClaimRewardsAsyncInput< + TAccountMintWrapper extends string = string, + TAccountMintWrapperProgram extends string = string, + TAccountMinter extends string = string, + TAccountRewardsTokenMint extends string = string, + TAccountRewardsTokenAccount extends string = string, + TAccountClaimFeeTokenAccount extends string = string, + TAccountAuthority extends string = string, + TAccountMiner extends string = string, + TAccountQuarry extends string = string, + TAccountUnusedMinerVault extends string = string, + TAccountUnusedTokenAccount extends string = string, + TAccountTokenProgram extends string = string, + TAccountRewarder extends string = string, +> { + mintWrapper: Address; + mintWrapperProgram?: Address; + minter?: Address; + rewardsTokenMint: Address; + rewardsTokenAccount: Address; + claimFeeTokenAccount?: Address; + authority: TransactionSigner; + miner?: Address; + quarry: Address; + unusedMinerVault: Address; + unusedTokenAccount: Address; + tokenProgram?: Address; + rewarder: Address; +} + +export async function getClaimRewardsInstructionAsync< + TAccountMintWrapper extends string, + TAccountMintWrapperProgram extends string, + TAccountMinter extends string, + TAccountRewardsTokenMint extends string, + TAccountRewardsTokenAccount extends string, + TAccountClaimFeeTokenAccount extends string, + TAccountAuthority extends string, + TAccountMiner extends string, + TAccountQuarry extends string, + TAccountUnusedMinerVault extends string, + TAccountUnusedTokenAccount extends string, + TAccountTokenProgram extends string, + TAccountRewarder extends string, + TProgramAddress extends Address = typeof QUARRY_MINE_PROGRAM_ADDRESS, +>( + input: ClaimRewardsAsyncInput< + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountUnusedMinerVault, + TAccountUnusedTokenAccount, + TAccountTokenProgram, + TAccountRewarder + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + ClaimRewardsInstruction< + TProgramAddress, + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountUnusedMinerVault, + TAccountUnusedTokenAccount, + TAccountTokenProgram, + TAccountRewarder + > +> { + // Program address. + const programAddress = config?.programAddress ?? QUARRY_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + mintWrapper: { value: input.mintWrapper ?? null, isWritable: true }, + mintWrapperProgram: { + value: input.mintWrapperProgram ?? null, + isWritable: false, + }, + minter: { value: input.minter ?? null, isWritable: true }, + rewardsTokenMint: { + value: input.rewardsTokenMint ?? null, + isWritable: true, + }, + rewardsTokenAccount: { + value: input.rewardsTokenAccount ?? null, + isWritable: true, + }, + claimFeeTokenAccount: { + value: input.claimFeeTokenAccount ?? null, + isWritable: true, + }, + authority: { value: input.authority ?? null, isWritable: false }, + miner: { value: input.miner ?? null, isWritable: true }, + quarry: { value: input.quarry ?? null, isWritable: true }, + unusedMinerVault: { + value: input.unusedMinerVault ?? null, + isWritable: false, + }, + unusedTokenAccount: { + value: input.unusedTokenAccount ?? null, + isWritable: false, + }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.mintWrapperProgram.value) { + accounts.mintWrapperProgram.value = + "QMWoBmAyJLAsA1Lh9ugMTw2gciTihncciphzdNzdZYV" as Address<"QMWoBmAyJLAsA1Lh9ugMTw2gciTihncciphzdNzdZYV">; + } + if (!accounts.minter.value) { + accounts.minter.value = await findMinterPda({ + wrapper: expectAddress(accounts.mintWrapper.value), + authority: expectAddress(accounts.rewarder.value), + }); + } + if (!accounts.claimFeeTokenAccount.value) { + accounts.claimFeeTokenAccount.value = await getProgramDerivedAddress({ + programAddress: + "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" as Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">, + seeds: [ + getAddressEncoder().encode(expectAddress(accounts.rewarder.value)), + getAddressEncoder().encode( + address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), + ), + getAddressEncoder().encode( + expectAddress(accounts.rewardsTokenMint.value), + ), + ], + }); + } + if (!accounts.miner.value) { + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.authority.value), + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.mintWrapper), + getAccountMeta(accounts.mintWrapperProgram), + getAccountMeta(accounts.minter), + getAccountMeta(accounts.rewardsTokenMint), + getAccountMeta(accounts.rewardsTokenAccount), + getAccountMeta(accounts.claimFeeTokenAccount), + getAccountMeta(accounts.authority), + getAccountMeta(accounts.miner), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.unusedMinerVault), + getAccountMeta(accounts.unusedTokenAccount), + getAccountMeta(accounts.tokenProgram), + getAccountMeta(accounts.rewarder), + ], + data: getClaimRewardsInstructionDataEncoder().encode({}), + programAddress, + } as ClaimRewardsInstruction< + TProgramAddress, + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountUnusedMinerVault, + TAccountUnusedTokenAccount, + TAccountTokenProgram, + TAccountRewarder + >); +} + export interface ClaimRewardsInput< TAccountMintWrapper extends string = string, TAccountMintWrapperProgram extends string = string, diff --git a/clients/quarry/src/generated/instructions/claimRewardsMM.ts b/clients/quarry/src/generated/instructions/claimRewardsMM.ts index cfd354f1..f521caae 100644 --- a/clients/quarry/src/generated/instructions/claimRewardsMM.ts +++ b/clients/quarry/src/generated/instructions/claimRewardsMM.ts @@ -21,17 +21,21 @@ import type { } from "@solana/kit"; import type { ResolvedAccount } from "../shared/index.js"; import { + address, combineCodec, fixDecoderSize, fixEncoderSize, + getAddressEncoder, getBytesDecoder, getBytesEncoder, + getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda, findMinterPda } from "../pdas/index.js"; import { QUARRY_MERGE_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const CLAIM_REWARDS_M_M_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([4, 144, 132, 71, 116, 23, 151, 80]); @@ -146,6 +150,235 @@ export function getClaimRewardsMMInstructionDataCodec(): FixedSizeCodec< ); } +export interface ClaimRewardsMMAsyncInput< + TAccountMintWrapper extends string = string, + TAccountMintWrapperProgram extends string = string, + TAccountMinter extends string = string, + TAccountRewardsTokenMint extends string = string, + TAccountRewardsTokenAccount extends string = string, + TAccountClaimFeeTokenAccount extends string = string, + TAccountStakeTokenAccount extends string = string, + TAccountPool extends string = string, + TAccountMm extends string = string, + TAccountRewarder extends string = string, + TAccountQuarry extends string = string, + TAccountMiner extends string = string, + TAccountMinerVault extends string = string, + TAccountTokenProgram extends string = string, + TAccountMineProgram extends string = string, +> { + mintWrapper: Address; + mintWrapperProgram?: Address; + minter?: Address; + rewardsTokenMint: Address; + rewardsTokenAccount?: Address; + claimFeeTokenAccount?: Address; + stakeTokenAccount: Address; + pool: Address; + mm: Address; + rewarder: Address; + quarry: Address; + miner?: Address; + minerVault: Address; + tokenProgram?: Address; + mineProgram?: Address; +} + +export async function getClaimRewardsMMInstructionAsync< + TAccountMintWrapper extends string, + TAccountMintWrapperProgram extends string, + TAccountMinter extends string, + TAccountRewardsTokenMint extends string, + TAccountRewardsTokenAccount extends string, + TAccountClaimFeeTokenAccount extends string, + TAccountStakeTokenAccount extends string, + TAccountPool extends string, + TAccountMm extends string, + TAccountRewarder extends string, + TAccountQuarry extends string, + TAccountMiner extends string, + TAccountMinerVault extends string, + TAccountTokenProgram extends string, + TAccountMineProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MERGE_MINE_PROGRAM_ADDRESS, +>( + input: ClaimRewardsMMAsyncInput< + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountStakeTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + ClaimRewardsMMInstruction< + TProgramAddress, + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountStakeTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_MERGE_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + mintWrapper: { value: input.mintWrapper ?? null, isWritable: true }, + mintWrapperProgram: { + value: input.mintWrapperProgram ?? null, + isWritable: false, + }, + minter: { value: input.minter ?? null, isWritable: true }, + rewardsTokenMint: { + value: input.rewardsTokenMint ?? null, + isWritable: true, + }, + rewardsTokenAccount: { + value: input.rewardsTokenAccount ?? null, + isWritable: true, + }, + claimFeeTokenAccount: { + value: input.claimFeeTokenAccount ?? null, + isWritable: true, + }, + stakeTokenAccount: { + value: input.stakeTokenAccount ?? null, + isWritable: true, + }, + pool: { value: input.pool ?? null, isWritable: true }, + mm: { value: input.mm ?? null, isWritable: true }, + rewarder: { value: input.rewarder ?? null, isWritable: false }, + quarry: { value: input.quarry ?? null, isWritable: true }, + miner: { value: input.miner ?? null, isWritable: true }, + minerVault: { value: input.minerVault ?? null, isWritable: true }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + mineProgram: { value: input.mineProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.mintWrapperProgram.value) { + accounts.mintWrapperProgram.value = + "QMWoBmAyJLAsA1Lh9ugMTw2gciTihncciphzdNzdZYV" as Address<"QMWoBmAyJLAsA1Lh9ugMTw2gciTihncciphzdNzdZYV">; + } + if (!accounts.minter.value) { + accounts.minter.value = await findMinterPda({ + wrapper: expectAddress(accounts.mintWrapper.value), + authority: expectAddress(accounts.rewarder.value), + }); + } + if (!accounts.rewardsTokenAccount.value) { + accounts.rewardsTokenAccount.value = await getProgramDerivedAddress({ + programAddress: + "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" as Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">, + seeds: [ + getAddressEncoder().encode(expectAddress(accounts.mm.value)), + getAddressEncoder().encode( + address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), + ), + getAddressEncoder().encode( + expectAddress(accounts.rewardsTokenMint.value), + ), + ], + }); + } + if (!accounts.claimFeeTokenAccount.value) { + accounts.claimFeeTokenAccount.value = await getProgramDerivedAddress({ + programAddress: + "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" as Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">, + seeds: [ + getAddressEncoder().encode(expectAddress(accounts.rewarder.value)), + getAddressEncoder().encode( + address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), + ), + getAddressEncoder().encode( + expectAddress(accounts.rewardsTokenMint.value), + ), + ], + }); + } + if (!accounts.miner.value) { + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.mm.value), + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + if (!accounts.mineProgram.value) { + accounts.mineProgram.value = + "QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB" as Address<"QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.mintWrapper), + getAccountMeta(accounts.mintWrapperProgram), + getAccountMeta(accounts.minter), + getAccountMeta(accounts.rewardsTokenMint), + getAccountMeta(accounts.rewardsTokenAccount), + getAccountMeta(accounts.claimFeeTokenAccount), + getAccountMeta(accounts.stakeTokenAccount), + getAccountMeta(accounts.pool), + getAccountMeta(accounts.mm), + getAccountMeta(accounts.rewarder), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.miner), + getAccountMeta(accounts.minerVault), + getAccountMeta(accounts.tokenProgram), + getAccountMeta(accounts.mineProgram), + ], + data: getClaimRewardsMMInstructionDataEncoder().encode({}), + programAddress, + } as ClaimRewardsMMInstruction< + TProgramAddress, + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountStakeTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + >); +} + export interface ClaimRewardsMMInput< TAccountMintWrapper extends string = string, TAccountMintWrapperProgram extends string = string, diff --git a/clients/quarry/src/generated/instructions/claimRewardsV2.ts b/clients/quarry/src/generated/instructions/claimRewardsV2.ts index 60191044..52e47ab1 100644 --- a/clients/quarry/src/generated/instructions/claimRewardsV2.ts +++ b/clients/quarry/src/generated/instructions/claimRewardsV2.ts @@ -24,17 +24,21 @@ import type { } from "@solana/kit"; import type { ResolvedAccount } from "../shared/index.js"; import { + address, combineCodec, fixDecoderSize, fixEncoderSize, + getAddressEncoder, getBytesDecoder, getBytesEncoder, + getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda, findMinterPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const CLAIM_REWARDS_V2_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([69, 49, 158, 229, 212, 133, 136, 227]); @@ -134,6 +138,180 @@ export function getClaimRewardsV2InstructionDataCodec(): FixedSizeCodec< ); } +export interface ClaimRewardsV2AsyncInput< + TAccountMintWrapper extends string = string, + TAccountMintWrapperProgram extends string = string, + TAccountMinter extends string = string, + TAccountRewardsTokenMint extends string = string, + TAccountRewardsTokenAccount extends string = string, + TAccountClaimFeeTokenAccount extends string = string, + TAccountAuthority extends string = string, + TAccountMiner extends string = string, + TAccountQuarry extends string = string, + TAccountTokenProgram extends string = string, + TAccountRewarder extends string = string, +> { + mintWrapper: Address; + mintWrapperProgram?: Address; + minter?: Address; + rewardsTokenMint: Address; + rewardsTokenAccount: Address; + claimFeeTokenAccount?: Address; + authority: TransactionSigner; + miner?: Address; + quarry: Address; + tokenProgram?: Address; + rewarder: Address; +} + +export async function getClaimRewardsV2InstructionAsync< + TAccountMintWrapper extends string, + TAccountMintWrapperProgram extends string, + TAccountMinter extends string, + TAccountRewardsTokenMint extends string, + TAccountRewardsTokenAccount extends string, + TAccountClaimFeeTokenAccount extends string, + TAccountAuthority extends string, + TAccountMiner extends string, + TAccountQuarry extends string, + TAccountTokenProgram extends string, + TAccountRewarder extends string, + TProgramAddress extends Address = typeof QUARRY_MINE_PROGRAM_ADDRESS, +>( + input: ClaimRewardsV2AsyncInput< + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountTokenProgram, + TAccountRewarder + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + ClaimRewardsV2Instruction< + TProgramAddress, + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountTokenProgram, + TAccountRewarder + > +> { + // Program address. + const programAddress = config?.programAddress ?? QUARRY_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + mintWrapper: { value: input.mintWrapper ?? null, isWritable: true }, + mintWrapperProgram: { + value: input.mintWrapperProgram ?? null, + isWritable: false, + }, + minter: { value: input.minter ?? null, isWritable: true }, + rewardsTokenMint: { + value: input.rewardsTokenMint ?? null, + isWritable: true, + }, + rewardsTokenAccount: { + value: input.rewardsTokenAccount ?? null, + isWritable: true, + }, + claimFeeTokenAccount: { + value: input.claimFeeTokenAccount ?? null, + isWritable: true, + }, + authority: { value: input.authority ?? null, isWritable: false }, + miner: { value: input.miner ?? null, isWritable: true }, + quarry: { value: input.quarry ?? null, isWritable: true }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.mintWrapperProgram.value) { + accounts.mintWrapperProgram.value = + "QMWoBmAyJLAsA1Lh9ugMTw2gciTihncciphzdNzdZYV" as Address<"QMWoBmAyJLAsA1Lh9ugMTw2gciTihncciphzdNzdZYV">; + } + if (!accounts.minter.value) { + accounts.minter.value = await findMinterPda({ + wrapper: expectAddress(accounts.mintWrapper.value), + authority: expectAddress(accounts.rewarder.value), + }); + } + if (!accounts.claimFeeTokenAccount.value) { + accounts.claimFeeTokenAccount.value = await getProgramDerivedAddress({ + programAddress: + "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" as Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">, + seeds: [ + getAddressEncoder().encode(expectAddress(accounts.rewarder.value)), + getAddressEncoder().encode( + address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), + ), + getAddressEncoder().encode( + expectAddress(accounts.rewardsTokenMint.value), + ), + ], + }); + } + if (!accounts.miner.value) { + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.authority.value), + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.mintWrapper), + getAccountMeta(accounts.mintWrapperProgram), + getAccountMeta(accounts.minter), + getAccountMeta(accounts.rewardsTokenMint), + getAccountMeta(accounts.rewardsTokenAccount), + getAccountMeta(accounts.claimFeeTokenAccount), + getAccountMeta(accounts.authority), + getAccountMeta(accounts.miner), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.tokenProgram), + getAccountMeta(accounts.rewarder), + ], + data: getClaimRewardsV2InstructionDataEncoder().encode({}), + programAddress, + } as ClaimRewardsV2Instruction< + TProgramAddress, + TAccountMintWrapper, + TAccountMintWrapperProgram, + TAccountMinter, + TAccountRewardsTokenMint, + TAccountRewardsTokenAccount, + TAccountClaimFeeTokenAccount, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountTokenProgram, + TAccountRewarder + >); +} + export interface ClaimRewardsV2Input< TAccountMintWrapper extends string = string, TAccountMintWrapperProgram extends string = string, diff --git a/clients/quarry/src/generated/instructions/createMiner.ts b/clients/quarry/src/generated/instructions/createMiner.ts index 2b457429..cdc6f717 100644 --- a/clients/quarry/src/generated/instructions/createMiner.ts +++ b/clients/quarry/src/generated/instructions/createMiner.ts @@ -28,16 +28,15 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU8Decoder, getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; @@ -226,15 +225,9 @@ export async function getCreateMinerInstructionAsync< // Resolve default values. if (!accounts.miner.value) { - accounts.miner.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([34, 77, 105, 110, 101, 114, 34]), - ), - getAddressEncoder().encode(expectAddress(accounts.quarry.value)), - getAddressEncoder().encode(expectAddress(accounts.authority.value)), - ], + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.authority.value), }); } if (!accounts.systemProgram.value) { diff --git a/clients/quarry/src/generated/instructions/createMinerV2.ts b/clients/quarry/src/generated/instructions/createMinerV2.ts index df56378f..e25e6b95 100644 --- a/clients/quarry/src/generated/instructions/createMinerV2.ts +++ b/clients/quarry/src/generated/instructions/createMinerV2.ts @@ -28,14 +28,13 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; @@ -213,15 +212,9 @@ export async function getCreateMinerV2InstructionAsync< // Resolve default values. if (!accounts.miner.value) { - accounts.miner.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([34, 77, 105, 110, 101, 114, 34]), - ), - getAddressEncoder().encode(expectAddress(accounts.quarry.value)), - getAddressEncoder().encode(expectAddress(accounts.authority.value)), - ], + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.authority.value), }); } if (!accounts.systemProgram.value) { diff --git a/clients/quarry/src/generated/instructions/createOperator.ts b/clients/quarry/src/generated/instructions/createOperator.ts index 3d233e6d..acec68dc 100644 --- a/clients/quarry/src/generated/instructions/createOperator.ts +++ b/clients/quarry/src/generated/instructions/createOperator.ts @@ -28,16 +28,15 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU8Decoder, getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findOperatorPda } from "../pdas/index.js"; import { QUARRY_OPERATOR_PROGRAM_ADDRESS } from "../programs/index.js"; import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; @@ -209,14 +208,8 @@ export async function getCreateOperatorInstructionAsync< // Resolve default values. if (!accounts.operator.value) { - accounts.operator.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([34, 79, 112, 101, 114, 97, 116, 111, 114, 34]), - ), - getAddressEncoder().encode(expectAddress(accounts.base.value)), - ], + accounts.operator.value = await findOperatorPda({ + base: expectAddress(accounts.base.value), }); } if (!accounts.systemProgram.value) { diff --git a/clients/quarry/src/generated/instructions/createOperatorV2.ts b/clients/quarry/src/generated/instructions/createOperatorV2.ts index c6183214..de6000ae 100644 --- a/clients/quarry/src/generated/instructions/createOperatorV2.ts +++ b/clients/quarry/src/generated/instructions/createOperatorV2.ts @@ -28,14 +28,13 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findOperatorPda } from "../pdas/index.js"; import { QUARRY_OPERATOR_PROGRAM_ADDRESS } from "../programs/index.js"; import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; @@ -195,14 +194,8 @@ export async function getCreateOperatorV2InstructionAsync< // Resolve default values. if (!accounts.operator.value) { - accounts.operator.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([34, 79, 112, 101, 114, 97, 116, 111, 114, 34]), - ), - getAddressEncoder().encode(expectAddress(accounts.base.value)), - ], + accounts.operator.value = await findOperatorPda({ + base: expectAddress(accounts.base.value), }); } if (!accounts.systemProgram.value) { diff --git a/clients/quarry/src/generated/instructions/createQuarry.ts b/clients/quarry/src/generated/instructions/createQuarry.ts index 688687a6..fb6c6f11 100644 --- a/clients/quarry/src/generated/instructions/createQuarry.ts +++ b/clients/quarry/src/generated/instructions/createQuarry.ts @@ -36,8 +36,9 @@ import { getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findQuarryPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const CREATE_QUARRY_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 18, 113, 223, 132, 105, 208, 102, 93, @@ -128,6 +129,117 @@ export function getCreateQuarryInstructionDataCodec(): FixedSizeCodec< ); } +export interface CreateQuarryAsyncInput< + TAccountQuarry extends string = string, + TAccountAuthority extends string = string, + TAccountRewarder extends string = string, + TAccountTokenMint extends string = string, + TAccountPayer extends string = string, + TAccountUnusedAccount extends string = string, + TAccountSystemProgram extends string = string, +> { + quarry?: Address; + authority: TransactionSigner; + rewarder: Address; + tokenMint: Address; + payer: TransactionSigner; + unusedAccount: Address; + systemProgram?: Address; + bump: CreateQuarryInstructionDataArgs["bump"]; +} + +export async function getCreateQuarryInstructionAsync< + TAccountQuarry extends string, + TAccountAuthority extends string, + TAccountRewarder extends string, + TAccountTokenMint extends string, + TAccountPayer extends string, + TAccountUnusedAccount extends string, + TAccountSystemProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MINE_PROGRAM_ADDRESS, +>( + input: CreateQuarryAsyncInput< + TAccountQuarry, + TAccountAuthority, + TAccountRewarder, + TAccountTokenMint, + TAccountPayer, + TAccountUnusedAccount, + TAccountSystemProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + CreateQuarryInstruction< + TProgramAddress, + TAccountQuarry, + TAccountAuthority, + TAccountRewarder, + TAccountTokenMint, + TAccountPayer, + TAccountUnusedAccount, + TAccountSystemProgram + > +> { + // Program address. + const programAddress = config?.programAddress ?? QUARRY_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + quarry: { value: input.quarry ?? null, isWritable: true }, + authority: { value: input.authority ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: true }, + tokenMint: { value: input.tokenMint ?? null, isWritable: false }, + payer: { value: input.payer ?? null, isWritable: true }, + unusedAccount: { value: input.unusedAccount ?? null, isWritable: false }, + systemProgram: { value: input.systemProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Original args. + const args = { ...input }; + + // Resolve default values. + if (!accounts.quarry.value) { + accounts.quarry.value = await findQuarryPda({ + rewarder: expectAddress(accounts.rewarder.value), + tokenMint: expectAddress(accounts.tokenMint.value), + }); + } + if (!accounts.systemProgram.value) { + accounts.systemProgram.value = + "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.authority), + getAccountMeta(accounts.rewarder), + getAccountMeta(accounts.tokenMint), + getAccountMeta(accounts.payer), + getAccountMeta(accounts.unusedAccount), + getAccountMeta(accounts.systemProgram), + ], + data: getCreateQuarryInstructionDataEncoder().encode( + args as CreateQuarryInstructionDataArgs, + ), + programAddress, + } as CreateQuarryInstruction< + TProgramAddress, + TAccountQuarry, + TAccountAuthority, + TAccountRewarder, + TAccountTokenMint, + TAccountPayer, + TAccountUnusedAccount, + TAccountSystemProgram + >); +} + export interface CreateQuarryInput< TAccountQuarry extends string = string, TAccountAuthority extends string = string, diff --git a/clients/quarry/src/generated/instructions/createQuarryV2.ts b/clients/quarry/src/generated/instructions/createQuarryV2.ts index 2029afdb..dd7137bf 100644 --- a/clients/quarry/src/generated/instructions/createQuarryV2.ts +++ b/clients/quarry/src/generated/instructions/createQuarryV2.ts @@ -34,8 +34,9 @@ import { getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findQuarryPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const CREATE_QUARRY_V2_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([46, 84, 33, 67, 174, 252, 67, 148]); @@ -114,6 +115,103 @@ export function getCreateQuarryV2InstructionDataCodec(): FixedSizeCodec< ); } +export interface CreateQuarryV2AsyncInput< + TAccountQuarry extends string = string, + TAccountAuthority extends string = string, + TAccountRewarder extends string = string, + TAccountTokenMint extends string = string, + TAccountPayer extends string = string, + TAccountSystemProgram extends string = string, +> { + quarry?: Address; + authority: TransactionSigner; + rewarder: Address; + tokenMint: Address; + payer: TransactionSigner; + systemProgram?: Address; +} + +export async function getCreateQuarryV2InstructionAsync< + TAccountQuarry extends string, + TAccountAuthority extends string, + TAccountRewarder extends string, + TAccountTokenMint extends string, + TAccountPayer extends string, + TAccountSystemProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MINE_PROGRAM_ADDRESS, +>( + input: CreateQuarryV2AsyncInput< + TAccountQuarry, + TAccountAuthority, + TAccountRewarder, + TAccountTokenMint, + TAccountPayer, + TAccountSystemProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + CreateQuarryV2Instruction< + TProgramAddress, + TAccountQuarry, + TAccountAuthority, + TAccountRewarder, + TAccountTokenMint, + TAccountPayer, + TAccountSystemProgram + > +> { + // Program address. + const programAddress = config?.programAddress ?? QUARRY_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + quarry: { value: input.quarry ?? null, isWritable: true }, + authority: { value: input.authority ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: true }, + tokenMint: { value: input.tokenMint ?? null, isWritable: false }, + payer: { value: input.payer ?? null, isWritable: true }, + systemProgram: { value: input.systemProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.quarry.value) { + accounts.quarry.value = await findQuarryPda({ + rewarder: expectAddress(accounts.rewarder.value), + tokenMint: expectAddress(accounts.tokenMint.value), + }); + } + if (!accounts.systemProgram.value) { + accounts.systemProgram.value = + "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.authority), + getAccountMeta(accounts.rewarder), + getAccountMeta(accounts.tokenMint), + getAccountMeta(accounts.payer), + getAccountMeta(accounts.systemProgram), + ], + data: getCreateQuarryV2InstructionDataEncoder().encode({}), + programAddress, + } as CreateQuarryV2Instruction< + TProgramAddress, + TAccountQuarry, + TAccountAuthority, + TAccountRewarder, + TAccountTokenMint, + TAccountPayer, + TAccountSystemProgram + >); +} + export interface CreateQuarryV2Input< TAccountQuarry extends string = string, TAccountAuthority extends string = string, diff --git a/clients/quarry/src/generated/instructions/delegateCreateQuarry.ts b/clients/quarry/src/generated/instructions/delegateCreateQuarry.ts index 51bf50b1..6199edb0 100644 --- a/clients/quarry/src/generated/instructions/delegateCreateQuarry.ts +++ b/clients/quarry/src/generated/instructions/delegateCreateQuarry.ts @@ -36,8 +36,9 @@ import { getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findQuarryPda } from "../pdas/index.js"; import { QUARRY_OPERATOR_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const DELEGATE_CREATE_QUARRY_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([245, 238, 31, 14, 175, 233, 75, 237]); @@ -140,6 +141,141 @@ export function getDelegateCreateQuarryInstructionDataCodec(): FixedSizeCodec< ); } +export interface DelegateCreateQuarryAsyncInput< + TAccountOperator extends string = string, + TAccountDelegate extends string = string, + TAccountRewarder extends string = string, + TAccountQuarryMineProgram extends string = string, + TAccountQuarry extends string = string, + TAccountTokenMint extends string = string, + TAccountPayer extends string = string, + TAccountUnusedAccount extends string = string, + TAccountSystemProgram extends string = string, +> { + operator: Address; + delegate: TransactionSigner; + rewarder: Address; + quarryMineProgram?: Address; + quarry?: Address; + tokenMint: Address; + payer: TransactionSigner; + unusedAccount: Address; + systemProgram?: Address; + bump: DelegateCreateQuarryInstructionDataArgs["bump"]; +} + +export async function getDelegateCreateQuarryInstructionAsync< + TAccountOperator extends string, + TAccountDelegate extends string, + TAccountRewarder extends string, + TAccountQuarryMineProgram extends string, + TAccountQuarry extends string, + TAccountTokenMint extends string, + TAccountPayer extends string, + TAccountUnusedAccount extends string, + TAccountSystemProgram extends string, + TProgramAddress extends Address = typeof QUARRY_OPERATOR_PROGRAM_ADDRESS, +>( + input: DelegateCreateQuarryAsyncInput< + TAccountOperator, + TAccountDelegate, + TAccountRewarder, + TAccountQuarryMineProgram, + TAccountQuarry, + TAccountTokenMint, + TAccountPayer, + TAccountUnusedAccount, + TAccountSystemProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + DelegateCreateQuarryInstruction< + TProgramAddress, + TAccountOperator, + TAccountDelegate, + TAccountRewarder, + TAccountQuarryMineProgram, + TAccountQuarry, + TAccountTokenMint, + TAccountPayer, + TAccountUnusedAccount, + TAccountSystemProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_OPERATOR_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + operator: { value: input.operator ?? null, isWritable: true }, + delegate: { value: input.delegate ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: true }, + quarryMineProgram: { + value: input.quarryMineProgram ?? null, + isWritable: false, + }, + quarry: { value: input.quarry ?? null, isWritable: true }, + tokenMint: { value: input.tokenMint ?? null, isWritable: false }, + payer: { value: input.payer ?? null, isWritable: true }, + unusedAccount: { value: input.unusedAccount ?? null, isWritable: false }, + systemProgram: { value: input.systemProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Original args. + const args = { ...input }; + + // Resolve default values. + if (!accounts.quarryMineProgram.value) { + accounts.quarryMineProgram.value = + "QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB" as Address<"QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB">; + } + if (!accounts.quarry.value) { + accounts.quarry.value = await findQuarryPda({ + rewarder: expectAddress(accounts.rewarder.value), + tokenMint: expectAddress(accounts.tokenMint.value), + }); + } + if (!accounts.systemProgram.value) { + accounts.systemProgram.value = + "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.operator), + getAccountMeta(accounts.delegate), + getAccountMeta(accounts.rewarder), + getAccountMeta(accounts.quarryMineProgram), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.tokenMint), + getAccountMeta(accounts.payer), + getAccountMeta(accounts.unusedAccount), + getAccountMeta(accounts.systemProgram), + ], + data: getDelegateCreateQuarryInstructionDataEncoder().encode( + args as DelegateCreateQuarryInstructionDataArgs, + ), + programAddress, + } as DelegateCreateQuarryInstruction< + TProgramAddress, + TAccountOperator, + TAccountDelegate, + TAccountRewarder, + TAccountQuarryMineProgram, + TAccountQuarry, + TAccountTokenMint, + TAccountPayer, + TAccountUnusedAccount, + TAccountSystemProgram + >); +} + export interface DelegateCreateQuarryInput< TAccountOperator extends string = string, TAccountDelegate extends string = string, diff --git a/clients/quarry/src/generated/instructions/delegateCreateQuarryV2.ts b/clients/quarry/src/generated/instructions/delegateCreateQuarryV2.ts index b4990077..dad5f79f 100644 --- a/clients/quarry/src/generated/instructions/delegateCreateQuarryV2.ts +++ b/clients/quarry/src/generated/instructions/delegateCreateQuarryV2.ts @@ -34,8 +34,9 @@ import { getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findQuarryPda } from "../pdas/index.js"; import { QUARRY_OPERATOR_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const DELEGATE_CREATE_QUARRY_V2_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([69, 180, 9, 212, 75, 142, 202, 62]); @@ -127,6 +128,127 @@ export function getDelegateCreateQuarryV2InstructionDataCodec(): FixedSizeCodec< ); } +export interface DelegateCreateQuarryV2AsyncInput< + TAccountOperator extends string = string, + TAccountDelegate extends string = string, + TAccountRewarder extends string = string, + TAccountQuarryMineProgram extends string = string, + TAccountQuarry extends string = string, + TAccountTokenMint extends string = string, + TAccountPayer extends string = string, + TAccountSystemProgram extends string = string, +> { + operator: Address; + delegate: TransactionSigner; + rewarder: Address; + quarryMineProgram?: Address; + quarry?: Address; + tokenMint: Address; + payer: TransactionSigner; + systemProgram?: Address; +} + +export async function getDelegateCreateQuarryV2InstructionAsync< + TAccountOperator extends string, + TAccountDelegate extends string, + TAccountRewarder extends string, + TAccountQuarryMineProgram extends string, + TAccountQuarry extends string, + TAccountTokenMint extends string, + TAccountPayer extends string, + TAccountSystemProgram extends string, + TProgramAddress extends Address = typeof QUARRY_OPERATOR_PROGRAM_ADDRESS, +>( + input: DelegateCreateQuarryV2AsyncInput< + TAccountOperator, + TAccountDelegate, + TAccountRewarder, + TAccountQuarryMineProgram, + TAccountQuarry, + TAccountTokenMint, + TAccountPayer, + TAccountSystemProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + DelegateCreateQuarryV2Instruction< + TProgramAddress, + TAccountOperator, + TAccountDelegate, + TAccountRewarder, + TAccountQuarryMineProgram, + TAccountQuarry, + TAccountTokenMint, + TAccountPayer, + TAccountSystemProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_OPERATOR_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + operator: { value: input.operator ?? null, isWritable: true }, + delegate: { value: input.delegate ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: true }, + quarryMineProgram: { + value: input.quarryMineProgram ?? null, + isWritable: false, + }, + quarry: { value: input.quarry ?? null, isWritable: true }, + tokenMint: { value: input.tokenMint ?? null, isWritable: false }, + payer: { value: input.payer ?? null, isWritable: true }, + systemProgram: { value: input.systemProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.quarryMineProgram.value) { + accounts.quarryMineProgram.value = + "QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB" as Address<"QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB">; + } + if (!accounts.quarry.value) { + accounts.quarry.value = await findQuarryPda({ + rewarder: expectAddress(accounts.rewarder.value), + tokenMint: expectAddress(accounts.tokenMint.value), + }); + } + if (!accounts.systemProgram.value) { + accounts.systemProgram.value = + "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.operator), + getAccountMeta(accounts.delegate), + getAccountMeta(accounts.rewarder), + getAccountMeta(accounts.quarryMineProgram), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.tokenMint), + getAccountMeta(accounts.payer), + getAccountMeta(accounts.systemProgram), + ], + data: getDelegateCreateQuarryV2InstructionDataEncoder().encode({}), + programAddress, + } as DelegateCreateQuarryV2Instruction< + TProgramAddress, + TAccountOperator, + TAccountDelegate, + TAccountRewarder, + TAccountQuarryMineProgram, + TAccountQuarry, + TAccountTokenMint, + TAccountPayer, + TAccountSystemProgram + >); +} + export interface DelegateCreateQuarryV2Input< TAccountOperator extends string = string, TAccountDelegate extends string = string, diff --git a/clients/quarry/src/generated/instructions/initMergeMiner.ts b/clients/quarry/src/generated/instructions/initMergeMiner.ts index 25df80ce..2023e41e 100644 --- a/clients/quarry/src/generated/instructions/initMergeMiner.ts +++ b/clients/quarry/src/generated/instructions/initMergeMiner.ts @@ -27,16 +27,15 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU8Decoder, getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findMergeMinerPda } from "../pdas/index.js"; import { QUARRY_MERGE_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; @@ -180,17 +179,9 @@ export async function getInitMergeMinerInstructionAsync< // Resolve default values. if (!accounts.mm.value) { - accounts.mm.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([ - 34, 77, 101, 114, 103, 101, 77, 105, 110, 101, 114, 34, - ]), - ), - getAddressEncoder().encode(expectAddress(accounts.pool.value)), - getAddressEncoder().encode(expectAddress(accounts.owner.value)), - ], + accounts.mm.value = await findMergeMinerPda({ + pool: expectAddress(accounts.pool.value), + owner: expectAddress(accounts.owner.value), }); } if (!accounts.systemProgram.value) { diff --git a/clients/quarry/src/generated/instructions/initMergeMinerV2.ts b/clients/quarry/src/generated/instructions/initMergeMinerV2.ts index f386312e..40067eed 100644 --- a/clients/quarry/src/generated/instructions/initMergeMinerV2.ts +++ b/clients/quarry/src/generated/instructions/initMergeMinerV2.ts @@ -27,14 +27,13 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMergeMinerPda } from "../pdas/index.js"; import { QUARRY_MERGE_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; @@ -167,17 +166,9 @@ export async function getInitMergeMinerV2InstructionAsync< // Resolve default values. if (!accounts.mm.value) { - accounts.mm.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([ - 34, 77, 101, 114, 103, 101, 77, 105, 110, 101, 114, 34, - ]), - ), - getAddressEncoder().encode(expectAddress(accounts.pool.value)), - getAddressEncoder().encode(expectAddress(accounts.owner.value)), - ], + accounts.mm.value = await findMergeMinerPda({ + pool: expectAddress(accounts.pool.value), + owner: expectAddress(accounts.owner.value), }); } if (!accounts.systemProgram.value) { diff --git a/clients/quarry/src/generated/instructions/newMinter.ts b/clients/quarry/src/generated/instructions/newMinter.ts index 896cc631..178bfec2 100644 --- a/clients/quarry/src/generated/instructions/newMinter.ts +++ b/clients/quarry/src/generated/instructions/newMinter.ts @@ -36,8 +36,13 @@ import { getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findMinterPda } from "../pdas/index.js"; import { QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { + expectAddress, + expectTransactionSigner, + getAccountMetaFactory, +} from "../shared/index.js"; export const NEW_MINTER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 14, 95, 216, 55, 122, 115, 37, 250, @@ -122,6 +127,118 @@ export function getNewMinterInstructionDataCodec(): FixedSizeCodec< ); } +export interface NewMinterAsyncInput< + TAccountMintWrapper extends string = string, + TAccountAdmin extends string = string, + TAccountNewMinterAuthority extends string = string, + TAccountMinter extends string = string, + TAccountPayer extends string = string, + TAccountSystemProgram extends string = string, +> { + mintWrapper: Address; + admin: TransactionSigner; + newMinterAuthority?: Address; + minter?: Address; + payer: TransactionSigner; + systemProgram?: Address; + bump: NewMinterInstructionDataArgs["bump"]; +} + +export async function getNewMinterInstructionAsync< + TAccountMintWrapper extends string, + TAccountAdmin extends string, + TAccountNewMinterAuthority extends string, + TAccountMinter extends string, + TAccountPayer extends string, + TAccountSystemProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS, +>( + input: NewMinterAsyncInput< + TAccountMintWrapper, + TAccountAdmin, + TAccountNewMinterAuthority, + TAccountMinter, + TAccountPayer, + TAccountSystemProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + NewMinterInstruction< + TProgramAddress, + TAccountMintWrapper, + TAccountAdmin, + TAccountNewMinterAuthority, + TAccountMinter, + TAccountPayer, + TAccountSystemProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + mintWrapper: { value: input.mintWrapper ?? null, isWritable: true }, + admin: { value: input.admin ?? null, isWritable: false }, + newMinterAuthority: { + value: input.newMinterAuthority ?? null, + isWritable: false, + }, + minter: { value: input.minter ?? null, isWritable: true }, + payer: { value: input.payer ?? null, isWritable: true }, + systemProgram: { value: input.systemProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Original args. + const args = { ...input }; + + // Resolve default values. + if (!accounts.newMinterAuthority.value) { + accounts.newMinterAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } + if (!accounts.minter.value) { + accounts.minter.value = await findMinterPda({ + wrapper: expectAddress(accounts.mintWrapper.value), + authority: expectAddress(accounts.newMinterAuthority.value), + }); + } + if (!accounts.systemProgram.value) { + accounts.systemProgram.value = + "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.mintWrapper), + getAccountMeta(accounts.admin), + getAccountMeta(accounts.newMinterAuthority), + getAccountMeta(accounts.minter), + getAccountMeta(accounts.payer), + getAccountMeta(accounts.systemProgram), + ], + data: getNewMinterInstructionDataEncoder().encode( + args as NewMinterInstructionDataArgs, + ), + programAddress, + } as NewMinterInstruction< + TProgramAddress, + TAccountMintWrapper, + TAccountAdmin, + TAccountNewMinterAuthority, + TAccountMinter, + TAccountPayer, + TAccountSystemProgram + >); +} + export interface NewMinterInput< TAccountMintWrapper extends string = string, TAccountAdmin extends string = string, @@ -132,7 +249,7 @@ export interface NewMinterInput< > { mintWrapper: Address; admin: TransactionSigner; - newMinterAuthority: Address; + newMinterAuthority?: Address; minter: Address; payer: TransactionSigner; systemProgram?: Address; @@ -191,6 +308,11 @@ export function getNewMinterInstruction< const args = { ...input }; // Resolve default values. + if (!accounts.newMinterAuthority.value) { + accounts.newMinterAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.systemProgram.value) { accounts.systemProgram.value = "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; diff --git a/clients/quarry/src/generated/instructions/newMinterV2.ts b/clients/quarry/src/generated/instructions/newMinterV2.ts index e7d6f392..074cd7eb 100644 --- a/clients/quarry/src/generated/instructions/newMinterV2.ts +++ b/clients/quarry/src/generated/instructions/newMinterV2.ts @@ -34,8 +34,13 @@ import { getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMinterPda } from "../pdas/index.js"; import { QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { + expectAddress, + expectTransactionSigner, + getAccountMetaFactory, +} from "../shared/index.js"; export const NEW_MINTER_V2_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 7, 93, 245, 202, 126, 212, 61, 195, @@ -115,6 +120,112 @@ export function getNewMinterV2InstructionDataCodec(): FixedSizeCodec< ); } +export interface NewMinterV2AsyncInput< + TAccountMintWrapper extends string = string, + TAccountAdmin extends string = string, + TAccountNewMinterAuthority extends string = string, + TAccountMinter extends string = string, + TAccountPayer extends string = string, + TAccountSystemProgram extends string = string, +> { + mintWrapper: Address; + admin: TransactionSigner; + newMinterAuthority?: Address; + minter?: Address; + payer: TransactionSigner; + systemProgram?: Address; +} + +export async function getNewMinterV2InstructionAsync< + TAccountMintWrapper extends string, + TAccountAdmin extends string, + TAccountNewMinterAuthority extends string, + TAccountMinter extends string, + TAccountPayer extends string, + TAccountSystemProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS, +>( + input: NewMinterV2AsyncInput< + TAccountMintWrapper, + TAccountAdmin, + TAccountNewMinterAuthority, + TAccountMinter, + TAccountPayer, + TAccountSystemProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + NewMinterV2Instruction< + TProgramAddress, + TAccountMintWrapper, + TAccountAdmin, + TAccountNewMinterAuthority, + TAccountMinter, + TAccountPayer, + TAccountSystemProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + mintWrapper: { value: input.mintWrapper ?? null, isWritable: true }, + admin: { value: input.admin ?? null, isWritable: false }, + newMinterAuthority: { + value: input.newMinterAuthority ?? null, + isWritable: false, + }, + minter: { value: input.minter ?? null, isWritable: true }, + payer: { value: input.payer ?? null, isWritable: true }, + systemProgram: { value: input.systemProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.newMinterAuthority.value) { + accounts.newMinterAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } + if (!accounts.minter.value) { + accounts.minter.value = await findMinterPda({ + wrapper: expectAddress(accounts.mintWrapper.value), + authority: expectAddress(accounts.newMinterAuthority.value), + }); + } + if (!accounts.systemProgram.value) { + accounts.systemProgram.value = + "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.mintWrapper), + getAccountMeta(accounts.admin), + getAccountMeta(accounts.newMinterAuthority), + getAccountMeta(accounts.minter), + getAccountMeta(accounts.payer), + getAccountMeta(accounts.systemProgram), + ], + data: getNewMinterV2InstructionDataEncoder().encode({}), + programAddress, + } as NewMinterV2Instruction< + TProgramAddress, + TAccountMintWrapper, + TAccountAdmin, + TAccountNewMinterAuthority, + TAccountMinter, + TAccountPayer, + TAccountSystemProgram + >); +} + export interface NewMinterV2Input< TAccountMintWrapper extends string = string, TAccountAdmin extends string = string, @@ -125,7 +236,7 @@ export interface NewMinterV2Input< > { mintWrapper: Address; admin: TransactionSigner; - newMinterAuthority: Address; + newMinterAuthority?: Address; minter: Address; payer: TransactionSigner; systemProgram?: Address; @@ -180,6 +291,11 @@ export function getNewMinterV2Instruction< >; // Resolve default values. + if (!accounts.newMinterAuthority.value) { + accounts.newMinterAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.systemProgram.value) { accounts.systemProgram.value = "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; diff --git a/clients/quarry/src/generated/instructions/newRewarder.ts b/clients/quarry/src/generated/instructions/newRewarder.ts index 82b1831c..884f36ac 100644 --- a/clients/quarry/src/generated/instructions/newRewarder.ts +++ b/clients/quarry/src/generated/instructions/newRewarder.ts @@ -28,18 +28,21 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU8Decoder, getU8Encoder, transformEncoder, } from "@solana/kit"; +import { findRewarderPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; +import { + expectAddress, + expectTransactionSigner, + getAccountMetaFactory, +} from "../shared/index.js"; export const NEW_REWARDER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 1, 115, 16, 244, 109, 74, 67, 209, @@ -150,7 +153,7 @@ export interface NewRewarderAsyncInput< > { base: TransactionSigner; rewarder?: Address; - initialAuthority: Address; + initialAuthority?: Address; payer: TransactionSigner; systemProgram?: Address; unusedAccount: Address; @@ -232,16 +235,15 @@ export async function getNewRewarderInstructionAsync< // Resolve default values. if (!accounts.rewarder.value) { - accounts.rewarder.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([34, 82, 101, 119, 97, 114, 100, 101, 114, 34]), - ), - getAddressEncoder().encode(expectAddress(accounts.base.value)), - ], + accounts.rewarder.value = await findRewarderPda({ + base: expectAddress(accounts.base.value), }); } + if (!accounts.initialAuthority.value) { + accounts.initialAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.systemProgram.value) { accounts.systemProgram.value = "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; @@ -291,7 +293,7 @@ export interface NewRewarderInput< > { base: TransactionSigner; rewarder: Address; - initialAuthority: Address; + initialAuthority?: Address; payer: TransactionSigner; systemProgram?: Address; unusedAccount: Address; @@ -370,6 +372,11 @@ export function getNewRewarderInstruction< const args = { ...input }; // Resolve default values. + if (!accounts.initialAuthority.value) { + accounts.initialAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.systemProgram.value) { accounts.systemProgram.value = "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; diff --git a/clients/quarry/src/generated/instructions/newRewarderV2.ts b/clients/quarry/src/generated/instructions/newRewarderV2.ts index 48068af9..b40ad01f 100644 --- a/clients/quarry/src/generated/instructions/newRewarderV2.ts +++ b/clients/quarry/src/generated/instructions/newRewarderV2.ts @@ -28,16 +28,19 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findRewarderPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; +import { + expectAddress, + expectTransactionSigner, + getAccountMetaFactory, +} from "../shared/index.js"; export const NEW_REWARDER_V2_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array( [173, 189, 26, 25, 79, 177, 60, 173], @@ -136,7 +139,7 @@ export interface NewRewarderV2AsyncInput< > { base: TransactionSigner; rewarder?: Address; - initialAuthority: Address; + initialAuthority?: Address; payer: TransactionSigner; systemProgram?: Address; mintWrapper: Address; @@ -209,16 +212,15 @@ export async function getNewRewarderV2InstructionAsync< // Resolve default values. if (!accounts.rewarder.value) { - accounts.rewarder.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([34, 82, 101, 119, 97, 114, 100, 101, 114, 34]), - ), - getAddressEncoder().encode(expectAddress(accounts.base.value)), - ], + accounts.rewarder.value = await findRewarderPda({ + base: expectAddress(accounts.base.value), }); } + if (!accounts.initialAuthority.value) { + accounts.initialAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.systemProgram.value) { accounts.systemProgram.value = "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; @@ -263,7 +265,7 @@ export interface NewRewarderV2Input< > { base: TransactionSigner; rewarder: Address; - initialAuthority: Address; + initialAuthority?: Address; payer: TransactionSigner; systemProgram?: Address; mintWrapper: Address; @@ -333,6 +335,11 @@ export function getNewRewarderV2Instruction< >; // Resolve default values. + if (!accounts.initialAuthority.value) { + accounts.initialAuthority.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.systemProgram.value) { accounts.systemProgram.value = "11111111111111111111111111111111" as Address<"11111111111111111111111111111111">; diff --git a/clients/quarry/src/generated/instructions/newWrapper.ts b/clients/quarry/src/generated/instructions/newWrapper.ts index a2cf7eaf..31fc7bcf 100644 --- a/clients/quarry/src/generated/instructions/newWrapper.ts +++ b/clients/quarry/src/generated/instructions/newWrapper.ts @@ -28,10 +28,8 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU8Decoder, @@ -40,8 +38,13 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMintWrapperPda } from "../pdas/index.js"; import { QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS } from "../programs/index.js"; -import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; +import { + expectAddress, + expectTransactionSigner, + getAccountMetaFactory, +} from "../shared/index.js"; export const NEW_WRAPPER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 106, 226, 139, 13, 35, 121, 62, 171, @@ -146,7 +149,7 @@ export interface NewWrapperAsyncInput< > { base: TransactionSigner; mintWrapper?: Address; - admin: Address; + admin?: Address; tokenMint: Address; tokenProgram?: Address; payer: TransactionSigner; @@ -211,18 +214,15 @@ export async function getNewWrapperInstructionAsync< // Resolve default values. if (!accounts.mintWrapper.value) { - accounts.mintWrapper.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([ - 34, 77, 105, 110, 116, 87, 114, 97, 112, 112, 101, 114, 34, - ]), - ), - getAddressEncoder().encode(expectAddress(accounts.base.value)), - ], + accounts.mintWrapper.value = await findMintWrapperPda({ + base: expectAddress(accounts.base.value), }); } + if (!accounts.admin.value) { + accounts.admin.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.tokenProgram.value) { accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; @@ -270,7 +270,7 @@ export interface NewWrapperInput< > { base: TransactionSigner; mintWrapper: Address; - admin: Address; + admin?: Address; tokenMint: Address; tokenProgram?: Address; payer: TransactionSigner; @@ -332,6 +332,11 @@ export function getNewWrapperInstruction< const args = { ...input }; // Resolve default values. + if (!accounts.admin.value) { + accounts.admin.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.tokenProgram.value) { accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; diff --git a/clients/quarry/src/generated/instructions/newWrapperV2.ts b/clients/quarry/src/generated/instructions/newWrapperV2.ts index 99f772fa..2158e164 100644 --- a/clients/quarry/src/generated/instructions/newWrapperV2.ts +++ b/clients/quarry/src/generated/instructions/newWrapperV2.ts @@ -28,18 +28,21 @@ import { combineCodec, fixDecoderSize, fixEncoderSize, - getAddressEncoder, getBytesDecoder, getBytesEncoder, - getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMintWrapperPda } from "../pdas/index.js"; import { QUARRY_MINT_WRAPPER_PROGRAM_ADDRESS } from "../programs/index.js"; -import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; +import { + expectAddress, + expectTransactionSigner, + getAccountMetaFactory, +} from "../shared/index.js"; export const NEW_WRAPPER_V2_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 140, 106, 205, 202, 15, 176, 85, 19, @@ -142,7 +145,7 @@ export interface NewWrapperV2AsyncInput< > { base: TransactionSigner; mintWrapper?: Address; - admin: Address; + admin?: Address; tokenMint: Address; tokenProgram?: Address; payer: TransactionSigner; @@ -206,18 +209,15 @@ export async function getNewWrapperV2InstructionAsync< // Resolve default values. if (!accounts.mintWrapper.value) { - accounts.mintWrapper.value = await getProgramDerivedAddress({ - programAddress, - seeds: [ - getBytesEncoder().encode( - new Uint8Array([ - 34, 77, 105, 110, 116, 87, 114, 97, 112, 112, 101, 114, 34, - ]), - ), - getAddressEncoder().encode(expectAddress(accounts.base.value)), - ], + accounts.mintWrapper.value = await findMintWrapperPda({ + base: expectAddress(accounts.base.value), }); } + if (!accounts.admin.value) { + accounts.admin.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.tokenProgram.value) { accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; @@ -265,7 +265,7 @@ export interface NewWrapperV2Input< > { base: TransactionSigner; mintWrapper: Address; - admin: Address; + admin?: Address; tokenMint: Address; tokenProgram?: Address; payer: TransactionSigner; @@ -326,6 +326,11 @@ export function getNewWrapperV2Instruction< const args = { ...input }; // Resolve default values. + if (!accounts.admin.value) { + accounts.admin.value = expectTransactionSigner( + accounts.payer.value, + ).address; + } if (!accounts.tokenProgram.value) { accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; diff --git a/clients/quarry/src/generated/instructions/redeemAllTokens.ts b/clients/quarry/src/generated/instructions/redeemAllTokens.ts index 35b10ebe..4cb06df8 100644 --- a/clients/quarry/src/generated/instructions/redeemAllTokens.ts +++ b/clients/quarry/src/generated/instructions/redeemAllTokens.ts @@ -24,17 +24,20 @@ import type { } from "@solana/kit"; import type { ResolvedAccount } from "../shared/index.js"; import { + address, combineCodec, fixDecoderSize, fixEncoderSize, + getAddressEncoder, getBytesDecoder, getBytesEncoder, + getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; import { QUARRY_REDEEMER_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const REDEEM_ALL_TOKENS_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([68, 38, 47, 47, 226, 176, 31, 48]); @@ -116,6 +119,127 @@ export function getRedeemAllTokensInstructionDataCodec(): FixedSizeCodec< ); } +export interface RedeemAllTokensAsyncInput< + TAccountRedeemer extends string = string, + TAccountSourceAuthority extends string = string, + TAccountIouMint extends string = string, + TAccountIouSource extends string = string, + TAccountRedemptionVault extends string = string, + TAccountRedemptionDestination extends string = string, + TAccountTokenProgram extends string = string, +> { + redeemer: Address; + sourceAuthority: TransactionSigner; + iouMint: Address; + iouSource?: Address; + redemptionVault: Address; + redemptionDestination: Address; + tokenProgram?: Address; +} + +export async function getRedeemAllTokensInstructionAsync< + TAccountRedeemer extends string, + TAccountSourceAuthority extends string, + TAccountIouMint extends string, + TAccountIouSource extends string, + TAccountRedemptionVault extends string, + TAccountRedemptionDestination extends string, + TAccountTokenProgram extends string, + TProgramAddress extends Address = typeof QUARRY_REDEEMER_PROGRAM_ADDRESS, +>( + input: RedeemAllTokensAsyncInput< + TAccountRedeemer, + TAccountSourceAuthority, + TAccountIouMint, + TAccountIouSource, + TAccountRedemptionVault, + TAccountRedemptionDestination, + TAccountTokenProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + RedeemAllTokensInstruction< + TProgramAddress, + TAccountRedeemer, + TAccountSourceAuthority, + TAccountIouMint, + TAccountIouSource, + TAccountRedemptionVault, + TAccountRedemptionDestination, + TAccountTokenProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_REDEEMER_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + redeemer: { value: input.redeemer ?? null, isWritable: true }, + sourceAuthority: { + value: input.sourceAuthority ?? null, + isWritable: false, + }, + iouMint: { value: input.iouMint ?? null, isWritable: true }, + iouSource: { value: input.iouSource ?? null, isWritable: true }, + redemptionVault: { value: input.redemptionVault ?? null, isWritable: true }, + redemptionDestination: { + value: input.redemptionDestination ?? null, + isWritable: true, + }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.iouSource.value) { + accounts.iouSource.value = await getProgramDerivedAddress({ + programAddress: + "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" as Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">, + seeds: [ + getAddressEncoder().encode( + expectAddress(accounts.sourceAuthority.value), + ), + getAddressEncoder().encode( + address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), + ), + getAddressEncoder().encode(expectAddress(accounts.iouMint.value)), + ], + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.redeemer), + getAccountMeta(accounts.sourceAuthority), + getAccountMeta(accounts.iouMint), + getAccountMeta(accounts.iouSource), + getAccountMeta(accounts.redemptionVault), + getAccountMeta(accounts.redemptionDestination), + getAccountMeta(accounts.tokenProgram), + ], + data: getRedeemAllTokensInstructionDataEncoder().encode({}), + programAddress, + } as RedeemAllTokensInstruction< + TProgramAddress, + TAccountRedeemer, + TAccountSourceAuthority, + TAccountIouMint, + TAccountIouSource, + TAccountRedemptionVault, + TAccountRedemptionDestination, + TAccountTokenProgram + >); +} + export interface RedeemAllTokensInput< TAccountRedeemer extends string = string, TAccountSourceAuthority extends string = string, diff --git a/clients/quarry/src/generated/instructions/redeemTokens.ts b/clients/quarry/src/generated/instructions/redeemTokens.ts index 5f842ca2..5ae6f91f 100644 --- a/clients/quarry/src/generated/instructions/redeemTokens.ts +++ b/clients/quarry/src/generated/instructions/redeemTokens.ts @@ -24,11 +24,14 @@ import type { } from "@solana/kit"; import type { ResolvedAccount } from "../shared/index.js"; import { + address, combineCodec, fixDecoderSize, fixEncoderSize, + getAddressEncoder, getBytesDecoder, getBytesEncoder, + getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU64Decoder, @@ -36,7 +39,7 @@ import { transformEncoder, } from "@solana/kit"; import { QUARRY_REDEEMER_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const REDEEM_TOKENS_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 246, 98, 134, 41, 152, 33, 120, 69, @@ -126,6 +129,133 @@ export function getRedeemTokensInstructionDataCodec(): FixedSizeCodec< ); } +export interface RedeemTokensAsyncInput< + TAccountRedeemer extends string = string, + TAccountSourceAuthority extends string = string, + TAccountIouMint extends string = string, + TAccountIouSource extends string = string, + TAccountRedemptionVault extends string = string, + TAccountRedemptionDestination extends string = string, + TAccountTokenProgram extends string = string, +> { + redeemer: Address; + sourceAuthority: TransactionSigner; + iouMint: Address; + iouSource?: Address; + redemptionVault: Address; + redemptionDestination: Address; + tokenProgram?: Address; + amount: RedeemTokensInstructionDataArgs["amount"]; +} + +export async function getRedeemTokensInstructionAsync< + TAccountRedeemer extends string, + TAccountSourceAuthority extends string, + TAccountIouMint extends string, + TAccountIouSource extends string, + TAccountRedemptionVault extends string, + TAccountRedemptionDestination extends string, + TAccountTokenProgram extends string, + TProgramAddress extends Address = typeof QUARRY_REDEEMER_PROGRAM_ADDRESS, +>( + input: RedeemTokensAsyncInput< + TAccountRedeemer, + TAccountSourceAuthority, + TAccountIouMint, + TAccountIouSource, + TAccountRedemptionVault, + TAccountRedemptionDestination, + TAccountTokenProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + RedeemTokensInstruction< + TProgramAddress, + TAccountRedeemer, + TAccountSourceAuthority, + TAccountIouMint, + TAccountIouSource, + TAccountRedemptionVault, + TAccountRedemptionDestination, + TAccountTokenProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_REDEEMER_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + redeemer: { value: input.redeemer ?? null, isWritable: true }, + sourceAuthority: { + value: input.sourceAuthority ?? null, + isWritable: false, + }, + iouMint: { value: input.iouMint ?? null, isWritable: true }, + iouSource: { value: input.iouSource ?? null, isWritable: true }, + redemptionVault: { value: input.redemptionVault ?? null, isWritable: true }, + redemptionDestination: { + value: input.redemptionDestination ?? null, + isWritable: true, + }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Original args. + const args = { ...input }; + + // Resolve default values. + if (!accounts.iouSource.value) { + accounts.iouSource.value = await getProgramDerivedAddress({ + programAddress: + "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" as Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">, + seeds: [ + getAddressEncoder().encode( + expectAddress(accounts.sourceAuthority.value), + ), + getAddressEncoder().encode( + address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), + ), + getAddressEncoder().encode(expectAddress(accounts.iouMint.value)), + ], + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.redeemer), + getAccountMeta(accounts.sourceAuthority), + getAccountMeta(accounts.iouMint), + getAccountMeta(accounts.iouSource), + getAccountMeta(accounts.redemptionVault), + getAccountMeta(accounts.redemptionDestination), + getAccountMeta(accounts.tokenProgram), + ], + data: getRedeemTokensInstructionDataEncoder().encode( + args as RedeemTokensInstructionDataArgs, + ), + programAddress, + } as RedeemTokensInstruction< + TProgramAddress, + TAccountRedeemer, + TAccountSourceAuthority, + TAccountIouMint, + TAccountIouSource, + TAccountRedemptionVault, + TAccountRedemptionDestination, + TAccountTokenProgram + >); +} + export interface RedeemTokensInput< TAccountRedeemer extends string = string, TAccountSourceAuthority extends string = string, diff --git a/clients/quarry/src/generated/instructions/stakePrimaryMiner.ts b/clients/quarry/src/generated/instructions/stakePrimaryMiner.ts index 94187941..5497dfe2 100644 --- a/clients/quarry/src/generated/instructions/stakePrimaryMiner.ts +++ b/clients/quarry/src/generated/instructions/stakePrimaryMiner.ts @@ -33,8 +33,9 @@ import { getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMergeMinerPda, findMinerPda } from "../pdas/index.js"; import { QUARRY_MERGE_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const STAKE_PRIMARY_MINER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([72, 59, 23, 242, 117, 178, 129, 138]); @@ -128,6 +129,149 @@ export function getStakePrimaryMinerInstructionDataCodec(): FixedSizeCodec< ); } +export interface StakePrimaryMinerAsyncInput< + TAccountMmOwner extends string = string, + TAccountMmPrimaryTokenAccount extends string = string, + TAccountPool extends string = string, + TAccountMm extends string = string, + TAccountRewarder extends string = string, + TAccountQuarry extends string = string, + TAccountMiner extends string = string, + TAccountMinerVault extends string = string, + TAccountTokenProgram extends string = string, + TAccountMineProgram extends string = string, +> { + mmOwner: TransactionSigner; + mmPrimaryTokenAccount: Address; + pool: Address; + mm?: Address; + rewarder: Address; + quarry: Address; + miner?: Address; + minerVault: Address; + tokenProgram?: Address; + mineProgram?: Address; +} + +export async function getStakePrimaryMinerInstructionAsync< + TAccountMmOwner extends string, + TAccountMmPrimaryTokenAccount extends string, + TAccountPool extends string, + TAccountMm extends string, + TAccountRewarder extends string, + TAccountQuarry extends string, + TAccountMiner extends string, + TAccountMinerVault extends string, + TAccountTokenProgram extends string, + TAccountMineProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MERGE_MINE_PROGRAM_ADDRESS, +>( + input: StakePrimaryMinerAsyncInput< + TAccountMmOwner, + TAccountMmPrimaryTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + StakePrimaryMinerInstruction< + TProgramAddress, + TAccountMmOwner, + TAccountMmPrimaryTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_MERGE_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + mmOwner: { value: input.mmOwner ?? null, isWritable: false }, + mmPrimaryTokenAccount: { + value: input.mmPrimaryTokenAccount ?? null, + isWritable: true, + }, + pool: { value: input.pool ?? null, isWritable: true }, + mm: { value: input.mm ?? null, isWritable: true }, + rewarder: { value: input.rewarder ?? null, isWritable: false }, + quarry: { value: input.quarry ?? null, isWritable: true }, + miner: { value: input.miner ?? null, isWritable: true }, + minerVault: { value: input.minerVault ?? null, isWritable: true }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + mineProgram: { value: input.mineProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.mm.value) { + accounts.mm.value = await findMergeMinerPda({ + pool: expectAddress(accounts.pool.value), + owner: expectAddress(accounts.mmOwner.value), + }); + } + if (!accounts.miner.value) { + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.mm.value), + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + if (!accounts.mineProgram.value) { + accounts.mineProgram.value = + "QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB" as Address<"QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.mmOwner), + getAccountMeta(accounts.mmPrimaryTokenAccount), + getAccountMeta(accounts.pool), + getAccountMeta(accounts.mm), + getAccountMeta(accounts.rewarder), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.miner), + getAccountMeta(accounts.minerVault), + getAccountMeta(accounts.tokenProgram), + getAccountMeta(accounts.mineProgram), + ], + data: getStakePrimaryMinerInstructionDataEncoder().encode({}), + programAddress, + } as StakePrimaryMinerInstruction< + TProgramAddress, + TAccountMmOwner, + TAccountMmPrimaryTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + >); +} + export interface StakePrimaryMinerInput< TAccountMmOwner extends string = string, TAccountMmPrimaryTokenAccount extends string = string, diff --git a/clients/quarry/src/generated/instructions/stakeReplicaMiner.ts b/clients/quarry/src/generated/instructions/stakeReplicaMiner.ts index 493b5a80..02678ce3 100644 --- a/clients/quarry/src/generated/instructions/stakeReplicaMiner.ts +++ b/clients/quarry/src/generated/instructions/stakeReplicaMiner.ts @@ -33,8 +33,9 @@ import { getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMergeMinerPda, findMinerPda } from "../pdas/index.js"; import { QUARRY_MERGE_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const STAKE_REPLICA_MINER_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([246, 171, 25, 201, 242, 145, 94, 47]); @@ -132,6 +133,157 @@ export function getStakeReplicaMinerInstructionDataCodec(): FixedSizeCodec< ); } +export interface StakeReplicaMinerAsyncInput< + TAccountMmOwner extends string = string, + TAccountReplicaMint extends string = string, + TAccountReplicaMintTokenAccount extends string = string, + TAccountPool extends string = string, + TAccountMm extends string = string, + TAccountRewarder extends string = string, + TAccountQuarry extends string = string, + TAccountMiner extends string = string, + TAccountMinerVault extends string = string, + TAccountTokenProgram extends string = string, + TAccountMineProgram extends string = string, +> { + mmOwner: TransactionSigner; + replicaMint: Address; + replicaMintTokenAccount: Address; + pool: Address; + mm?: Address; + rewarder: Address; + quarry: Address; + miner?: Address; + minerVault: Address; + tokenProgram?: Address; + mineProgram?: Address; +} + +export async function getStakeReplicaMinerInstructionAsync< + TAccountMmOwner extends string, + TAccountReplicaMint extends string, + TAccountReplicaMintTokenAccount extends string, + TAccountPool extends string, + TAccountMm extends string, + TAccountRewarder extends string, + TAccountQuarry extends string, + TAccountMiner extends string, + TAccountMinerVault extends string, + TAccountTokenProgram extends string, + TAccountMineProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MERGE_MINE_PROGRAM_ADDRESS, +>( + input: StakeReplicaMinerAsyncInput< + TAccountMmOwner, + TAccountReplicaMint, + TAccountReplicaMintTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + StakeReplicaMinerInstruction< + TProgramAddress, + TAccountMmOwner, + TAccountReplicaMint, + TAccountReplicaMintTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_MERGE_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + mmOwner: { value: input.mmOwner ?? null, isWritable: false }, + replicaMint: { value: input.replicaMint ?? null, isWritable: true }, + replicaMintTokenAccount: { + value: input.replicaMintTokenAccount ?? null, + isWritable: true, + }, + pool: { value: input.pool ?? null, isWritable: true }, + mm: { value: input.mm ?? null, isWritable: true }, + rewarder: { value: input.rewarder ?? null, isWritable: false }, + quarry: { value: input.quarry ?? null, isWritable: true }, + miner: { value: input.miner ?? null, isWritable: true }, + minerVault: { value: input.minerVault ?? null, isWritable: true }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + mineProgram: { value: input.mineProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.mm.value) { + accounts.mm.value = await findMergeMinerPda({ + pool: expectAddress(accounts.pool.value), + owner: expectAddress(accounts.mmOwner.value), + }); + } + if (!accounts.miner.value) { + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.mm.value), + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + if (!accounts.mineProgram.value) { + accounts.mineProgram.value = + "QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB" as Address<"QMNeHCGYnLVDn1icRAfQZpjPLBNkfGbSKRB83G5d8KB">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.mmOwner), + getAccountMeta(accounts.replicaMint), + getAccountMeta(accounts.replicaMintTokenAccount), + getAccountMeta(accounts.pool), + getAccountMeta(accounts.mm), + getAccountMeta(accounts.rewarder), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.miner), + getAccountMeta(accounts.minerVault), + getAccountMeta(accounts.tokenProgram), + getAccountMeta(accounts.mineProgram), + ], + data: getStakeReplicaMinerInstructionDataEncoder().encode({}), + programAddress, + } as StakeReplicaMinerInstruction< + TProgramAddress, + TAccountMmOwner, + TAccountReplicaMint, + TAccountReplicaMintTokenAccount, + TAccountPool, + TAccountMm, + TAccountRewarder, + TAccountQuarry, + TAccountMiner, + TAccountMinerVault, + TAccountTokenProgram, + TAccountMineProgram + >); +} + export interface StakeReplicaMinerInput< TAccountMmOwner extends string = string, TAccountReplicaMint extends string = string, diff --git a/clients/quarry/src/generated/instructions/stakeTokens.ts b/clients/quarry/src/generated/instructions/stakeTokens.ts index fc13cb81..7df03f94 100644 --- a/clients/quarry/src/generated/instructions/stakeTokens.ts +++ b/clients/quarry/src/generated/instructions/stakeTokens.ts @@ -35,8 +35,9 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const STAKE_TOKENS_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([ 136, 126, 91, 162, 40, 131, 13, 127, @@ -126,6 +127,117 @@ export function getStakeTokensInstructionDataCodec(): FixedSizeCodec< ); } +export interface StakeTokensAsyncInput< + TAccountAuthority extends string = string, + TAccountMiner extends string = string, + TAccountQuarry extends string = string, + TAccountMinerVault extends string = string, + TAccountTokenAccount extends string = string, + TAccountTokenProgram extends string = string, + TAccountRewarder extends string = string, +> { + authority: TransactionSigner; + miner?: Address; + quarry: Address; + minerVault: Address; + tokenAccount: Address; + tokenProgram?: Address; + rewarder: Address; + amount: StakeTokensInstructionDataArgs["amount"]; +} + +export async function getStakeTokensInstructionAsync< + TAccountAuthority extends string, + TAccountMiner extends string, + TAccountQuarry extends string, + TAccountMinerVault extends string, + TAccountTokenAccount extends string, + TAccountTokenProgram extends string, + TAccountRewarder extends string, + TProgramAddress extends Address = typeof QUARRY_MINE_PROGRAM_ADDRESS, +>( + input: StakeTokensAsyncInput< + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountMinerVault, + TAccountTokenAccount, + TAccountTokenProgram, + TAccountRewarder + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + StakeTokensInstruction< + TProgramAddress, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountMinerVault, + TAccountTokenAccount, + TAccountTokenProgram, + TAccountRewarder + > +> { + // Program address. + const programAddress = config?.programAddress ?? QUARRY_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + authority: { value: input.authority ?? null, isWritable: false }, + miner: { value: input.miner ?? null, isWritable: true }, + quarry: { value: input.quarry ?? null, isWritable: true }, + minerVault: { value: input.minerVault ?? null, isWritable: true }, + tokenAccount: { value: input.tokenAccount ?? null, isWritable: true }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Original args. + const args = { ...input }; + + // Resolve default values. + if (!accounts.miner.value) { + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.authority.value), + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.authority), + getAccountMeta(accounts.miner), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.minerVault), + getAccountMeta(accounts.tokenAccount), + getAccountMeta(accounts.tokenProgram), + getAccountMeta(accounts.rewarder), + ], + data: getStakeTokensInstructionDataEncoder().encode( + args as StakeTokensInstructionDataArgs, + ), + programAddress, + } as StakeTokensInstruction< + TProgramAddress, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountMinerVault, + TAccountTokenAccount, + TAccountTokenProgram, + TAccountRewarder + >); +} + export interface StakeTokensInput< TAccountAuthority extends string = string, TAccountMiner extends string = string, diff --git a/clients/quarry/src/generated/instructions/withdrawTokens.ts b/clients/quarry/src/generated/instructions/withdrawTokens.ts index d2578b98..25f59e91 100644 --- a/clients/quarry/src/generated/instructions/withdrawTokens.ts +++ b/clients/quarry/src/generated/instructions/withdrawTokens.ts @@ -35,8 +35,9 @@ import { getU64Encoder, transformEncoder, } from "@solana/kit"; +import { findMinerPda } from "../pdas/index.js"; import { QUARRY_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const WITHDRAW_TOKENS_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array( [2, 4, 225, 61, 19, 182, 106, 170], @@ -126,6 +127,117 @@ export function getWithdrawTokensInstructionDataCodec(): FixedSizeCodec< ); } +export interface WithdrawTokensAsyncInput< + TAccountAuthority extends string = string, + TAccountMiner extends string = string, + TAccountQuarry extends string = string, + TAccountMinerVault extends string = string, + TAccountTokenAccount extends string = string, + TAccountTokenProgram extends string = string, + TAccountRewarder extends string = string, +> { + authority: TransactionSigner; + miner?: Address; + quarry: Address; + minerVault: Address; + tokenAccount: Address; + tokenProgram?: Address; + rewarder: Address; + amount: WithdrawTokensInstructionDataArgs["amount"]; +} + +export async function getWithdrawTokensInstructionAsync< + TAccountAuthority extends string, + TAccountMiner extends string, + TAccountQuarry extends string, + TAccountMinerVault extends string, + TAccountTokenAccount extends string, + TAccountTokenProgram extends string, + TAccountRewarder extends string, + TProgramAddress extends Address = typeof QUARRY_MINE_PROGRAM_ADDRESS, +>( + input: WithdrawTokensAsyncInput< + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountMinerVault, + TAccountTokenAccount, + TAccountTokenProgram, + TAccountRewarder + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + WithdrawTokensInstruction< + TProgramAddress, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountMinerVault, + TAccountTokenAccount, + TAccountTokenProgram, + TAccountRewarder + > +> { + // Program address. + const programAddress = config?.programAddress ?? QUARRY_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + authority: { value: input.authority ?? null, isWritable: false }, + miner: { value: input.miner ?? null, isWritable: true }, + quarry: { value: input.quarry ?? null, isWritable: true }, + minerVault: { value: input.minerVault ?? null, isWritable: true }, + tokenAccount: { value: input.tokenAccount ?? null, isWritable: true }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + rewarder: { value: input.rewarder ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Original args. + const args = { ...input }; + + // Resolve default values. + if (!accounts.miner.value) { + accounts.miner.value = await findMinerPda({ + quarry: expectAddress(accounts.quarry.value), + authority: expectAddress(accounts.authority.value), + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.authority), + getAccountMeta(accounts.miner), + getAccountMeta(accounts.quarry), + getAccountMeta(accounts.minerVault), + getAccountMeta(accounts.tokenAccount), + getAccountMeta(accounts.tokenProgram), + getAccountMeta(accounts.rewarder), + ], + data: getWithdrawTokensInstructionDataEncoder().encode( + args as WithdrawTokensInstructionDataArgs, + ), + programAddress, + } as WithdrawTokensInstruction< + TProgramAddress, + TAccountAuthority, + TAccountMiner, + TAccountQuarry, + TAccountMinerVault, + TAccountTokenAccount, + TAccountTokenProgram, + TAccountRewarder + >); +} + export interface WithdrawTokensInput< TAccountAuthority extends string = string, TAccountMiner extends string = string, diff --git a/clients/quarry/src/generated/instructions/withdrawTokensMM.ts b/clients/quarry/src/generated/instructions/withdrawTokensMM.ts index 96c22af4..9d2dd45a 100644 --- a/clients/quarry/src/generated/instructions/withdrawTokensMM.ts +++ b/clients/quarry/src/generated/instructions/withdrawTokensMM.ts @@ -24,17 +24,21 @@ import type { } from "@solana/kit"; import type { ResolvedAccount } from "../shared/index.js"; import { + address, combineCodec, fixDecoderSize, fixEncoderSize, + getAddressEncoder, getBytesDecoder, getBytesEncoder, + getProgramDerivedAddress, getStructDecoder, getStructEncoder, transformEncoder, } from "@solana/kit"; +import { findMergeMinerPda } from "../pdas/index.js"; import { QUARRY_MERGE_MINE_PROGRAM_ADDRESS } from "../programs/index.js"; -import { getAccountMetaFactory } from "../shared/index.js"; +import { expectAddress, getAccountMetaFactory } from "../shared/index.js"; export const WITHDRAW_TOKENS_M_M_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([2, 4, 225, 61, 19, 182, 106, 170]); @@ -114,6 +118,128 @@ export function getWithdrawTokensMMInstructionDataCodec(): FixedSizeCodec< ); } +export interface WithdrawTokensMMAsyncInput< + TAccountOwner extends string = string, + TAccountPool extends string = string, + TAccountMm extends string = string, + TAccountWithdrawMint extends string = string, + TAccountMmTokenAccount extends string = string, + TAccountTokenDestination extends string = string, + TAccountTokenProgram extends string = string, +> { + owner: TransactionSigner; + pool: Address; + mm?: Address; + withdrawMint: Address; + mmTokenAccount?: Address; + tokenDestination: Address; + tokenProgram?: Address; +} + +export async function getWithdrawTokensMMInstructionAsync< + TAccountOwner extends string, + TAccountPool extends string, + TAccountMm extends string, + TAccountWithdrawMint extends string, + TAccountMmTokenAccount extends string, + TAccountTokenDestination extends string, + TAccountTokenProgram extends string, + TProgramAddress extends Address = typeof QUARRY_MERGE_MINE_PROGRAM_ADDRESS, +>( + input: WithdrawTokensMMAsyncInput< + TAccountOwner, + TAccountPool, + TAccountMm, + TAccountWithdrawMint, + TAccountMmTokenAccount, + TAccountTokenDestination, + TAccountTokenProgram + >, + config?: { programAddress?: TProgramAddress }, +): Promise< + WithdrawTokensMMInstruction< + TProgramAddress, + TAccountOwner, + TAccountPool, + TAccountMm, + TAccountWithdrawMint, + TAccountMmTokenAccount, + TAccountTokenDestination, + TAccountTokenProgram + > +> { + // Program address. + const programAddress = + config?.programAddress ?? QUARRY_MERGE_MINE_PROGRAM_ADDRESS; + + // Original accounts. + const originalAccounts = { + owner: { value: input.owner ?? null, isWritable: false }, + pool: { value: input.pool ?? null, isWritable: false }, + mm: { value: input.mm ?? null, isWritable: true }, + withdrawMint: { value: input.withdrawMint ?? null, isWritable: false }, + mmTokenAccount: { value: input.mmTokenAccount ?? null, isWritable: true }, + tokenDestination: { + value: input.tokenDestination ?? null, + isWritable: true, + }, + tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }, + }; + const accounts = originalAccounts as Record< + keyof typeof originalAccounts, + ResolvedAccount + >; + + // Resolve default values. + if (!accounts.mm.value) { + accounts.mm.value = await findMergeMinerPda({ + pool: expectAddress(accounts.pool.value), + owner: expectAddress(accounts.owner.value), + }); + } + if (!accounts.mmTokenAccount.value) { + accounts.mmTokenAccount.value = await getProgramDerivedAddress({ + programAddress: + "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" as Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">, + seeds: [ + getAddressEncoder().encode(expectAddress(accounts.mm.value)), + getAddressEncoder().encode( + address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), + ), + getAddressEncoder().encode(expectAddress(accounts.withdrawMint.value)), + ], + }); + } + if (!accounts.tokenProgram.value) { + accounts.tokenProgram.value = + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" as Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">; + } + + const getAccountMeta = getAccountMetaFactory(programAddress, "programId"); + return Object.freeze({ + accounts: [ + getAccountMeta(accounts.owner), + getAccountMeta(accounts.pool), + getAccountMeta(accounts.mm), + getAccountMeta(accounts.withdrawMint), + getAccountMeta(accounts.mmTokenAccount), + getAccountMeta(accounts.tokenDestination), + getAccountMeta(accounts.tokenProgram), + ], + data: getWithdrawTokensMMInstructionDataEncoder().encode({}), + programAddress, + } as WithdrawTokensMMInstruction< + TProgramAddress, + TAccountOwner, + TAccountPool, + TAccountMm, + TAccountWithdrawMint, + TAccountMmTokenAccount, + TAccountTokenDestination, + TAccountTokenProgram + >); +} + export interface WithdrawTokensMMInput< TAccountOwner extends string = string, TAccountPool extends string = string, diff --git a/clients/quarry/src/generated/pdas/mergeMiner.ts b/clients/quarry/src/generated/pdas/mergeMiner.ts index bd8ff80f..79d3057f 100644 --- a/clients/quarry/src/generated/pdas/mergeMiner.ts +++ b/clients/quarry/src/generated/pdas/mergeMiner.ts @@ -18,6 +18,7 @@ export interface MergeMinerSeeds { owner: Address; } +/** Merge miner account for a user in a merge pool */ export async function findMergeMinerPda( seeds: MergeMinerSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/mergePool.ts b/clients/quarry/src/generated/pdas/mergePool.ts index bb7cc019..1ae52710 100644 --- a/clients/quarry/src/generated/pdas/mergePool.ts +++ b/clients/quarry/src/generated/pdas/mergePool.ts @@ -17,6 +17,7 @@ export interface MergePoolSeeds { primaryMint: Address; } +/** Merge pool that allows staking multiple quarry rewards as one */ export async function findMergePoolPda( seeds: MergePoolSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/miner.ts b/clients/quarry/src/generated/pdas/miner.ts index a3fc9f22..6bb2e8b6 100644 --- a/clients/quarry/src/generated/pdas/miner.ts +++ b/clients/quarry/src/generated/pdas/miner.ts @@ -18,6 +18,7 @@ export interface MinerSeeds { authority: Address; } +/** Miner account representing a user's staking position in a quarry */ export async function findMinerPda( seeds: MinerSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/mintWrapper.ts b/clients/quarry/src/generated/pdas/mintWrapper.ts index 00d4d105..18387e6b 100644 --- a/clients/quarry/src/generated/pdas/mintWrapper.ts +++ b/clients/quarry/src/generated/pdas/mintWrapper.ts @@ -17,6 +17,7 @@ export interface MintWrapperSeeds { base: Address; } +/** Mint wrapper that controls minting of wrapped tokens */ export async function findMintWrapperPda( seeds: MintWrapperSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/minter.ts b/clients/quarry/src/generated/pdas/minter.ts index 900d3dee..65eed4f9 100644 --- a/clients/quarry/src/generated/pdas/minter.ts +++ b/clients/quarry/src/generated/pdas/minter.ts @@ -18,6 +18,7 @@ export interface MinterSeeds { authority: Address; } +/** Minter authority for a specific mint wrapper */ export async function findMinterPda( seeds: MinterSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/operator.ts b/clients/quarry/src/generated/pdas/operator.ts index 31ffd738..0f640dd9 100644 --- a/clients/quarry/src/generated/pdas/operator.ts +++ b/clients/quarry/src/generated/pdas/operator.ts @@ -17,6 +17,7 @@ export interface OperatorSeeds { base: Address; } +/** Operator account with delegated authority to manage quarries */ export async function findOperatorPda( seeds: OperatorSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/quarry.ts b/clients/quarry/src/generated/pdas/quarry.ts index 04f5ec6f..c3ce74b8 100644 --- a/clients/quarry/src/generated/pdas/quarry.ts +++ b/clients/quarry/src/generated/pdas/quarry.ts @@ -18,6 +18,7 @@ export interface QuarrySeeds { tokenMint: Address; } +/** Individual quarry (staking pool) for a specific token mint */ export async function findQuarryPda( seeds: QuarrySeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/redeemer.ts b/clients/quarry/src/generated/pdas/redeemer.ts index 00a325a0..cdcc5423 100644 --- a/clients/quarry/src/generated/pdas/redeemer.ts +++ b/clients/quarry/src/generated/pdas/redeemer.ts @@ -18,6 +18,7 @@ export interface RedeemerSeeds { redemptionMint: Address; } +/** Redeemer account for exchanging IOU tokens for redemption tokens */ export async function findRedeemerPda( seeds: RedeemerSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/registry.ts b/clients/quarry/src/generated/pdas/registry.ts index 07de204a..1b760c1b 100644 --- a/clients/quarry/src/generated/pdas/registry.ts +++ b/clients/quarry/src/generated/pdas/registry.ts @@ -17,6 +17,7 @@ export interface RegistrySeeds { rewarder: Address; } +/** Registry tracking all quarries for a rewarder */ export async function findRegistryPda( seeds: RegistrySeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/replicaMint.ts b/clients/quarry/src/generated/pdas/replicaMint.ts index ad310b2e..583ef997 100644 --- a/clients/quarry/src/generated/pdas/replicaMint.ts +++ b/clients/quarry/src/generated/pdas/replicaMint.ts @@ -17,6 +17,7 @@ export interface ReplicaMintSeeds { pool: Address; } +/** Replica mint token for the merge pool */ export async function findReplicaMintPda( seeds: ReplicaMintSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/clients/quarry/src/generated/pdas/rewarder.ts b/clients/quarry/src/generated/pdas/rewarder.ts index 5aeebd45..7d314b62 100644 --- a/clients/quarry/src/generated/pdas/rewarder.ts +++ b/clients/quarry/src/generated/pdas/rewarder.ts @@ -17,6 +17,7 @@ export interface RewarderSeeds { base: Address; } +/** Rewarder account that manages reward distribution for quarries */ export async function findRewarderPda( seeds: RewarderSeeds, config: { programAddress?: Address | undefined } = {}, diff --git a/packages/coda-visitors/src/associated-token-account-value-node.ts b/packages/coda-visitors/src/associated-token-account-value-node.ts new file mode 100644 index 00000000..b341fe35 --- /dev/null +++ b/packages/coda-visitors/src/associated-token-account-value-node.ts @@ -0,0 +1,36 @@ +import type { AccountValueNode, PublicKeyValueNode } from "codama"; +import { + pdaNode, + pdaSeedValueNode, + pdaValueNode, + publicKeyTypeNode, + publicKeyValueNode, + variablePdaSeedNode, +} from "codama"; + +export const associatedTokenAccountPdaNode = pdaNode({ + name: "associatedTokenAccount", + programId: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL", + seeds: [ + variablePdaSeedNode("owner", publicKeyTypeNode()), + variablePdaSeedNode("tokenProgram", publicKeyTypeNode()), + variablePdaSeedNode("mint", publicKeyTypeNode()), + ], +}); + +export const associatedTokenAccountValueNode = ({ + owner, + mint, + tokenProgram = publicKeyValueNode( + "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", + ), +}: { + owner: AccountValueNode; + mint: AccountValueNode; + tokenProgram?: PublicKeyValueNode | AccountValueNode; +}) => + pdaValueNode(associatedTokenAccountPdaNode, [ + pdaSeedValueNode("owner", owner), + pdaSeedValueNode("tokenProgram", tokenProgram), + pdaSeedValueNode("mint", mint), + ]); diff --git a/packages/coda-visitors/src/index.ts b/packages/coda-visitors/src/index.ts index 5bcb8edc..83100417 100644 --- a/packages/coda-visitors/src/index.ts +++ b/packages/coda-visitors/src/index.ts @@ -1 +1,2 @@ export * from "./add-nodes-visitor.js"; +export * from "./associated-token-account-value-node.js";