Add more defaults to Quarry

.changeset/small-geckos-brake.md

@@ -0,0 +1,6 @@
+---
+"@macalinao/coda-visitors": patch
+"@macalinao/clients-quarry": patch
+---
+
+Add more defaults to Quarry client

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,17 +21,64 @@ 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()),
           ],
         },
         {
           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,20 +100,25 @@ export default defineConfig({
       quarryMergeMine: [
         {
           name: "mergePool",
+          docs: [
+            "Merge pool that allows staking multiple quarry rewards as one",
+          ],
           seeds: [
             constantPdaSeedNodeFromString("utf8", "MergePool"),
             variablePdaSeedNode("primaryMint", publicKeyTypeNode()),
           ],
         },
         {
           name: "replicaMint",
+          docs: ["Replica mint token for the merge pool"],
           seeds: [
             constantPdaSeedNodeFromString("utf8", "ReplicaMint"),
             variablePdaSeedNode("pool", publicKeyTypeNode()),
           ],
         },
         {
           name: "mergeMiner",
+          docs: ["Merge miner account for a user in a merge pool"],
           seeds: [
             constantPdaSeedNodeFromString("utf8", "MergeMiner"),
             variablePdaSeedNode("pool", publicKeyTypeNode()),
@@ -67,13 +129,15 @@ export default defineConfig({
       quarryMintWrapper: [
         {
           name: "mintWrapper",
+          docs: ["Mint wrapper that controls minting of wrapped tokens"],
           seeds: [
             constantPdaSeedNodeFromString("utf8", "MintWrapper"),
             variablePdaSeedNode("base", publicKeyTypeNode()),
           ],
         },
         {
           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"),
+        },
+      ]),
+    ]),
   ],
 });

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<typeof fetchEncodedAccount>[0],
+  seeds: MergeMinerSeeds,
+  config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<Account<MergeMiner>> {
+  const maybeAccount = await fetchMaybeMergeMinerFromSeeds(rpc, seeds, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeMergeMinerFromSeeds(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  seeds: MergeMinerSeeds,
+  config: FetchAccountConfig & { programAddress?: Address } = {},
+): Promise<MaybeAccount<MergeMiner>> {
+  const { programAddress, ...fetchConfig } = config;
+  const [address] = await findMergeMinerPda(seeds, { programAddress });
+  return await fetchMaybeMergeMiner(rpc, address, fetchConfig);
+}