@useaccord/sdk 0.1.0 → 0.1.1

package/dist/index.js

@@ -12,12 +12,12 @@ import {
   assertIsInstructionWithAccounts,
   containsBytes,
   extendClient,
-  fixEncoderSize as fixEncoderSize39,
-  getBytesEncoder as getBytesEncoder46,
+  fixEncoderSize as fixEncoderSize40,
+  getBytesEncoder as getBytesEncoder47,
   SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
   SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
   SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
-  SolanaError as SolanaError30
+  SolanaError as SolanaError31
 } from "@solana/kit";
 import {
   addSelfFetchFunctions,
@@ -151,8 +151,9 @@ function getAppealBondEncoder() {
       ["appellant", getAddressEncoder2()],
       ["amount", getU64Encoder2()],
       ["priorResult", getU64Encoder2()],
+      ["reward", getU64Encoder2()],
       ["bump", getU8Encoder2()],
-      ["padding", fixEncoderSize2(getBytesEncoder2(), 64)]
+      ["padding", fixEncoderSize2(getBytesEncoder2(), 56)]
     ]),
     (value) => ({ ...value, discriminator: APPEAL_BOND_DISCRIMINATOR })
   );
@@ -166,8 +167,9 @@ function getAppealBondDecoder() {
     ["appellant", getAddressDecoder2()],
     ["amount", getU64Decoder2()],
     ["priorResult", getU64Decoder2()],
+    ["reward", getU64Decoder2()],
     ["bump", getU8Decoder2()],
-    ["padding", fixDecoderSize2(getBytesDecoder2(), 64)]
+    ["padding", fixDecoderSize2(getBytesDecoder2(), 56)]
   ]);
 }
 __name(getAppealBondDecoder, "getAppealBondDecoder");
@@ -581,7 +583,8 @@ function getDisputeEncoder() {
       ["filedAt", getI64Encoder()],
       ["bump", getU8Encoder5()],
       ["drawnSeats", getU32Encoder3()],
-      ["padding", fixEncoderSize4(getBytesEncoder4(), 60)]
+      ["bountyPool", getU64Encoder7()],
+      ["padding", fixEncoderSize4(getBytesEncoder4(), 52)]
     ]),
     (value) => ({ ...value, discriminator: DISPUTE_DISCRIMINATOR })
   );
@@ -614,7 +617,8 @@ function getDisputeDecoder() {
     ["filedAt", getI64Decoder()],
     ["bump", getU8Decoder5()],
     ["drawnSeats", getU32Decoder3()],
-    ["padding", fixDecoderSize4(getBytesDecoder4(), 60)]
+    ["bountyPool", getU64Decoder7()],
+    ["padding", fixDecoderSize4(getBytesDecoder4(), 52)]
   ]);
 }
 __name(getDisputeDecoder, "getDisputeDecoder");
@@ -693,7 +697,8 @@ function getJurorStakeEncoder() {
       ["pendingWithdrawal", getU64Encoder8()],
       ["feesEarned", getU64Encoder8()],
       ["nextFree", getU32Encoder4()],
-      ["padding", fixEncoderSize5(getBytesEncoder5(), 64)]
+      ["prevFree", getU32Encoder4()],
+      ["padding", fixEncoderSize5(getBytesEncoder5(), 60)]
     ]),
     (value) => ({ ...value, discriminator: JUROR_STAKE_DISCRIMINATOR })
   );
@@ -714,7 +719,8 @@ function getJurorStakeDecoder() {
     ["pendingWithdrawal", getU64Decoder8()],
     ["feesEarned", getU64Decoder8()],
     ["nextFree", getU32Decoder4()],
-    ["padding", fixDecoderSize5(getBytesDecoder5(), 64)]
+    ["prevFree", getU32Decoder4()],
+    ["padding", fixDecoderSize5(getBytesDecoder5(), 60)]
   ]);
 }
 __name(getJurorStakeDecoder, "getJurorStakeDecoder");
@@ -1978,13 +1984,15 @@ function parseClaimAppealRefundInstruction(instruction) {
 }
 __name(parseClaimAppealRefundInstruction, "parseClaimAppealRefundInstruction");
 
-// src/generated/instructions/commit.ts
+// src/generated/instructions/claimFilingBounty.ts
 import {
   combineCodec as combineCodec18,
   fixDecoderSize as fixDecoderSize12,
   fixEncoderSize as fixEncoderSize13,
+  getAddressEncoder as getAddressEncoder19,
   getBytesDecoder as getBytesDecoder12,
   getBytesEncoder as getBytesEncoder20,
+  getProgramDerivedAddress as getProgramDerivedAddress12,
   getStructDecoder as getStructDecoder15,
   getStructEncoder as getStructEncoder15,
   SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS4,
@@ -1992,7 +2000,193 @@ import {
   transformEncoder as transformEncoder11
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory4
+  getAccountMetaFactory as getAccountMetaFactory4,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount4
+} from "@solana/kit/program-client-core";
+var CLAIM_FILING_BOUNTY_DISCRIMINATOR = new Uint8Array([0, 179, 28, 122, 171, 246, 12, 132]);
+function getClaimFilingBountyInstructionDataEncoder() {
+  return transformEncoder11(
+    getStructEncoder15([["discriminator", fixEncoderSize13(getBytesEncoder20(), 8)]]),
+    (value) => ({ ...value, discriminator: CLAIM_FILING_BOUNTY_DISCRIMINATOR })
+  );
+}
+__name(getClaimFilingBountyInstructionDataEncoder, "getClaimFilingBountyInstructionDataEncoder");
+function getClaimFilingBountyInstructionDataDecoder() {
+  return getStructDecoder15([
+    ["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)]
+  ]);
+}
+__name(getClaimFilingBountyInstructionDataDecoder, "getClaimFilingBountyInstructionDataDecoder");
+async function getClaimFilingBountyInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? ACCORD_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    caller: { value: input.caller ?? null, isWritable: false },
+    subaccord: { value: input.subaccord ?? null, isWritable: true },
+    dispute: { value: input.dispute ?? null, isWritable: true },
+    feeToken: { value: input.feeToken ?? null, isWritable: false },
+    filerTokenAccount: {
+      value: input.filerTokenAccount ?? null,
+      isWritable: true
+    },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await getProgramDerivedAddress12({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        getAddressEncoder19().encode(
+          getAddressFromResolvedInstructionAccount4(
+            "subaccord",
+            accounts.subaccord.value
+          )
+        ),
+        getBytesEncoder20().encode(
+          new Uint8Array([
+            6,
+            221,
+            246,
+            225,
+            215,
+            101,
+            161,
+            147,
+            217,
+            203,
+            225,
+            70,
+            206,
+            235,
+            121,
+            172,
+            28,
+            180,
+            133,
+            237,
+            95,
+            91,
+            55,
+            145,
+            58,
+            140,
+            245,
+            133,
+            126,
+            255,
+            0,
+            169
+          ])
+        ),
+        getAddressEncoder19().encode(
+          getAddressFromResolvedInstructionAccount4(
+            "feeToken",
+            accounts.feeToken.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  const getAccountMeta = getAccountMetaFactory4(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("caller", accounts.caller),
+      getAccountMeta("subaccord", accounts.subaccord),
+      getAccountMeta("dispute", accounts.dispute),
+      getAccountMeta("feeToken", accounts.feeToken),
+      getAccountMeta("filerTokenAccount", accounts.filerTokenAccount),
+      getAccountMeta("feeVault", accounts.feeVault),
+      getAccountMeta("tokenProgram", accounts.tokenProgram)
+    ],
+    data: getClaimFilingBountyInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+__name(getClaimFilingBountyInstructionAsync, "getClaimFilingBountyInstructionAsync");
+function getClaimFilingBountyInstruction(input, config) {
+  const programAddress = config?.programAddress ?? ACCORD_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    caller: { value: input.caller ?? null, isWritable: false },
+    subaccord: { value: input.subaccord ?? null, isWritable: true },
+    dispute: { value: input.dispute ?? null, isWritable: true },
+    feeToken: { value: input.feeToken ?? null, isWritable: false },
+    filerTokenAccount: {
+      value: input.filerTokenAccount ?? null,
+      isWritable: true
+    },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  const getAccountMeta = getAccountMetaFactory4(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("caller", accounts.caller),
+      getAccountMeta("subaccord", accounts.subaccord),
+      getAccountMeta("dispute", accounts.dispute),
+      getAccountMeta("feeToken", accounts.feeToken),
+      getAccountMeta("filerTokenAccount", accounts.filerTokenAccount),
+      getAccountMeta("feeVault", accounts.feeVault),
+      getAccountMeta("tokenProgram", accounts.tokenProgram)
+    ],
+    data: getClaimFilingBountyInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
+__name(getClaimFilingBountyInstruction, "getClaimFilingBountyInstruction");
+function parseClaimFilingBountyInstruction(instruction) {
+  if (instruction.accounts.length < 7) {
+    throw new SolanaError4(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS4,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 7
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = /* @__PURE__ */ __name(() => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  }, "getNextAccount");
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      caller: getNextAccount(),
+      subaccord: getNextAccount(),
+      dispute: getNextAccount(),
+      feeToken: getNextAccount(),
+      filerTokenAccount: getNextAccount(),
+      feeVault: getNextAccount(),
+      tokenProgram: getNextAccount()
+    },
+    data: getClaimFilingBountyInstructionDataDecoder().decode(instruction.data)
+  };
+}
+__name(parseClaimFilingBountyInstruction, "parseClaimFilingBountyInstruction");
+
+// src/generated/instructions/commit.ts
+import {
+  combineCodec as combineCodec19,
+  fixDecoderSize as fixDecoderSize13,
+  fixEncoderSize as fixEncoderSize14,
+  getBytesDecoder as getBytesDecoder13,
+  getBytesEncoder as getBytesEncoder21,
+  getStructDecoder as getStructDecoder16,
+  getStructEncoder as getStructEncoder16,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS5,
+  SolanaError as SolanaError5,
+  transformEncoder as transformEncoder12
+} from "@solana/kit";
+import {
+  getAccountMetaFactory as getAccountMetaFactory5
 } from "@solana/kit/program-client-core";
 var COMMIT_DISCRIMINATOR = new Uint8Array([
   223,
@@ -2005,19 +2199,19 @@ var COMMIT_DISCRIMINATOR = new Uint8Array([
   74
 ]);
 function getCommitInstructionDataEncoder() {
-  return transformEncoder11(
-    getStructEncoder15([
-      ["discriminator", fixEncoderSize13(getBytesEncoder20(), 8)],
-      ["commitment", fixEncoderSize13(getBytesEncoder20(), 32)]
+  return transformEncoder12(
+    getStructEncoder16([
+      ["discriminator", fixEncoderSize14(getBytesEncoder21(), 8)],
+      ["commitment", fixEncoderSize14(getBytesEncoder21(), 32)]
     ]),
     (value) => ({ ...value, discriminator: COMMIT_DISCRIMINATOR })
   );
 }
 __name(getCommitInstructionDataEncoder, "getCommitInstructionDataEncoder");
 function getCommitInstructionDataDecoder() {
-  return getStructDecoder15([
-    ["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)],
-    ["commitment", fixDecoderSize12(getBytesDecoder12(), 32)]
+  return getStructDecoder16([
+    ["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
+    ["commitment", fixDecoderSize13(getBytesDecoder13(), 32)]
   ]);
 }
 __name(getCommitInstructionDataDecoder, "getCommitInstructionDataDecoder");
@@ -2031,7 +2225,7 @@ function getCommitInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory4(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory5(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -2048,8 +2242,8 @@ function getCommitInstruction(input, config) {
 __name(getCommitInstruction, "getCommitInstruction");
 function parseCommitInstruction(instruction) {
   if (instruction.accounts.length < 4) {
-    throw new SolanaError4(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS4,
+    throw new SolanaError5(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS5,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 4
@@ -2077,35 +2271,35 @@ __name(parseCommitInstruction, "parseCommitInstruction");
 
 // src/generated/instructions/commitVrfCallback.ts
 import {
-  combineCodec as combineCodec19,
-  fixDecoderSize as fixDecoderSize13,
-  fixEncoderSize as fixEncoderSize14,
-  getBytesDecoder as getBytesDecoder13,
-  getBytesEncoder as getBytesEncoder21,
-  getStructDecoder as getStructDecoder16,
-  getStructEncoder as getStructEncoder16,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS5,
-  SolanaError as SolanaError5,
-  transformEncoder as transformEncoder12
+  combineCodec as combineCodec20,
+  fixDecoderSize as fixDecoderSize14,
+  fixEncoderSize as fixEncoderSize15,
+  getBytesDecoder as getBytesDecoder14,
+  getBytesEncoder as getBytesEncoder22,
+  getStructDecoder as getStructDecoder17,
+  getStructEncoder as getStructEncoder17,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS6,
+  SolanaError as SolanaError6,
+  transformEncoder as transformEncoder13
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory5
+  getAccountMetaFactory as getAccountMetaFactory6
 } from "@solana/kit/program-client-core";
 var COMMIT_VRF_CALLBACK_DISCRIMINATOR = new Uint8Array([51, 127, 131, 85, 83, 117, 121, 59]);
 function getCommitVrfCallbackInstructionDataEncoder() {
-  return transformEncoder12(
-    getStructEncoder16([
-      ["discriminator", fixEncoderSize14(getBytesEncoder21(), 8)],
-      ["randomness", fixEncoderSize14(getBytesEncoder21(), 32)]
+  return transformEncoder13(
+    getStructEncoder17([
+      ["discriminator", fixEncoderSize15(getBytesEncoder22(), 8)],
+      ["randomness", fixEncoderSize15(getBytesEncoder22(), 32)]
     ]),
     (value) => ({ ...value, discriminator: COMMIT_VRF_CALLBACK_DISCRIMINATOR })
   );
 }
 __name(getCommitVrfCallbackInstructionDataEncoder, "getCommitVrfCallbackInstructionDataEncoder");
 function getCommitVrfCallbackInstructionDataDecoder() {
-  return getStructDecoder16([
-    ["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
-    ["randomness", fixDecoderSize13(getBytesDecoder13(), 32)]
+  return getStructDecoder17([
+    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
+    ["randomness", fixDecoderSize14(getBytesDecoder14(), 32)]
   ]);
 }
 __name(getCommitVrfCallbackInstructionDataDecoder, "getCommitVrfCallbackInstructionDataDecoder");
@@ -2121,7 +2315,7 @@ function getCommitVrfCallbackInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory5(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory6(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("vrfProgramIdentity", accounts.vrfProgramIdentity),
@@ -2137,8 +2331,8 @@ function getCommitVrfCallbackInstruction(input, config) {
 __name(getCommitVrfCallbackInstruction, "getCommitVrfCallbackInstruction");
 function parseCommitVrfCallbackInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new SolanaError5(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS5,
+    throw new SolanaError6(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS6,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 3
@@ -2165,26 +2359,26 @@ __name(parseCommitVrfCallbackInstruction, "parseCommitVrfCallbackInstruction");
 
 // src/generated/instructions/createDispute.ts
 import {
-  combineCodec as combineCodec20,
-  fixDecoderSize as fixDecoderSize14,
-  fixEncoderSize as fixEncoderSize15,
-  getAddressEncoder as getAddressEncoder19,
+  combineCodec as combineCodec21,
+  fixDecoderSize as fixDecoderSize15,
+  fixEncoderSize as fixEncoderSize16,
+  getAddressEncoder as getAddressEncoder20,
   getArrayDecoder as getArrayDecoder3,
   getArrayEncoder as getArrayEncoder3,
-  getBytesDecoder as getBytesDecoder14,
-  getBytesEncoder as getBytesEncoder22,
-  getProgramDerivedAddress as getProgramDerivedAddress12,
-  getStructDecoder as getStructDecoder17,
-  getStructEncoder as getStructEncoder17,
+  getBytesDecoder as getBytesDecoder15,
+  getBytesEncoder as getBytesEncoder23,
+  getProgramDerivedAddress as getProgramDerivedAddress13,
+  getStructDecoder as getStructDecoder18,
+  getStructEncoder as getStructEncoder18,
   getU64Decoder as getU64Decoder12,
   getU64Encoder as getU64Encoder14,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS6,
-  SolanaError as SolanaError6,
-  transformEncoder as transformEncoder13
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS7,
+  SolanaError as SolanaError7,
+  transformEncoder as transformEncoder14
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory6,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount4,
+  getAccountMetaFactory as getAccountMetaFactory7,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount5,
   getNonNullResolvedInstructionInput as getNonNullResolvedInstructionInput2
 } from "@solana/kit/program-client-core";
 var CREATE_DISPUTE_DISCRIMINATOR = new Uint8Array([
@@ -2198,11 +2392,11 @@ var CREATE_DISPUTE_DISCRIMINATOR = new Uint8Array([
   105
 ]);
 function getCreateDisputeInstructionDataEncoder() {
-  return transformEncoder13(
-    getStructEncoder17([
-      ["discriminator", fixEncoderSize15(getBytesEncoder22(), 8)],
-      ["options", getArrayEncoder3(fixEncoderSize15(getBytesEncoder22(), 32))],
-      ["evidenceHash", fixEncoderSize15(getBytesEncoder22(), 32)],
+  return transformEncoder14(
+    getStructEncoder18([
+      ["discriminator", fixEncoderSize16(getBytesEncoder23(), 8)],
+      ["options", getArrayEncoder3(fixEncoderSize16(getBytesEncoder23(), 32))],
+      ["evidenceHash", fixEncoderSize16(getBytesEncoder23(), 32)],
       ["nonce", getU64Encoder14()],
       ["fee", getU64Encoder14()]
     ]),
@@ -2211,11 +2405,11 @@ function getCreateDisputeInstructionDataEncoder() {
 }
 __name(getCreateDisputeInstructionDataEncoder, "getCreateDisputeInstructionDataEncoder");
 function getCreateDisputeInstructionDataDecoder() {
-  return getStructDecoder17([
-    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
-    ["options", getArrayDecoder3(fixDecoderSize14(getBytesDecoder14(), 32))],
-    ["evidenceHash", fixDecoderSize14(getBytesDecoder14(), 32)],
-    ["nonce", getU64Decoder12()],
+  return getStructDecoder18([
+    ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)],
+    ["options", getArrayDecoder3(fixDecoderSize15(getBytesDecoder15(), 32))],
+    ["evidenceHash", fixDecoderSize15(getBytesDecoder15(), 32)],
+    ["nonce", getU64Decoder12()],
     ["fee", getU64Decoder12()]
   ]);
 }
@@ -2248,7 +2442,7 @@ async function getCreateDisputeInstructionAsync(input, config) {
   }
   if (!accounts.dispute.value) {
     accounts.dispute.value = await findDisputePda({
-      filer: getAddressFromResolvedInstructionAccount4(
+      filer: getAddressFromResolvedInstructionAccount5(
         "filer",
         accounts.filer.value
       ),
@@ -2256,16 +2450,16 @@ async function getCreateDisputeInstructionAsync(input, config) {
     });
   }
   if (!accounts.filerTokenAccount.value) {
-    accounts.filerTokenAccount.value = await getProgramDerivedAddress12({
+    accounts.filerTokenAccount.value = await getProgramDerivedAddress13({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder19().encode(
-          getAddressFromResolvedInstructionAccount4(
+        getAddressEncoder20().encode(
+          getAddressFromResolvedInstructionAccount5(
             "filer",
             accounts.filer.value
           )
         ),
-        getBytesEncoder22().encode(
+        getBytesEncoder23().encode(
           new Uint8Array([
             6,
             221,
@@ -2301,8 +2495,8 @@ async function getCreateDisputeInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder19().encode(
-          getAddressFromResolvedInstructionAccount4(
+        getAddressEncoder20().encode(
+          getAddressFromResolvedInstructionAccount5(
             "feeToken",
             accounts.feeToken.value
           )
@@ -2311,16 +2505,16 @@ async function getCreateDisputeInstructionAsync(input, config) {
     });
   }
   if (!accounts.feeVault.value) {
-    accounts.feeVault.value = await getProgramDerivedAddress12({
+    accounts.feeVault.value = await getProgramDerivedAddress13({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder19().encode(
-          getAddressFromResolvedInstructionAccount4(
+        getAddressEncoder20().encode(
+          getAddressFromResolvedInstructionAccount5(
             "subaccord",
             accounts.subaccord.value
           )
         ),
-        getBytesEncoder22().encode(
+        getBytesEncoder23().encode(
           new Uint8Array([
             6,
             221,
@@ -2356,8 +2550,8 @@ async function getCreateDisputeInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder19().encode(
-          getAddressFromResolvedInstructionAccount4(
+        getAddressEncoder20().encode(
+          getAddressFromResolvedInstructionAccount5(
             "feeToken",
             accounts.feeToken.value
           )
@@ -2374,7 +2568,7 @@ async function getCreateDisputeInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory6(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory7(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("filer", accounts.filer),
@@ -2428,7 +2622,7 @@ function getCreateDisputeInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory6(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory7(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("filer", accounts.filer),
@@ -2452,8 +2646,8 @@ function getCreateDisputeInstruction(input, config) {
 __name(getCreateDisputeInstruction, "getCreateDisputeInstruction");
 function parseCreateDisputeInstruction(instruction) {
   if (instruction.accounts.length < 11) {
-    throw new SolanaError6(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS6,
+    throw new SolanaError7(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS7,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 11
@@ -2488,15 +2682,15 @@ __name(parseCreateDisputeInstruction, "parseCreateDisputeInstruction");
 
 // src/generated/instructions/createSubaccord.ts
 import {
-  combineCodec as combineCodec21,
-  fixDecoderSize as fixDecoderSize15,
-  fixEncoderSize as fixEncoderSize16,
+  combineCodec as combineCodec22,
+  fixDecoderSize as fixDecoderSize16,
+  fixEncoderSize as fixEncoderSize17,
   getAddressDecoder as getAddressDecoder10,
-  getAddressEncoder as getAddressEncoder20,
-  getBytesDecoder as getBytesDecoder15,
-  getBytesEncoder as getBytesEncoder23,
-  getStructDecoder as getStructDecoder18,
-  getStructEncoder as getStructEncoder18,
+  getAddressEncoder as getAddressEncoder21,
+  getBytesDecoder as getBytesDecoder16,
+  getBytesEncoder as getBytesEncoder24,
+  getStructDecoder as getStructDecoder19,
+  getStructEncoder as getStructEncoder19,
   getU16Decoder as getU16Decoder4,
   getU16Encoder as getU16Encoder4,
   getU32Decoder as getU32Decoder8,
@@ -2505,22 +2699,22 @@ import {
   getU64Encoder as getU64Encoder15,
   getU8Decoder as getU8Decoder10,
   getU8Encoder as getU8Encoder10,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS7,
-  SolanaError as SolanaError7,
-  transformEncoder as transformEncoder14
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS8,
+  SolanaError as SolanaError8,
+  transformEncoder as transformEncoder15
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory7,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount5,
+  getAccountMetaFactory as getAccountMetaFactory8,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount6,
   getNonNullResolvedInstructionInput as getNonNullResolvedInstructionInput3
 } from "@solana/kit/program-client-core";
 var CREATE_SUBACCORD_DISCRIMINATOR = new Uint8Array([135, 240, 91, 50, 192, 161, 177, 22]);
 function getCreateSubaccordInstructionDataEncoder() {
-  return transformEncoder14(
-    getStructEncoder18([
-      ["discriminator", fixEncoderSize16(getBytesEncoder23(), 8)],
-      ["domainRef", fixEncoderSize16(getBytesEncoder23(), 32)],
-      ["evidenceSpec", fixEncoderSize16(getBytesEncoder23(), 32)],
+  return transformEncoder15(
+    getStructEncoder19([
+      ["discriminator", fixEncoderSize17(getBytesEncoder24(), 8)],
+      ["domainRef", fixEncoderSize17(getBytesEncoder24(), 32)],
+      ["evidenceSpec", fixEncoderSize17(getBytesEncoder24(), 32)],
       ["minStake", getU64Encoder15()],
       ["alphaBps", getU16Encoder4()],
       ["reviewWindow", getU64Encoder15()],
@@ -2535,21 +2729,21 @@ function getCreateSubaccordInstructionDataEncoder() {
       ["shortfallPolicy", getShortfallPolicyEncoder()],
       ["maxDrawAttempts", getU8Encoder10()],
       ["coherenceTolBps", getU16Encoder4()],
-      ["authority", getAddressEncoder20()],
-      ["evidenceOperator", getAddressEncoder20()],
+      ["authority", getAddressEncoder21()],
+      ["evidenceOperator", getAddressEncoder21()],
       ["depth", getU8Encoder10()],
-      ["jurorCredential", getAddressEncoder20()],
-      ["jurorSchema", getAddressEncoder20()]
+      ["jurorCredential", getAddressEncoder21()],
+      ["jurorSchema", getAddressEncoder21()]
     ]),
     (value) => ({ ...value, discriminator: CREATE_SUBACCORD_DISCRIMINATOR })
   );
 }
 __name(getCreateSubaccordInstructionDataEncoder, "getCreateSubaccordInstructionDataEncoder");
 function getCreateSubaccordInstructionDataDecoder() {
-  return getStructDecoder18([
-    ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)],
-    ["domainRef", fixDecoderSize15(getBytesDecoder15(), 32)],
-    ["evidenceSpec", fixDecoderSize15(getBytesDecoder15(), 32)],
+  return getStructDecoder19([
+    ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)],
+    ["domainRef", fixDecoderSize16(getBytesDecoder16(), 32)],
+    ["evidenceSpec", fixDecoderSize16(getBytesDecoder16(), 32)],
     ["minStake", getU64Decoder13()],
     ["alphaBps", getU16Decoder4()],
     ["reviewWindow", getU64Decoder13()],
@@ -2585,7 +2779,7 @@ async function getCreateSubaccordInstructionAsync(input, config) {
   const args = { ...input };
   if (!accounts.subaccord.value) {
     accounts.subaccord.value = await findSubaccordPda({
-      creator: getAddressFromResolvedInstructionAccount5(
+      creator: getAddressFromResolvedInstructionAccount6(
         "creator",
         accounts.creator.value
       ),
@@ -2598,7 +2792,7 @@ async function getCreateSubaccordInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory7(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory8(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("creator", accounts.creator),
@@ -2628,7 +2822,7 @@ function getCreateSubaccordInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory7(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory8(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("creator", accounts.creator),
@@ -2646,8 +2840,8 @@ function getCreateSubaccordInstruction(input, config) {
 __name(getCreateSubaccordInstruction, "getCreateSubaccordInstruction");
 function parseCreateSubaccordInstruction(instruction) {
   if (instruction.accounts.length < 5) {
-    throw new SolanaError7(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS7,
+    throw new SolanaError8(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS8,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 5
@@ -2676,23 +2870,23 @@ __name(parseCreateSubaccordInstruction, "parseCreateSubaccordInstruction");
 
 // src/generated/instructions/drawSeat.ts
 import {
-  combineCodec as combineCodec22,
-  fixDecoderSize as fixDecoderSize16,
-  fixEncoderSize as fixEncoderSize17,
+  combineCodec as combineCodec23,
+  fixDecoderSize as fixDecoderSize17,
+  fixEncoderSize as fixEncoderSize18,
   getArrayDecoder as getArrayDecoder4,
   getArrayEncoder as getArrayEncoder4,
-  getBytesDecoder as getBytesDecoder16,
-  getBytesEncoder as getBytesEncoder24,
-  getStructDecoder as getStructDecoder19,
-  getStructEncoder as getStructEncoder19,
+  getBytesDecoder as getBytesDecoder17,
+  getBytesEncoder as getBytesEncoder25,
+  getStructDecoder as getStructDecoder20,
+  getStructEncoder as getStructEncoder20,
   getU32Decoder as getU32Decoder9,
   getU32Encoder as getU32Encoder11,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS8,
-  SolanaError as SolanaError8,
-  transformEncoder as transformEncoder15
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9,
+  SolanaError as SolanaError9,
+  transformEncoder as transformEncoder16
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory8
+  getAccountMetaFactory as getAccountMetaFactory9
 } from "@solana/kit/program-client-core";
 var DRAW_SEAT_DISCRIMINATOR = new Uint8Array([
   52,
@@ -2705,9 +2899,9 @@ var DRAW_SEAT_DISCRIMINATOR = new Uint8Array([
   236
 ]);
 function getDrawSeatInstructionDataEncoder() {
-  return transformEncoder15(
-    getStructEncoder19([
-      ["discriminator", fixEncoderSize17(getBytesEncoder24(), 8)],
+  return transformEncoder16(
+    getStructEncoder20([
+      ["discriminator", fixEncoderSize18(getBytesEncoder25(), 8)],
       ["seat", getU32Encoder11()],
       ["retries", getU32Encoder11()],
       ["leaf", getLeafClaimEncoder()],
@@ -2719,8 +2913,8 @@ function getDrawSeatInstructionDataEncoder() {
 }
 __name(getDrawSeatInstructionDataEncoder, "getDrawSeatInstructionDataEncoder");
 function getDrawSeatInstructionDataDecoder() {
-  return getStructDecoder19([
-    ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)],
+  return getStructDecoder20([
+    ["discriminator", fixDecoderSize17(getBytesDecoder17(), 8)],
     ["seat", getU32Decoder9()],
     ["retries", getU32Decoder9()],
     ["leaf", getLeafClaimDecoder()],
@@ -2743,7 +2937,7 @@ function getDrawSeatInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory8(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory9(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -2761,8 +2955,8 @@ function getDrawSeatInstruction(input, config) {
 __name(getDrawSeatInstruction, "getDrawSeatInstruction");
 function parseDrawSeatInstruction(instruction) {
   if (instruction.accounts.length < 5) {
-    throw new SolanaError8(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS8,
+    throw new SolanaError9(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 5
@@ -2791,24 +2985,24 @@ __name(parseDrawSeatInstruction, "parseDrawSeatInstruction");
 
 // src/generated/instructions/executeSubaccordUpdate.ts
 import {
-  combineCodec as combineCodec23,
-  fixDecoderSize as fixDecoderSize17,
-  fixEncoderSize as fixEncoderSize18,
-  getBytesDecoder as getBytesDecoder17,
-  getBytesEncoder as getBytesEncoder25,
-  getStructDecoder as getStructDecoder20,
-  getStructEncoder as getStructEncoder20,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9,
-  SolanaError as SolanaError9,
-  transformEncoder as transformEncoder16
+  combineCodec as combineCodec24,
+  fixDecoderSize as fixDecoderSize18,
+  fixEncoderSize as fixEncoderSize19,
+  getBytesDecoder as getBytesDecoder18,
+  getBytesEncoder as getBytesEncoder26,
+  getStructDecoder as getStructDecoder21,
+  getStructEncoder as getStructEncoder21,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10,
+  SolanaError as SolanaError10,
+  transformEncoder as transformEncoder17
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory9
+  getAccountMetaFactory as getAccountMetaFactory10
 } from "@solana/kit/program-client-core";
 var EXECUTE_SUBACCORD_UPDATE_DISCRIMINATOR = new Uint8Array([145, 99, 105, 27, 63, 159, 254, 203]);
 function getExecuteSubaccordUpdateInstructionDataEncoder() {
-  return transformEncoder16(
-    getStructEncoder20([["discriminator", fixEncoderSize18(getBytesEncoder25(), 8)]]),
+  return transformEncoder17(
+    getStructEncoder21([["discriminator", fixEncoderSize19(getBytesEncoder26(), 8)]]),
     (value) => ({
       ...value,
       discriminator: EXECUTE_SUBACCORD_UPDATE_DISCRIMINATOR
@@ -2817,8 +3011,8 @@ function getExecuteSubaccordUpdateInstructionDataEncoder() {
 }
 __name(getExecuteSubaccordUpdateInstructionDataEncoder, "getExecuteSubaccordUpdateInstructionDataEncoder");
 function getExecuteSubaccordUpdateInstructionDataDecoder() {
-  return getStructDecoder20([
-    ["discriminator", fixDecoderSize17(getBytesDecoder17(), 8)]
+  return getStructDecoder21([
+    ["discriminator", fixDecoderSize18(getBytesDecoder18(), 8)]
   ]);
 }
 __name(getExecuteSubaccordUpdateInstructionDataDecoder, "getExecuteSubaccordUpdateInstructionDataDecoder");
@@ -2830,7 +3024,7 @@ function getExecuteSubaccordUpdateInstruction(input, config) {
     pendingUpdate: { value: input.pendingUpdate ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory9(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory10(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -2844,8 +3038,8 @@ function getExecuteSubaccordUpdateInstruction(input, config) {
 __name(getExecuteSubaccordUpdateInstruction, "getExecuteSubaccordUpdateInstruction");
 function parseExecuteSubaccordUpdateInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new SolanaError9(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS9,
+    throw new SolanaError10(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 3
@@ -2874,33 +3068,33 @@ __name(parseExecuteSubaccordUpdateInstruction, "parseExecuteSubaccordUpdateInstr
 
 // src/generated/instructions/executeUnpause.ts
 import {
-  combineCodec as combineCodec24,
-  fixDecoderSize as fixDecoderSize18,
-  fixEncoderSize as fixEncoderSize19,
-  getBytesDecoder as getBytesDecoder18,
-  getBytesEncoder as getBytesEncoder26,
-  getStructDecoder as getStructDecoder21,
-  getStructEncoder as getStructEncoder21,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10,
-  SolanaError as SolanaError10,
-  transformEncoder as transformEncoder17
+  combineCodec as combineCodec25,
+  fixDecoderSize as fixDecoderSize19,
+  fixEncoderSize as fixEncoderSize20,
+  getBytesDecoder as getBytesDecoder19,
+  getBytesEncoder as getBytesEncoder27,
+  getStructDecoder as getStructDecoder22,
+  getStructEncoder as getStructEncoder22,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11,
+  SolanaError as SolanaError11,
+  transformEncoder as transformEncoder18
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory10
+  getAccountMetaFactory as getAccountMetaFactory11
 } from "@solana/kit/program-client-core";
 var EXECUTE_UNPAUSE_DISCRIMINATOR = new Uint8Array(
   [55, 43, 56, 5, 154, 156, 52, 232]
 );
 function getExecuteUnpauseInstructionDataEncoder() {
-  return transformEncoder17(
-    getStructEncoder21([["discriminator", fixEncoderSize19(getBytesEncoder26(), 8)]]),
+  return transformEncoder18(
+    getStructEncoder22([["discriminator", fixEncoderSize20(getBytesEncoder27(), 8)]]),
     (value) => ({ ...value, discriminator: EXECUTE_UNPAUSE_DISCRIMINATOR })
   );
 }
 __name(getExecuteUnpauseInstructionDataEncoder, "getExecuteUnpauseInstructionDataEncoder");
 function getExecuteUnpauseInstructionDataDecoder() {
-  return getStructDecoder21([
-    ["discriminator", fixDecoderSize18(getBytesDecoder18(), 8)]
+  return getStructDecoder22([
+    ["discriminator", fixDecoderSize19(getBytesDecoder19(), 8)]
   ]);
 }
 __name(getExecuteUnpauseInstructionDataDecoder, "getExecuteUnpauseInstructionDataDecoder");
@@ -2914,7 +3108,7 @@ async function getExecuteUnpauseInstructionAsync(input, config) {
   if (!accounts.accordState.value) {
     accounts.accordState.value = await findAccordStatePda();
   }
-  const getAccountMeta = getAccountMetaFactory10(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory11(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -2932,7 +3126,7 @@ function getExecuteUnpauseInstruction(input, config) {
     accordState: { value: input.accordState ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory10(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory11(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -2945,8 +3139,8 @@ function getExecuteUnpauseInstruction(input, config) {
 __name(getExecuteUnpauseInstruction, "getExecuteUnpauseInstruction");
 function parseExecuteUnpauseInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new SolanaError10(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS10,
+    throw new SolanaError11(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 2
@@ -2969,31 +3163,31 @@ __name(parseExecuteUnpauseInstruction, "parseExecuteUnpauseInstruction");
 
 // src/generated/instructions/finalizeDispute.ts
 import {
-  combineCodec as combineCodec25,
-  fixDecoderSize as fixDecoderSize19,
-  fixEncoderSize as fixEncoderSize20,
-  getBytesDecoder as getBytesDecoder19,
-  getBytesEncoder as getBytesEncoder27,
-  getStructDecoder as getStructDecoder22,
-  getStructEncoder as getStructEncoder22,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11,
-  SolanaError as SolanaError11,
-  transformEncoder as transformEncoder18
+  combineCodec as combineCodec26,
+  fixDecoderSize as fixDecoderSize20,
+  fixEncoderSize as fixEncoderSize21,
+  getBytesDecoder as getBytesDecoder20,
+  getBytesEncoder as getBytesEncoder28,
+  getStructDecoder as getStructDecoder23,
+  getStructEncoder as getStructEncoder23,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12,
+  SolanaError as SolanaError12,
+  transformEncoder as transformEncoder19
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory11
+  getAccountMetaFactory as getAccountMetaFactory12
 } from "@solana/kit/program-client-core";
 var FINALIZE_DISPUTE_DISCRIMINATOR = new Uint8Array([190, 211, 17, 122, 247, 157, 27, 223]);
 function getFinalizeDisputeInstructionDataEncoder() {
-  return transformEncoder18(
-    getStructEncoder22([["discriminator", fixEncoderSize20(getBytesEncoder27(), 8)]]),
+  return transformEncoder19(
+    getStructEncoder23([["discriminator", fixEncoderSize21(getBytesEncoder28(), 8)]]),
     (value) => ({ ...value, discriminator: FINALIZE_DISPUTE_DISCRIMINATOR })
   );
 }
 __name(getFinalizeDisputeInstructionDataEncoder, "getFinalizeDisputeInstructionDataEncoder");
 function getFinalizeDisputeInstructionDataDecoder() {
-  return getStructDecoder22([
-    ["discriminator", fixDecoderSize19(getBytesDecoder19(), 8)]
+  return getStructDecoder23([
+    ["discriminator", fixDecoderSize20(getBytesDecoder20(), 8)]
   ]);
 }
 __name(getFinalizeDisputeInstructionDataDecoder, "getFinalizeDisputeInstructionDataDecoder");
@@ -3006,7 +3200,7 @@ function getFinalizeDisputeInstruction(input, config) {
     round: { value: input.round ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory11(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory12(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -3021,8 +3215,8 @@ function getFinalizeDisputeInstruction(input, config) {
 __name(getFinalizeDisputeInstruction, "getFinalizeDisputeInstruction");
 function parseFinalizeDisputeInstruction(instruction) {
   if (instruction.accounts.length < 4) {
-    throw new SolanaError11(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS11,
+    throw new SolanaError12(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 4
@@ -3050,19 +3244,19 @@ __name(parseFinalizeDisputeInstruction, "parseFinalizeDisputeInstruction");
 
 // src/generated/instructions/finalizeRound.ts
 import {
-  combineCodec as combineCodec26,
-  fixDecoderSize as fixDecoderSize20,
-  fixEncoderSize as fixEncoderSize21,
-  getBytesDecoder as getBytesDecoder20,
-  getBytesEncoder as getBytesEncoder28,
-  getStructDecoder as getStructDecoder23,
-  getStructEncoder as getStructEncoder23,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12,
-  SolanaError as SolanaError12,
-  transformEncoder as transformEncoder19
+  combineCodec as combineCodec27,
+  fixDecoderSize as fixDecoderSize21,
+  fixEncoderSize as fixEncoderSize22,
+  getBytesDecoder as getBytesDecoder21,
+  getBytesEncoder as getBytesEncoder29,
+  getStructDecoder as getStructDecoder24,
+  getStructEncoder as getStructEncoder24,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13,
+  SolanaError as SolanaError13,
+  transformEncoder as transformEncoder20
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory12
+  getAccountMetaFactory as getAccountMetaFactory13
 } from "@solana/kit/program-client-core";
 var FINALIZE_ROUND_DISCRIMINATOR = new Uint8Array([
   239,
@@ -3075,15 +3269,15 @@ var FINALIZE_ROUND_DISCRIMINATOR = new Uint8Array([
   148
 ]);
 function getFinalizeRoundInstructionDataEncoder() {
-  return transformEncoder19(
-    getStructEncoder23([["discriminator", fixEncoderSize21(getBytesEncoder28(), 8)]]),
+  return transformEncoder20(
+    getStructEncoder24([["discriminator", fixEncoderSize22(getBytesEncoder29(), 8)]]),
     (value) => ({ ...value, discriminator: FINALIZE_ROUND_DISCRIMINATOR })
   );
 }
 __name(getFinalizeRoundInstructionDataEncoder, "getFinalizeRoundInstructionDataEncoder");
 function getFinalizeRoundInstructionDataDecoder() {
-  return getStructDecoder23([
-    ["discriminator", fixDecoderSize20(getBytesDecoder20(), 8)]
+  return getStructDecoder24([
+    ["discriminator", fixDecoderSize21(getBytesDecoder21(), 8)]
   ]);
 }
 __name(getFinalizeRoundInstructionDataDecoder, "getFinalizeRoundInstructionDataDecoder");
@@ -3096,7 +3290,7 @@ function getFinalizeRoundInstruction(input, config) {
     round: { value: input.round ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory12(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory13(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -3111,8 +3305,8 @@ function getFinalizeRoundInstruction(input, config) {
 __name(getFinalizeRoundInstruction, "getFinalizeRoundInstruction");
 function parseFinalizeRoundInstruction(instruction) {
   if (instruction.accounts.length < 4) {
-    throw new SolanaError12(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12,
+    throw new SolanaError13(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 4
@@ -3140,20 +3334,20 @@ __name(parseFinalizeRoundInstruction, "parseFinalizeRoundInstruction");
 
 // src/generated/instructions/getRuling.ts
 import {
-  combineCodec as combineCodec27,
-  fixDecoderSize as fixDecoderSize21,
-  fixEncoderSize as fixEncoderSize22,
-  getBytesDecoder as getBytesDecoder21,
-  getBytesEncoder as getBytesEncoder29,
-  getStructDecoder as getStructDecoder24,
-  getStructEncoder as getStructEncoder24,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13,
-  SolanaError as SolanaError13,
-  transformEncoder as transformEncoder20
-} from "@solana/kit";
-import {
-  getAccountMetaFactory as getAccountMetaFactory13
-} from "@solana/kit/program-client-core";
+  combineCodec as combineCodec28,
+  fixDecoderSize as fixDecoderSize22,
+  fixEncoderSize as fixEncoderSize23,
+  getBytesDecoder as getBytesDecoder22,
+  getBytesEncoder as getBytesEncoder30,
+  getStructDecoder as getStructDecoder25,
+  getStructEncoder as getStructEncoder25,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS14,
+  SolanaError as SolanaError14,
+  transformEncoder as transformEncoder21
+} from "@solana/kit";
+import {
+  getAccountMetaFactory as getAccountMetaFactory14
+} from "@solana/kit/program-client-core";
 var GET_RULING_DISCRIMINATOR = new Uint8Array([
   196,
   52,
@@ -3165,15 +3359,15 @@ var GET_RULING_DISCRIMINATOR = new Uint8Array([
   16
 ]);
 function getGetRulingInstructionDataEncoder() {
-  return transformEncoder20(
-    getStructEncoder24([["discriminator", fixEncoderSize22(getBytesEncoder29(), 8)]]),
+  return transformEncoder21(
+    getStructEncoder25([["discriminator", fixEncoderSize23(getBytesEncoder30(), 8)]]),
     (value) => ({ ...value, discriminator: GET_RULING_DISCRIMINATOR })
   );
 }
 __name(getGetRulingInstructionDataEncoder, "getGetRulingInstructionDataEncoder");
 function getGetRulingInstructionDataDecoder() {
-  return getStructDecoder24([
-    ["discriminator", fixDecoderSize21(getBytesDecoder21(), 8)]
+  return getStructDecoder25([
+    ["discriminator", fixDecoderSize22(getBytesDecoder22(), 8)]
   ]);
 }
 __name(getGetRulingInstructionDataDecoder, "getGetRulingInstructionDataDecoder");
@@ -3184,7 +3378,7 @@ function getGetRulingInstruction(input, config) {
     dispute: { value: input.dispute ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory13(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory14(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -3197,8 +3391,8 @@ function getGetRulingInstruction(input, config) {
 __name(getGetRulingInstruction, "getGetRulingInstruction");
 function parseGetRulingInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new SolanaError13(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS13,
+    throw new SolanaError14(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS14,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 2
@@ -3221,19 +3415,19 @@ __name(parseGetRulingInstruction, "parseGetRulingInstruction");
 
 // src/generated/instructions/health.ts
 import {
-  combineCodec as combineCodec28,
-  fixDecoderSize as fixDecoderSize22,
-  fixEncoderSize as fixEncoderSize23,
-  getBytesDecoder as getBytesDecoder22,
-  getBytesEncoder as getBytesEncoder30,
-  getStructDecoder as getStructDecoder25,
-  getStructEncoder as getStructEncoder25,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS14,
-  SolanaError as SolanaError14,
-  transformEncoder as transformEncoder21
+  combineCodec as combineCodec29,
+  fixDecoderSize as fixDecoderSize23,
+  fixEncoderSize as fixEncoderSize24,
+  getBytesDecoder as getBytesDecoder23,
+  getBytesEncoder as getBytesEncoder31,
+  getStructDecoder as getStructDecoder26,
+  getStructEncoder as getStructEncoder26,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS15,
+  SolanaError as SolanaError15,
+  transformEncoder as transformEncoder22
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory14
+  getAccountMetaFactory as getAccountMetaFactory15
 } from "@solana/kit/program-client-core";
 var HEALTH_DISCRIMINATOR = new Uint8Array([
   235,
@@ -3246,15 +3440,15 @@ var HEALTH_DISCRIMINATOR = new Uint8Array([
   16
 ]);
 function getHealthInstructionDataEncoder() {
-  return transformEncoder21(
-    getStructEncoder25([["discriminator", fixEncoderSize23(getBytesEncoder30(), 8)]]),
+  return transformEncoder22(
+    getStructEncoder26([["discriminator", fixEncoderSize24(getBytesEncoder31(), 8)]]),
     (value) => ({ ...value, discriminator: HEALTH_DISCRIMINATOR })
   );
 }
 __name(getHealthInstructionDataEncoder, "getHealthInstructionDataEncoder");
 function getHealthInstructionDataDecoder() {
-  return getStructDecoder25([
-    ["discriminator", fixDecoderSize22(getBytesDecoder22(), 8)]
+  return getStructDecoder26([
+    ["discriminator", fixDecoderSize23(getBytesDecoder23(), 8)]
   ]);
 }
 __name(getHealthInstructionDataDecoder, "getHealthInstructionDataDecoder");
@@ -3264,7 +3458,7 @@ function getHealthInstruction(input, config) {
     caller: { value: input.caller ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory14(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory15(programAddress, "programId");
   return Object.freeze({
     accounts: [getAccountMeta("caller", accounts.caller)],
     data: getHealthInstructionDataEncoder().encode({}),
@@ -3274,8 +3468,8 @@ function getHealthInstruction(input, config) {
 __name(getHealthInstruction, "getHealthInstruction");
 function parseHealthInstruction(instruction) {
   if (instruction.accounts.length < 1) {
-    throw new SolanaError14(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS14,
+    throw new SolanaError15(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS15,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 1
@@ -3298,31 +3492,31 @@ __name(parseHealthInstruction, "parseHealthInstruction");
 
 // src/generated/instructions/initializePause.ts
 import {
-  combineCodec as combineCodec29,
-  fixDecoderSize as fixDecoderSize23,
-  fixEncoderSize as fixEncoderSize24,
-  getBytesDecoder as getBytesDecoder23,
-  getBytesEncoder as getBytesEncoder31,
-  getStructDecoder as getStructDecoder26,
-  getStructEncoder as getStructEncoder26,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS15,
-  SolanaError as SolanaError15,
-  transformEncoder as transformEncoder22
+  combineCodec as combineCodec30,
+  fixDecoderSize as fixDecoderSize24,
+  fixEncoderSize as fixEncoderSize25,
+  getBytesDecoder as getBytesDecoder24,
+  getBytesEncoder as getBytesEncoder32,
+  getStructDecoder as getStructDecoder27,
+  getStructEncoder as getStructEncoder27,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS16,
+  SolanaError as SolanaError16,
+  transformEncoder as transformEncoder23
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory15
+  getAccountMetaFactory as getAccountMetaFactory16
 } from "@solana/kit/program-client-core";
 var INITIALIZE_PAUSE_DISCRIMINATOR = new Uint8Array([70, 32, 55, 248, 231, 46, 123, 153]);
 function getInitializePauseInstructionDataEncoder() {
-  return transformEncoder22(
-    getStructEncoder26([["discriminator", fixEncoderSize24(getBytesEncoder31(), 8)]]),
+  return transformEncoder23(
+    getStructEncoder27([["discriminator", fixEncoderSize25(getBytesEncoder32(), 8)]]),
     (value) => ({ ...value, discriminator: INITIALIZE_PAUSE_DISCRIMINATOR })
   );
 }
 __name(getInitializePauseInstructionDataEncoder, "getInitializePauseInstructionDataEncoder");
 function getInitializePauseInstructionDataDecoder() {
-  return getStructDecoder26([
-    ["discriminator", fixDecoderSize23(getBytesDecoder23(), 8)]
+  return getStructDecoder27([
+    ["discriminator", fixDecoderSize24(getBytesDecoder24(), 8)]
   ]);
 }
 __name(getInitializePauseInstructionDataDecoder, "getInitializePauseInstructionDataDecoder");
@@ -3340,7 +3534,7 @@ async function getInitializePauseInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory15(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory16(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3363,7 +3557,7 @@ function getInitializePauseInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory15(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory16(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3377,8 +3571,8 @@ function getInitializePauseInstruction(input, config) {
 __name(getInitializePauseInstruction, "getInitializePauseInstruction");
 function parseInitializePauseInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new SolanaError15(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS15,
+    throw new SolanaError16(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS16,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 3
@@ -3405,19 +3599,19 @@ __name(parseInitializePauseInstruction, "parseInitializePauseInstruction");
 
 // src/generated/instructions/pause.ts
 import {
-  combineCodec as combineCodec30,
-  fixDecoderSize as fixDecoderSize24,
-  fixEncoderSize as fixEncoderSize25,
-  getBytesDecoder as getBytesDecoder24,
-  getBytesEncoder as getBytesEncoder32,
-  getStructDecoder as getStructDecoder27,
-  getStructEncoder as getStructEncoder27,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS16,
-  SolanaError as SolanaError16,
-  transformEncoder as transformEncoder23
+  combineCodec as combineCodec31,
+  fixDecoderSize as fixDecoderSize25,
+  fixEncoderSize as fixEncoderSize26,
+  getBytesDecoder as getBytesDecoder25,
+  getBytesEncoder as getBytesEncoder33,
+  getStructDecoder as getStructDecoder28,
+  getStructEncoder as getStructEncoder28,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS17,
+  SolanaError as SolanaError17,
+  transformEncoder as transformEncoder24
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory16
+  getAccountMetaFactory as getAccountMetaFactory17
 } from "@solana/kit/program-client-core";
 var PAUSE_DISCRIMINATOR = new Uint8Array([
   211,
@@ -3430,15 +3624,15 @@ var PAUSE_DISCRIMINATOR = new Uint8Array([
   47
 ]);
 function getPauseInstructionDataEncoder() {
-  return transformEncoder23(
-    getStructEncoder27([["discriminator", fixEncoderSize25(getBytesEncoder32(), 8)]]),
+  return transformEncoder24(
+    getStructEncoder28([["discriminator", fixEncoderSize26(getBytesEncoder33(), 8)]]),
     (value) => ({ ...value, discriminator: PAUSE_DISCRIMINATOR })
   );
 }
 __name(getPauseInstructionDataEncoder, "getPauseInstructionDataEncoder");
 function getPauseInstructionDataDecoder() {
-  return getStructDecoder27([
-    ["discriminator", fixDecoderSize24(getBytesDecoder24(), 8)]
+  return getStructDecoder28([
+    ["discriminator", fixDecoderSize25(getBytesDecoder25(), 8)]
   ]);
 }
 __name(getPauseInstructionDataDecoder, "getPauseInstructionDataDecoder");
@@ -3452,7 +3646,7 @@ async function getPauseInstructionAsync(input, config) {
   if (!accounts.accordState.value) {
     accounts.accordState.value = await findAccordStatePda();
   }
-  const getAccountMeta = getAccountMetaFactory16(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory17(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3470,7 +3664,7 @@ function getPauseInstruction(input, config) {
     accordState: { value: input.accordState ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory16(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory17(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3483,8 +3677,8 @@ function getPauseInstruction(input, config) {
 __name(getPauseInstruction, "getPauseInstruction");
 function parsePauseInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new SolanaError16(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS16,
+    throw new SolanaError17(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS17,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 2
@@ -3507,29 +3701,29 @@ __name(parsePauseInstruction, "parsePauseInstruction");
 
 // src/generated/instructions/proposeSubaccordUpdate.ts
 import {
-  combineCodec as combineCodec31,
-  fixDecoderSize as fixDecoderSize25,
-  fixEncoderSize as fixEncoderSize26,
-  getBytesDecoder as getBytesDecoder25,
-  getBytesEncoder as getBytesEncoder33,
-  getStructDecoder as getStructDecoder28,
-  getStructEncoder as getStructEncoder28,
+  combineCodec as combineCodec32,
+  fixDecoderSize as fixDecoderSize26,
+  fixEncoderSize as fixEncoderSize27,
+  getBytesDecoder as getBytesDecoder26,
+  getBytesEncoder as getBytesEncoder34,
+  getStructDecoder as getStructDecoder29,
+  getStructEncoder as getStructEncoder29,
   getU64Decoder as getU64Decoder14,
   getU64Encoder as getU64Encoder16,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS17,
-  SolanaError as SolanaError17,
-  transformEncoder as transformEncoder24
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS18,
+  SolanaError as SolanaError18,
+  transformEncoder as transformEncoder25
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory17,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount6,
+  getAccountMetaFactory as getAccountMetaFactory18,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount7,
   getNonNullResolvedInstructionInput as getNonNullResolvedInstructionInput4
 } from "@solana/kit/program-client-core";
 var PROPOSE_SUBACCORD_UPDATE_DISCRIMINATOR = new Uint8Array([8, 224, 186, 131, 130, 76, 165, 172]);
 function getProposeSubaccordUpdateInstructionDataEncoder() {
-  return transformEncoder24(
-    getStructEncoder28([
-      ["discriminator", fixEncoderSize26(getBytesEncoder33(), 8)],
+  return transformEncoder25(
+    getStructEncoder29([
+      ["discriminator", fixEncoderSize27(getBytesEncoder34(), 8)],
       ["nonce", getU64Encoder16()],
       ["payload", getUpdatePayloadEncoder()]
     ]),
@@ -3541,8 +3735,8 @@ function getProposeSubaccordUpdateInstructionDataEncoder() {
 }
 __name(getProposeSubaccordUpdateInstructionDataEncoder, "getProposeSubaccordUpdateInstructionDataEncoder");
 function getProposeSubaccordUpdateInstructionDataDecoder() {
-  return getStructDecoder28([
-    ["discriminator", fixDecoderSize25(getBytesDecoder25(), 8)],
+  return getStructDecoder29([
+    ["discriminator", fixDecoderSize26(getBytesDecoder26(), 8)],
     ["nonce", getU64Decoder14()],
     ["payload", getUpdatePayloadDecoder()]
   ]);
@@ -3561,7 +3755,7 @@ async function getProposeSubaccordUpdateInstructionAsync(input, config) {
   const args = { ...input };
   if (!accounts.pendingUpdate.value) {
     accounts.pendingUpdate.value = await findPendingUpdatePda({
-      subaccord: getAddressFromResolvedInstructionAccount6(
+      subaccord: getAddressFromResolvedInstructionAccount7(
         "subaccord",
         accounts.subaccord.value
       ),
@@ -3571,7 +3765,7 @@ async function getProposeSubaccordUpdateInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory17(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory18(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3601,7 +3795,7 @@ function getProposeSubaccordUpdateInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory17(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory18(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3619,8 +3813,8 @@ function getProposeSubaccordUpdateInstruction(input, config) {
 __name(getProposeSubaccordUpdateInstruction, "getProposeSubaccordUpdateInstruction");
 function parseProposeSubaccordUpdateInstruction(instruction) {
   if (instruction.accounts.length < 5) {
-    throw new SolanaError17(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS17,
+    throw new SolanaError18(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS18,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 5
@@ -3651,33 +3845,33 @@ __name(parseProposeSubaccordUpdateInstruction, "parseProposeSubaccordUpdateInstr
 
 // src/generated/instructions/proposeUnpause.ts
 import {
-  combineCodec as combineCodec32,
-  fixDecoderSize as fixDecoderSize26,
-  fixEncoderSize as fixEncoderSize27,
-  getBytesDecoder as getBytesDecoder26,
-  getBytesEncoder as getBytesEncoder34,
-  getStructDecoder as getStructDecoder29,
-  getStructEncoder as getStructEncoder29,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS18,
-  SolanaError as SolanaError18,
-  transformEncoder as transformEncoder25
+  combineCodec as combineCodec33,
+  fixDecoderSize as fixDecoderSize27,
+  fixEncoderSize as fixEncoderSize28,
+  getBytesDecoder as getBytesDecoder27,
+  getBytesEncoder as getBytesEncoder35,
+  getStructDecoder as getStructDecoder30,
+  getStructEncoder as getStructEncoder30,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS19,
+  SolanaError as SolanaError19,
+  transformEncoder as transformEncoder26
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory18
+  getAccountMetaFactory as getAccountMetaFactory19
 } from "@solana/kit/program-client-core";
 var PROPOSE_UNPAUSE_DISCRIMINATOR = new Uint8Array(
   [45, 136, 163, 143, 156, 57, 113, 132]
 );
 function getProposeUnpauseInstructionDataEncoder() {
-  return transformEncoder25(
-    getStructEncoder29([["discriminator", fixEncoderSize27(getBytesEncoder34(), 8)]]),
+  return transformEncoder26(
+    getStructEncoder30([["discriminator", fixEncoderSize28(getBytesEncoder35(), 8)]]),
     (value) => ({ ...value, discriminator: PROPOSE_UNPAUSE_DISCRIMINATOR })
   );
 }
 __name(getProposeUnpauseInstructionDataEncoder, "getProposeUnpauseInstructionDataEncoder");
 function getProposeUnpauseInstructionDataDecoder() {
-  return getStructDecoder29([
-    ["discriminator", fixDecoderSize26(getBytesDecoder26(), 8)]
+  return getStructDecoder30([
+    ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)]
   ]);
 }
 __name(getProposeUnpauseInstructionDataDecoder, "getProposeUnpauseInstructionDataDecoder");
@@ -3691,7 +3885,7 @@ async function getProposeUnpauseInstructionAsync(input, config) {
   if (!accounts.accordState.value) {
     accounts.accordState.value = await findAccordStatePda();
   }
-  const getAccountMeta = getAccountMetaFactory18(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory19(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3709,7 +3903,7 @@ function getProposeUnpauseInstruction(input, config) {
     accordState: { value: input.accordState ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
-  const getAccountMeta = getAccountMetaFactory18(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory19(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -3722,8 +3916,8 @@ function getProposeUnpauseInstruction(input, config) {
 __name(getProposeUnpauseInstruction, "getProposeUnpauseInstruction");
 function parseProposeUnpauseInstruction(instruction) {
   if (instruction.accounts.length < 2) {
-    throw new SolanaError18(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS18,
+    throw new SolanaError19(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS19,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 2
@@ -3746,22 +3940,22 @@ __name(parseProposeUnpauseInstruction, "parseProposeUnpauseInstruction");
 
 // src/generated/instructions/pruneJuror.ts
 import {
-  combineCodec as combineCodec33,
-  fixDecoderSize as fixDecoderSize27,
-  fixEncoderSize as fixEncoderSize28,
+  combineCodec as combineCodec34,
+  fixDecoderSize as fixDecoderSize28,
+  fixEncoderSize as fixEncoderSize29,
   getArrayDecoder as getArrayDecoder5,
   getArrayEncoder as getArrayEncoder5,
-  getBytesDecoder as getBytesDecoder27,
-  getBytesEncoder as getBytesEncoder35,
-  getStructDecoder as getStructDecoder30,
-  getStructEncoder as getStructEncoder30,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS19,
-  SolanaError as SolanaError19,
-  transformEncoder as transformEncoder26
+  getBytesDecoder as getBytesDecoder28,
+  getBytesEncoder as getBytesEncoder36,
+  getStructDecoder as getStructDecoder31,
+  getStructEncoder as getStructEncoder31,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS20,
+  SolanaError as SolanaError20,
+  transformEncoder as transformEncoder27
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory19,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount7
+  getAccountMetaFactory as getAccountMetaFactory20,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount8
 } from "@solana/kit/program-client-core";
 var PRUNE_JUROR_DISCRIMINATOR = new Uint8Array([
   49,
@@ -3774,9 +3968,9 @@ var PRUNE_JUROR_DISCRIMINATOR = new Uint8Array([
   167
 ]);
 function getPruneJurorInstructionDataEncoder() {
-  return transformEncoder26(
-    getStructEncoder30([
-      ["discriminator", fixEncoderSize28(getBytesEncoder35(), 8)],
+  return transformEncoder27(
+    getStructEncoder31([
+      ["discriminator", fixEncoderSize29(getBytesEncoder36(), 8)],
       ["path", getArrayEncoder5(getMSTNodeEncoder())]
     ]),
     (value) => ({ ...value, discriminator: PRUNE_JUROR_DISCRIMINATOR })
@@ -3784,8 +3978,8 @@ function getPruneJurorInstructionDataEncoder() {
 }
 __name(getPruneJurorInstructionDataEncoder, "getPruneJurorInstructionDataEncoder");
 function getPruneJurorInstructionDataDecoder() {
-  return getStructDecoder30([
-    ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)],
+  return getStructDecoder31([
+    ["discriminator", fixDecoderSize28(getBytesDecoder28(), 8)],
     ["path", getArrayDecoder5(getMSTNodeDecoder())]
   ]);
 }
@@ -3803,11 +3997,11 @@ async function getPruneJurorInstructionAsync(input, config) {
   const args = { ...input };
   if (!accounts.jurorStake.value) {
     accounts.jurorStake.value = await findJurorStakePda({
-      subaccord: getAddressFromResolvedInstructionAccount7(
+      subaccord: getAddressFromResolvedInstructionAccount8(
         "subaccord",
         accounts.subaccord.value
       ),
-      juror: getAddressFromResolvedInstructionAccount7(
+      juror: getAddressFromResolvedInstructionAccount8(
         "juror",
         accounts.juror.value
       )
@@ -3816,7 +4010,7 @@ async function getPruneJurorInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory19(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory20(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -3846,7 +4040,7 @@ function getPruneJurorInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory19(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory20(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -3864,8 +4058,8 @@ function getPruneJurorInstruction(input, config) {
 __name(getPruneJurorInstruction, "getPruneJurorInstruction");
 function parsePruneJurorInstruction(instruction) {
   if (instruction.accounts.length < 5) {
-    throw new SolanaError19(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS19,
+    throw new SolanaError20(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS20,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 5
@@ -3894,21 +4088,21 @@ __name(parsePruneJurorInstruction, "parsePruneJurorInstruction");
 
 // src/generated/instructions/reclaimSlot.ts
 import {
-  combineCodec as combineCodec34,
-  fixDecoderSize as fixDecoderSize28,
-  fixEncoderSize as fixEncoderSize29,
+  combineCodec as combineCodec35,
+  fixDecoderSize as fixDecoderSize29,
+  fixEncoderSize as fixEncoderSize30,
   getArrayDecoder as getArrayDecoder6,
   getArrayEncoder as getArrayEncoder6,
-  getBytesDecoder as getBytesDecoder28,
-  getBytesEncoder as getBytesEncoder36,
-  getStructDecoder as getStructDecoder31,
-  getStructEncoder as getStructEncoder31,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS20,
-  SolanaError as SolanaError20,
-  transformEncoder as transformEncoder27
+  getBytesDecoder as getBytesDecoder29,
+  getBytesEncoder as getBytesEncoder37,
+  getStructDecoder as getStructDecoder32,
+  getStructEncoder as getStructEncoder32,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS21,
+  SolanaError as SolanaError21,
+  transformEncoder as transformEncoder28
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory20
+  getAccountMetaFactory as getAccountMetaFactory21
 } from "@solana/kit/program-client-core";
 var RECLAIM_SLOT_DISCRIMINATOR = new Uint8Array([
   44,
@@ -3921,9 +4115,9 @@ var RECLAIM_SLOT_DISCRIMINATOR = new Uint8Array([
   5
 ]);
 function getReclaimSlotInstructionDataEncoder() {
-  return transformEncoder27(
-    getStructEncoder31([
-      ["discriminator", fixEncoderSize29(getBytesEncoder36(), 8)],
+  return transformEncoder28(
+    getStructEncoder32([
+      ["discriminator", fixEncoderSize30(getBytesEncoder37(), 8)],
       ["path", getArrayEncoder6(getMSTNodeEncoder())]
     ]),
     (value) => ({ ...value, discriminator: RECLAIM_SLOT_DISCRIMINATOR })
@@ -3931,8 +4125,8 @@ function getReclaimSlotInstructionDataEncoder() {
 }
 __name(getReclaimSlotInstructionDataEncoder, "getReclaimSlotInstructionDataEncoder");
 function getReclaimSlotInstructionDataDecoder() {
-  return getStructDecoder31([
-    ["discriminator", fixDecoderSize28(getBytesDecoder28(), 8)],
+  return getStructDecoder32([
+    ["discriminator", fixDecoderSize29(getBytesDecoder29(), 8)],
     ["path", getArrayDecoder6(getMSTNodeDecoder())]
   ]);
 }
@@ -3946,7 +4140,7 @@ function getReclaimSlotInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory20(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory21(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -3962,8 +4156,8 @@ function getReclaimSlotInstruction(input, config) {
 __name(getReclaimSlotInstruction, "getReclaimSlotInstruction");
 function parseReclaimSlotInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new SolanaError20(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS20,
+    throw new SolanaError21(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS21,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 3
@@ -3990,29 +4184,29 @@ __name(parseReclaimSlotInstruction, "parseReclaimSlotInstruction");
 
 // src/generated/instructions/reconcileStake.ts
 import {
-  combineCodec as combineCodec35,
-  fixDecoderSize as fixDecoderSize29,
-  fixEncoderSize as fixEncoderSize30,
+  combineCodec as combineCodec36,
+  fixDecoderSize as fixDecoderSize30,
+  fixEncoderSize as fixEncoderSize31,
   getArrayDecoder as getArrayDecoder7,
   getArrayEncoder as getArrayEncoder7,
-  getBytesDecoder as getBytesDecoder29,
-  getBytesEncoder as getBytesEncoder37,
-  getStructDecoder as getStructDecoder32,
-  getStructEncoder as getStructEncoder32,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS21,
-  SolanaError as SolanaError21,
-  transformEncoder as transformEncoder28
+  getBytesDecoder as getBytesDecoder30,
+  getBytesEncoder as getBytesEncoder38,
+  getStructDecoder as getStructDecoder33,
+  getStructEncoder as getStructEncoder33,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS22,
+  SolanaError as SolanaError22,
+  transformEncoder as transformEncoder29
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory21
+  getAccountMetaFactory as getAccountMetaFactory22
 } from "@solana/kit/program-client-core";
 var RECONCILE_STAKE_DISCRIMINATOR = new Uint8Array(
   [40, 103, 128, 85, 211, 11, 34, 80]
 );
 function getReconcileStakeInstructionDataEncoder() {
-  return transformEncoder28(
-    getStructEncoder32([
-      ["discriminator", fixEncoderSize30(getBytesEncoder37(), 8)],
+  return transformEncoder29(
+    getStructEncoder33([
+      ["discriminator", fixEncoderSize31(getBytesEncoder38(), 8)],
       ["path", getArrayEncoder7(getMSTNodeEncoder())]
     ]),
     (value) => ({ ...value, discriminator: RECONCILE_STAKE_DISCRIMINATOR })
@@ -4020,8 +4214,8 @@ function getReconcileStakeInstructionDataEncoder() {
 }
 __name(getReconcileStakeInstructionDataEncoder, "getReconcileStakeInstructionDataEncoder");
 function getReconcileStakeInstructionDataDecoder() {
-  return getStructDecoder32([
-    ["discriminator", fixDecoderSize29(getBytesDecoder29(), 8)],
+  return getStructDecoder33([
+    ["discriminator", fixDecoderSize30(getBytesDecoder30(), 8)],
     ["path", getArrayDecoder7(getMSTNodeDecoder())]
   ]);
 }
@@ -4035,7 +4229,7 @@ function getReconcileStakeInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory21(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory22(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -4051,8 +4245,8 @@ function getReconcileStakeInstruction(input, config) {
 __name(getReconcileStakeInstruction, "getReconcileStakeInstruction");
 function parseReconcileStakeInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new SolanaError21(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS21,
+    throw new SolanaError22(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS22,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 3
@@ -4079,22 +4273,22 @@ __name(parseReconcileStakeInstruction, "parseReconcileStakeInstruction");
 
 // src/generated/instructions/redraw.ts
 import {
-  combineCodec as combineCodec36,
-  fixDecoderSize as fixDecoderSize30,
-  fixEncoderSize as fixEncoderSize31,
-  getAddressEncoder as getAddressEncoder21,
-  getBytesDecoder as getBytesDecoder30,
-  getBytesEncoder as getBytesEncoder38,
-  getProgramDerivedAddress as getProgramDerivedAddress13,
-  getStructDecoder as getStructDecoder33,
-  getStructEncoder as getStructEncoder33,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS22,
-  SolanaError as SolanaError22,
-  transformEncoder as transformEncoder29
+  combineCodec as combineCodec37,
+  fixDecoderSize as fixDecoderSize31,
+  fixEncoderSize as fixEncoderSize32,
+  getAddressEncoder as getAddressEncoder22,
+  getBytesDecoder as getBytesDecoder31,
+  getBytesEncoder as getBytesEncoder39,
+  getProgramDerivedAddress as getProgramDerivedAddress14,
+  getStructDecoder as getStructDecoder34,
+  getStructEncoder as getStructEncoder34,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS23,
+  SolanaError as SolanaError23,
+  transformEncoder as transformEncoder30
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory22,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount8
+  getAccountMetaFactory as getAccountMetaFactory23,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount9
 } from "@solana/kit/program-client-core";
 var REDRAW_DISCRIMINATOR = new Uint8Array([
   86,
@@ -4107,15 +4301,15 @@ var REDRAW_DISCRIMINATOR = new Uint8Array([
   164
 ]);
 function getRedrawInstructionDataEncoder() {
-  return transformEncoder29(
-    getStructEncoder33([["discriminator", fixEncoderSize31(getBytesEncoder38(), 8)]]),
+  return transformEncoder30(
+    getStructEncoder34([["discriminator", fixEncoderSize32(getBytesEncoder39(), 8)]]),
     (value) => ({ ...value, discriminator: REDRAW_DISCRIMINATOR })
   );
 }
 __name(getRedrawInstructionDataEncoder, "getRedrawInstructionDataEncoder");
 function getRedrawInstructionDataDecoder() {
-  return getStructDecoder33([
-    ["discriminator", fixDecoderSize30(getBytesDecoder30(), 8)]
+  return getStructDecoder34([
+    ["discriminator", fixDecoderSize31(getBytesDecoder31(), 8)]
   ]);
 }
 __name(getRedrawInstructionDataDecoder, "getRedrawInstructionDataDecoder");
@@ -4136,16 +4330,16 @@ async function getRedrawInstructionAsync(input, config) {
   };
   const accounts = originalAccounts;
   if (!accounts.feeVault.value) {
-    accounts.feeVault.value = await getProgramDerivedAddress13({
+    accounts.feeVault.value = await getProgramDerivedAddress14({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder21().encode(
-          getAddressFromResolvedInstructionAccount8(
+        getAddressEncoder22().encode(
+          getAddressFromResolvedInstructionAccount9(
             "subaccord",
             accounts.subaccord.value
           )
         ),
-        getBytesEncoder38().encode(
+        getBytesEncoder39().encode(
           new Uint8Array([
             6,
             221,
@@ -4181,8 +4375,8 @@ async function getRedrawInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder21().encode(
-          getAddressFromResolvedInstructionAccount8(
+        getAddressEncoder22().encode(
+          getAddressFromResolvedInstructionAccount9(
             "feeToken",
             accounts.feeToken.value
           )
@@ -4193,7 +4387,7 @@ async function getRedrawInstructionAsync(input, config) {
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
-  const getAccountMeta = getAccountMetaFactory22(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory23(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -4229,7 +4423,7 @@ function getRedrawInstruction(input, config) {
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
-  const getAccountMeta = getAccountMetaFactory22(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory23(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -4248,8 +4442,8 @@ function getRedrawInstruction(input, config) {
 __name(getRedrawInstruction, "getRedrawInstruction");
 function parseRedrawInstruction(instruction) {
   if (instruction.accounts.length < 8) {
-    throw new SolanaError22(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS22,
+    throw new SolanaError23(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS23,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 8
@@ -4281,19 +4475,19 @@ __name(parseRedrawInstruction, "parseRedrawInstruction");
 
 // src/generated/instructions/requestVrf.ts
 import {
-  combineCodec as combineCodec37,
-  fixDecoderSize as fixDecoderSize31,
-  fixEncoderSize as fixEncoderSize32,
-  getBytesDecoder as getBytesDecoder31,
-  getBytesEncoder as getBytesEncoder39,
-  getStructDecoder as getStructDecoder34,
-  getStructEncoder as getStructEncoder34,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS23,
-  SolanaError as SolanaError23,
-  transformEncoder as transformEncoder30
+  combineCodec as combineCodec38,
+  fixDecoderSize as fixDecoderSize32,
+  fixEncoderSize as fixEncoderSize33,
+  getBytesDecoder as getBytesDecoder32,
+  getBytesEncoder as getBytesEncoder40,
+  getStructDecoder as getStructDecoder35,
+  getStructEncoder as getStructEncoder35,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS24,
+  SolanaError as SolanaError24,
+  transformEncoder as transformEncoder31
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory23
+  getAccountMetaFactory as getAccountMetaFactory24
 } from "@solana/kit/program-client-core";
 var REQUEST_VRF_DISCRIMINATOR = new Uint8Array([
   5,
@@ -4306,15 +4500,15 @@ var REQUEST_VRF_DISCRIMINATOR = new Uint8Array([
   226
 ]);
 function getRequestVrfInstructionDataEncoder() {
-  return transformEncoder30(
-    getStructEncoder34([["discriminator", fixEncoderSize32(getBytesEncoder39(), 8)]]),
+  return transformEncoder31(
+    getStructEncoder35([["discriminator", fixEncoderSize33(getBytesEncoder40(), 8)]]),
     (value) => ({ ...value, discriminator: REQUEST_VRF_DISCRIMINATOR })
   );
 }
 __name(getRequestVrfInstructionDataEncoder, "getRequestVrfInstructionDataEncoder");
 function getRequestVrfInstructionDataDecoder() {
-  return getStructDecoder34([
-    ["discriminator", fixDecoderSize31(getBytesDecoder31(), 8)]
+  return getStructDecoder35([
+    ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)]
   ]);
 }
 __name(getRequestVrfInstructionDataDecoder, "getRequestVrfInstructionDataDecoder");
@@ -4349,7 +4543,7 @@ async function getRequestVrfInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory23(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory24(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -4394,7 +4588,7 @@ function getRequestVrfInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory23(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory24(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -4413,8 +4607,8 @@ function getRequestVrfInstruction(input, config) {
 __name(getRequestVrfInstruction, "getRequestVrfInstruction");
 function parseRequestVrfInstruction(instruction) {
   if (instruction.accounts.length < 8) {
-    throw new SolanaError23(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS23,
+    throw new SolanaError24(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS24,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 8
@@ -4446,30 +4640,30 @@ __name(parseRequestVrfInstruction, "parseRequestVrfInstruction");
 
 // src/generated/instructions/requestWithdraw.ts
 import {
-  combineCodec as combineCodec38,
-  fixDecoderSize as fixDecoderSize32,
-  fixEncoderSize as fixEncoderSize33,
+  combineCodec as combineCodec39,
+  fixDecoderSize as fixDecoderSize33,
+  fixEncoderSize as fixEncoderSize34,
   getArrayDecoder as getArrayDecoder8,
   getArrayEncoder as getArrayEncoder8,
-  getBytesDecoder as getBytesDecoder32,
-  getBytesEncoder as getBytesEncoder40,
-  getStructDecoder as getStructDecoder35,
-  getStructEncoder as getStructEncoder35,
+  getBytesDecoder as getBytesDecoder33,
+  getBytesEncoder as getBytesEncoder41,
+  getStructDecoder as getStructDecoder36,
+  getStructEncoder as getStructEncoder36,
   getU64Decoder as getU64Decoder15,
   getU64Encoder as getU64Encoder17,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS24,
-  SolanaError as SolanaError24,
-  transformEncoder as transformEncoder31
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS25,
+  SolanaError as SolanaError25,
+  transformEncoder as transformEncoder32
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory24,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount9
+  getAccountMetaFactory as getAccountMetaFactory25,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount10
 } from "@solana/kit/program-client-core";
 var REQUEST_WITHDRAW_DISCRIMINATOR = new Uint8Array([137, 95, 187, 96, 250, 138, 31, 182]);
 function getRequestWithdrawInstructionDataEncoder() {
-  return transformEncoder31(
-    getStructEncoder35([
-      ["discriminator", fixEncoderSize33(getBytesEncoder40(), 8)],
+  return transformEncoder32(
+    getStructEncoder36([
+      ["discriminator", fixEncoderSize34(getBytesEncoder41(), 8)],
       ["amount", getU64Encoder17()],
       ["path", getArrayEncoder8(getMSTNodeEncoder())]
     ]),
@@ -4478,8 +4672,8 @@ function getRequestWithdrawInstructionDataEncoder() {
 }
 __name(getRequestWithdrawInstructionDataEncoder, "getRequestWithdrawInstructionDataEncoder");
 function getRequestWithdrawInstructionDataDecoder() {
-  return getStructDecoder35([
-    ["discriminator", fixDecoderSize32(getBytesDecoder32(), 8)],
+  return getStructDecoder36([
+    ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)],
     ["amount", getU64Decoder15()],
     ["path", getArrayDecoder8(getMSTNodeDecoder())]
   ]);
@@ -4496,17 +4690,17 @@ async function getRequestWithdrawInstructionAsync(input, config) {
   const args = { ...input };
   if (!accounts.jurorStake.value) {
     accounts.jurorStake.value = await findJurorStakePda({
-      subaccord: getAddressFromResolvedInstructionAccount9(
+      subaccord: getAddressFromResolvedInstructionAccount10(
         "subaccord",
         accounts.subaccord.value
       ),
-      juror: getAddressFromResolvedInstructionAccount9(
+      juror: getAddressFromResolvedInstructionAccount10(
         "juror",
         accounts.juror.value
       )
     });
   }
-  const getAccountMeta = getAccountMetaFactory24(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory25(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -4529,7 +4723,7 @@ function getRequestWithdrawInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory24(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory25(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -4545,8 +4739,8 @@ function getRequestWithdrawInstruction(input, config) {
 __name(getRequestWithdrawInstruction, "getRequestWithdrawInstruction");
 function parseRequestWithdrawInstruction(instruction) {
   if (instruction.accounts.length < 3) {
-    throw new SolanaError24(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS24,
+    throw new SolanaError25(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS25,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 3
@@ -4573,21 +4767,21 @@ __name(parseRequestWithdrawInstruction, "parseRequestWithdrawInstruction");
 
 // src/generated/instructions/reveal.ts
 import {
-  combineCodec as combineCodec39,
-  fixDecoderSize as fixDecoderSize33,
-  fixEncoderSize as fixEncoderSize34,
-  getBytesDecoder as getBytesDecoder33,
-  getBytesEncoder as getBytesEncoder41,
-  getStructDecoder as getStructDecoder36,
-  getStructEncoder as getStructEncoder36,
+  combineCodec as combineCodec40,
+  fixDecoderSize as fixDecoderSize34,
+  fixEncoderSize as fixEncoderSize35,
+  getBytesDecoder as getBytesDecoder34,
+  getBytesEncoder as getBytesEncoder42,
+  getStructDecoder as getStructDecoder37,
+  getStructEncoder as getStructEncoder37,
   getU64Decoder as getU64Decoder16,
   getU64Encoder as getU64Encoder18,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS25,
-  SolanaError as SolanaError25,
-  transformEncoder as transformEncoder32
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS26,
+  SolanaError as SolanaError26,
+  transformEncoder as transformEncoder33
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory25
+  getAccountMetaFactory as getAccountMetaFactory26
 } from "@solana/kit/program-client-core";
 var REVEAL_DISCRIMINATOR = new Uint8Array([
   9,
@@ -4600,21 +4794,21 @@ var REVEAL_DISCRIMINATOR = new Uint8Array([
   115
 ]);
 function getRevealInstructionDataEncoder() {
-  return transformEncoder32(
-    getStructEncoder36([
-      ["discriminator", fixEncoderSize34(getBytesEncoder41(), 8)],
+  return transformEncoder33(
+    getStructEncoder37([
+      ["discriminator", fixEncoderSize35(getBytesEncoder42(), 8)],
       ["vote", getU64Encoder18()],
-      ["salt", fixEncoderSize34(getBytesEncoder41(), 32)]
+      ["salt", fixEncoderSize35(getBytesEncoder42(), 32)]
     ]),
     (value) => ({ ...value, discriminator: REVEAL_DISCRIMINATOR })
   );
 }
 __name(getRevealInstructionDataEncoder, "getRevealInstructionDataEncoder");
 function getRevealInstructionDataDecoder() {
-  return getStructDecoder36([
-    ["discriminator", fixDecoderSize33(getBytesDecoder33(), 8)],
+  return getStructDecoder37([
+    ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)],
     ["vote", getU64Decoder16()],
-    ["salt", fixDecoderSize33(getBytesDecoder33(), 32)]
+    ["salt", fixDecoderSize34(getBytesDecoder34(), 32)]
   ]);
 }
 __name(getRevealInstructionDataDecoder, "getRevealInstructionDataDecoder");
@@ -4628,7 +4822,7 @@ function getRevealInstruction(input, config) {
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory25(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory26(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -4645,8 +4839,8 @@ function getRevealInstruction(input, config) {
 __name(getRevealInstruction, "getRevealInstruction");
 function parseRevealInstruction(instruction) {
   if (instruction.accounts.length < 4) {
-    throw new SolanaError25(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS25,
+    throw new SolanaError26(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS26,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 4
@@ -4674,22 +4868,22 @@ __name(parseRevealInstruction, "parseRevealInstruction");
 
 // src/generated/instructions/settleRound.ts
 import {
-  combineCodec as combineCodec40,
-  fixDecoderSize as fixDecoderSize34,
-  fixEncoderSize as fixEncoderSize35,
-  getBytesDecoder as getBytesDecoder34,
-  getBytesEncoder as getBytesEncoder42,
-  getStructDecoder as getStructDecoder37,
-  getStructEncoder as getStructEncoder37,
+  combineCodec as combineCodec41,
+  fixDecoderSize as fixDecoderSize35,
+  fixEncoderSize as fixEncoderSize36,
+  getBytesDecoder as getBytesDecoder35,
+  getBytesEncoder as getBytesEncoder43,
+  getStructDecoder as getStructDecoder38,
+  getStructEncoder as getStructEncoder38,
   getU32Decoder as getU32Decoder10,
   getU32Encoder as getU32Encoder12,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS26,
-  SolanaError as SolanaError26,
-  transformEncoder as transformEncoder33
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS27,
+  SolanaError as SolanaError27,
+  transformEncoder as transformEncoder34
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory26,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount10,
+  getAccountMetaFactory as getAccountMetaFactory27,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount11,
   getNonNullResolvedInstructionInput as getNonNullResolvedInstructionInput5
 } from "@solana/kit/program-client-core";
 var SETTLE_ROUND_DISCRIMINATOR = new Uint8Array([
@@ -4703,9 +4897,9 @@ var SETTLE_ROUND_DISCRIMINATOR = new Uint8Array([
   77
 ]);
 function getSettleRoundInstructionDataEncoder() {
-  return transformEncoder33(
-    getStructEncoder37([
-      ["discriminator", fixEncoderSize35(getBytesEncoder42(), 8)],
+  return transformEncoder34(
+    getStructEncoder38([
+      ["discriminator", fixEncoderSize36(getBytesEncoder43(), 8)],
       ["roundIdx", getU32Encoder12()]
     ]),
     (value) => ({ ...value, discriminator: SETTLE_ROUND_DISCRIMINATOR })
@@ -4713,8 +4907,8 @@ function getSettleRoundInstructionDataEncoder() {
 }
 __name(getSettleRoundInstructionDataEncoder, "getSettleRoundInstructionDataEncoder");
 function getSettleRoundInstructionDataDecoder() {
-  return getStructDecoder37([
-    ["discriminator", fixDecoderSize34(getBytesDecoder34(), 8)],
+  return getStructDecoder38([
+    ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)],
     ["roundIdx", getU32Decoder10()]
   ]);
 }
@@ -4724,21 +4918,21 @@ async function getSettleRoundInstructionAsync(input, config) {
   const originalAccounts = {
     caller: { value: input.caller ?? null, isWritable: true },
     subaccord: { value: input.subaccord ?? null, isWritable: false },
-    dispute: { value: input.dispute ?? null, isWritable: false },
+    dispute: { value: input.dispute ?? null, isWritable: true },
     round: { value: input.round ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.round.value) {
     accounts.round.value = await findRoundPda({
-      dispute: getAddressFromResolvedInstructionAccount10(
+      dispute: getAddressFromResolvedInstructionAccount11(
         "dispute",
         accounts.dispute.value
       ),
       roundIdx: getNonNullResolvedInstructionInput5("roundIdx", args.roundIdx)
     });
   }
-  const getAccountMeta = getAccountMetaFactory26(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory27(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -4758,12 +4952,12 @@ function getSettleRoundInstruction(input, config) {
   const originalAccounts = {
     caller: { value: input.caller ?? null, isWritable: true },
     subaccord: { value: input.subaccord ?? null, isWritable: false },
-    dispute: { value: input.dispute ?? null, isWritable: false },
+    dispute: { value: input.dispute ?? null, isWritable: true },
     round: { value: input.round ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
   const args = { ...input };
-  const getAccountMeta = getAccountMetaFactory26(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory27(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("caller", accounts.caller),
@@ -4780,8 +4974,8 @@ function getSettleRoundInstruction(input, config) {
 __name(getSettleRoundInstruction, "getSettleRoundInstruction");
 function parseSettleRoundInstruction(instruction) {
   if (instruction.accounts.length < 4) {
-    throw new SolanaError26(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS26,
+    throw new SolanaError27(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS27,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 4
@@ -4809,26 +5003,26 @@ __name(parseSettleRoundInstruction, "parseSettleRoundInstruction");
 
 // src/generated/instructions/stake.ts
 import {
-  combineCodec as combineCodec41,
-  fixDecoderSize as fixDecoderSize35,
-  fixEncoderSize as fixEncoderSize36,
-  getAddressEncoder as getAddressEncoder22,
+  combineCodec as combineCodec42,
+  fixDecoderSize as fixDecoderSize36,
+  fixEncoderSize as fixEncoderSize37,
+  getAddressEncoder as getAddressEncoder23,
   getArrayDecoder as getArrayDecoder9,
   getArrayEncoder as getArrayEncoder9,
-  getBytesDecoder as getBytesDecoder35,
-  getBytesEncoder as getBytesEncoder43,
-  getProgramDerivedAddress as getProgramDerivedAddress14,
-  getStructDecoder as getStructDecoder38,
-  getStructEncoder as getStructEncoder38,
+  getBytesDecoder as getBytesDecoder36,
+  getBytesEncoder as getBytesEncoder44,
+  getProgramDerivedAddress as getProgramDerivedAddress15,
+  getStructDecoder as getStructDecoder39,
+  getStructEncoder as getStructEncoder39,
   getU64Decoder as getU64Decoder17,
   getU64Encoder as getU64Encoder19,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS27,
-  SolanaError as SolanaError27,
-  transformEncoder as transformEncoder34
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS28,
+  SolanaError as SolanaError28,
+  transformEncoder as transformEncoder35
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory27,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount11
+  getAccountMetaFactory as getAccountMetaFactory28,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount12
 } from "@solana/kit/program-client-core";
 var STAKE_DISCRIMINATOR = new Uint8Array([
   206,
@@ -4841,9 +5035,9 @@ var STAKE_DISCRIMINATOR = new Uint8Array([
   108
 ]);
 function getStakeInstructionDataEncoder() {
-  return transformEncoder34(
-    getStructEncoder38([
-      ["discriminator", fixEncoderSize36(getBytesEncoder43(), 8)],
+  return transformEncoder35(
+    getStructEncoder39([
+      ["discriminator", fixEncoderSize37(getBytesEncoder44(), 8)],
       ["amount", getU64Encoder19()],
       ["path", getArrayEncoder9(getMSTNodeEncoder())]
     ]),
@@ -4852,8 +5046,8 @@ function getStakeInstructionDataEncoder() {
 }
 __name(getStakeInstructionDataEncoder, "getStakeInstructionDataEncoder");
 function getStakeInstructionDataDecoder() {
-  return getStructDecoder38([
-    ["discriminator", fixDecoderSize35(getBytesDecoder35(), 8)],
+  return getStructDecoder39([
+    ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)],
     ["amount", getU64Decoder17()],
     ["path", getArrayDecoder9(getMSTNodeDecoder())]
   ]);
@@ -4886,27 +5080,27 @@ async function getStakeInstructionAsync(input, config) {
   }
   if (!accounts.jurorStake.value) {
     accounts.jurorStake.value = await findJurorStakePda({
-      subaccord: getAddressFromResolvedInstructionAccount11(
+      subaccord: getAddressFromResolvedInstructionAccount12(
         "subaccord",
         accounts.subaccord.value
       ),
-      juror: getAddressFromResolvedInstructionAccount11(
+      juror: getAddressFromResolvedInstructionAccount12(
         "juror",
         accounts.juror.value
       )
     });
   }
   if (!accounts.jurorTokenAccount.value) {
-    accounts.jurorTokenAccount.value = await getProgramDerivedAddress14({
+    accounts.jurorTokenAccount.value = await getProgramDerivedAddress15({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder22().encode(
-          getAddressFromResolvedInstructionAccount11(
+        getAddressEncoder23().encode(
+          getAddressFromResolvedInstructionAccount12(
             "juror",
             accounts.juror.value
           )
         ),
-        getBytesEncoder43().encode(
+        getBytesEncoder44().encode(
           new Uint8Array([
             6,
             221,
@@ -4942,8 +5136,8 @@ async function getStakeInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder22().encode(
-          getAddressFromResolvedInstructionAccount11(
+        getAddressEncoder23().encode(
+          getAddressFromResolvedInstructionAccount12(
             "stakingToken",
             accounts.stakingToken.value
           )
@@ -4952,16 +5146,16 @@ async function getStakeInstructionAsync(input, config) {
     });
   }
   if (!accounts.stakeVault.value) {
-    accounts.stakeVault.value = await getProgramDerivedAddress14({
+    accounts.stakeVault.value = await getProgramDerivedAddress15({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder22().encode(
-          getAddressFromResolvedInstructionAccount11(
+        getAddressEncoder23().encode(
+          getAddressFromResolvedInstructionAccount12(
             "subaccord",
             accounts.subaccord.value
           )
         ),
-        getBytesEncoder43().encode(
+        getBytesEncoder44().encode(
           new Uint8Array([
             6,
             221,
@@ -4997,8 +5191,8 @@ async function getStakeInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder22().encode(
-          getAddressFromResolvedInstructionAccount11(
+        getAddressEncoder23().encode(
+          getAddressFromResolvedInstructionAccount12(
             "stakingToken",
             accounts.stakingToken.value
           )
@@ -5015,7 +5209,7 @@ async function getStakeInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory27(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory28(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -5067,7 +5261,7 @@ function getStakeInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory27(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory28(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -5090,8 +5284,8 @@ function getStakeInstruction(input, config) {
 __name(getStakeInstruction, "getStakeInstruction");
 function parseStakeInstruction(instruction) {
   if (instruction.accounts.length < 10) {
-    throw new SolanaError27(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS27,
+    throw new SolanaError28(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS28,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 10
@@ -5125,22 +5319,22 @@ __name(parseStakeInstruction, "parseStakeInstruction");
 
 // src/generated/instructions/withdraw.ts
 import {
-  combineCodec as combineCodec42,
-  fixDecoderSize as fixDecoderSize36,
-  fixEncoderSize as fixEncoderSize37,
-  getAddressEncoder as getAddressEncoder23,
-  getBytesDecoder as getBytesDecoder36,
-  getBytesEncoder as getBytesEncoder44,
-  getProgramDerivedAddress as getProgramDerivedAddress15,
-  getStructDecoder as getStructDecoder39,
-  getStructEncoder as getStructEncoder39,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS28,
-  SolanaError as SolanaError28,
-  transformEncoder as transformEncoder35
+  combineCodec as combineCodec43,
+  fixDecoderSize as fixDecoderSize37,
+  fixEncoderSize as fixEncoderSize38,
+  getAddressEncoder as getAddressEncoder24,
+  getBytesDecoder as getBytesDecoder37,
+  getBytesEncoder as getBytesEncoder45,
+  getProgramDerivedAddress as getProgramDerivedAddress16,
+  getStructDecoder as getStructDecoder40,
+  getStructEncoder as getStructEncoder40,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS29,
+  SolanaError as SolanaError29,
+  transformEncoder as transformEncoder36
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory28,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount12
+  getAccountMetaFactory as getAccountMetaFactory29,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount13
 } from "@solana/kit/program-client-core";
 var WITHDRAW_DISCRIMINATOR = new Uint8Array([
   183,
@@ -5153,15 +5347,15 @@ var WITHDRAW_DISCRIMINATOR = new Uint8Array([
   34
 ]);
 function getWithdrawInstructionDataEncoder() {
-  return transformEncoder35(
-    getStructEncoder39([["discriminator", fixEncoderSize37(getBytesEncoder44(), 8)]]),
+  return transformEncoder36(
+    getStructEncoder40([["discriminator", fixEncoderSize38(getBytesEncoder45(), 8)]]),
     (value) => ({ ...value, discriminator: WITHDRAW_DISCRIMINATOR })
   );
 }
 __name(getWithdrawInstructionDataEncoder, "getWithdrawInstructionDataEncoder");
 function getWithdrawInstructionDataDecoder() {
-  return getStructDecoder39([
-    ["discriminator", fixDecoderSize36(getBytesDecoder36(), 8)]
+  return getStructDecoder40([
+    ["discriminator", fixDecoderSize37(getBytesDecoder37(), 8)]
   ]);
 }
 __name(getWithdrawInstructionDataDecoder, "getWithdrawInstructionDataDecoder");
@@ -5182,27 +5376,27 @@ async function getWithdrawInstructionAsync(input, config) {
   const accounts = originalAccounts;
   if (!accounts.jurorStake.value) {
     accounts.jurorStake.value = await findJurorStakePda({
-      subaccord: getAddressFromResolvedInstructionAccount12(
+      subaccord: getAddressFromResolvedInstructionAccount13(
         "subaccord",
         accounts.subaccord.value
       ),
-      juror: getAddressFromResolvedInstructionAccount12(
+      juror: getAddressFromResolvedInstructionAccount13(
         "juror",
         accounts.juror.value
       )
     });
   }
   if (!accounts.jurorTokenAccount.value) {
-    accounts.jurorTokenAccount.value = await getProgramDerivedAddress15({
+    accounts.jurorTokenAccount.value = await getProgramDerivedAddress16({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder23().encode(
-          getAddressFromResolvedInstructionAccount12(
+        getAddressEncoder24().encode(
+          getAddressFromResolvedInstructionAccount13(
             "juror",
             accounts.juror.value
           )
         ),
-        getBytesEncoder44().encode(
+        getBytesEncoder45().encode(
           new Uint8Array([
             6,
             221,
@@ -5238,8 +5432,8 @@ async function getWithdrawInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder23().encode(
-          getAddressFromResolvedInstructionAccount12(
+        getAddressEncoder24().encode(
+          getAddressFromResolvedInstructionAccount13(
             "stakingToken",
             accounts.stakingToken.value
           )
@@ -5248,16 +5442,16 @@ async function getWithdrawInstructionAsync(input, config) {
     });
   }
   if (!accounts.stakeVault.value) {
-    accounts.stakeVault.value = await getProgramDerivedAddress15({
+    accounts.stakeVault.value = await getProgramDerivedAddress16({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder23().encode(
-          getAddressFromResolvedInstructionAccount12(
+        getAddressEncoder24().encode(
+          getAddressFromResolvedInstructionAccount13(
             "subaccord",
             accounts.subaccord.value
           )
         ),
-        getBytesEncoder44().encode(
+        getBytesEncoder45().encode(
           new Uint8Array([
             6,
             221,
@@ -5293,8 +5487,8 @@ async function getWithdrawInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder23().encode(
-          getAddressFromResolvedInstructionAccount12(
+        getAddressEncoder24().encode(
+          getAddressFromResolvedInstructionAccount13(
             "stakingToken",
             accounts.stakingToken.value
           )
@@ -5305,7 +5499,7 @@ async function getWithdrawInstructionAsync(input, config) {
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
-  const getAccountMeta = getAccountMetaFactory28(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory29(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -5339,7 +5533,7 @@ function getWithdrawInstruction(input, config) {
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
-  const getAccountMeta = getAccountMetaFactory28(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory29(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -5357,8 +5551,8 @@ function getWithdrawInstruction(input, config) {
 __name(getWithdrawInstruction, "getWithdrawInstruction");
 function parseWithdrawInstruction(instruction) {
   if (instruction.accounts.length < 7) {
-    throw new SolanaError28(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS28,
+    throw new SolanaError29(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS29,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 7
@@ -5389,22 +5583,22 @@ __name(parseWithdrawInstruction, "parseWithdrawInstruction");
 
 // src/generated/instructions/withdrawFees.ts
 import {
-  combineCodec as combineCodec43,
-  fixDecoderSize as fixDecoderSize37,
-  fixEncoderSize as fixEncoderSize38,
-  getAddressEncoder as getAddressEncoder24,
-  getBytesDecoder as getBytesDecoder37,
-  getBytesEncoder as getBytesEncoder45,
-  getProgramDerivedAddress as getProgramDerivedAddress16,
-  getStructDecoder as getStructDecoder40,
-  getStructEncoder as getStructEncoder40,
-  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS29,
-  SolanaError as SolanaError29,
-  transformEncoder as transformEncoder36
+  combineCodec as combineCodec44,
+  fixDecoderSize as fixDecoderSize38,
+  fixEncoderSize as fixEncoderSize39,
+  getAddressEncoder as getAddressEncoder25,
+  getBytesDecoder as getBytesDecoder38,
+  getBytesEncoder as getBytesEncoder46,
+  getProgramDerivedAddress as getProgramDerivedAddress17,
+  getStructDecoder as getStructDecoder41,
+  getStructEncoder as getStructEncoder41,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS30,
+  SolanaError as SolanaError30,
+  transformEncoder as transformEncoder37
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory29,
-  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount13
+  getAccountMetaFactory as getAccountMetaFactory30,
+  getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount14
 } from "@solana/kit/program-client-core";
 var WITHDRAW_FEES_DISCRIMINATOR = new Uint8Array([
   198,
@@ -5417,15 +5611,15 @@ var WITHDRAW_FEES_DISCRIMINATOR = new Uint8Array([
   89
 ]);
 function getWithdrawFeesInstructionDataEncoder() {
-  return transformEncoder36(
-    getStructEncoder40([["discriminator", fixEncoderSize38(getBytesEncoder45(), 8)]]),
+  return transformEncoder37(
+    getStructEncoder41([["discriminator", fixEncoderSize39(getBytesEncoder46(), 8)]]),
     (value) => ({ ...value, discriminator: WITHDRAW_FEES_DISCRIMINATOR })
   );
 }
 __name(getWithdrawFeesInstructionDataEncoder, "getWithdrawFeesInstructionDataEncoder");
 function getWithdrawFeesInstructionDataDecoder() {
-  return getStructDecoder40([
-    ["discriminator", fixDecoderSize37(getBytesDecoder37(), 8)]
+  return getStructDecoder41([
+    ["discriminator", fixDecoderSize38(getBytesDecoder38(), 8)]
   ]);
 }
 __name(getWithdrawFeesInstructionDataDecoder, "getWithdrawFeesInstructionDataDecoder");
@@ -5446,27 +5640,27 @@ async function getWithdrawFeesInstructionAsync(input, config) {
   const accounts = originalAccounts;
   if (!accounts.jurorStake.value) {
     accounts.jurorStake.value = await findJurorStakePda({
-      subaccord: getAddressFromResolvedInstructionAccount13(
+      subaccord: getAddressFromResolvedInstructionAccount14(
         "subaccord",
         accounts.subaccord.value
       ),
-      juror: getAddressFromResolvedInstructionAccount13(
+      juror: getAddressFromResolvedInstructionAccount14(
         "juror",
         accounts.juror.value
       )
     });
   }
   if (!accounts.jurorFeeTokenAccount.value) {
-    accounts.jurorFeeTokenAccount.value = await getProgramDerivedAddress16({
+    accounts.jurorFeeTokenAccount.value = await getProgramDerivedAddress17({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder24().encode(
-          getAddressFromResolvedInstructionAccount13(
+        getAddressEncoder25().encode(
+          getAddressFromResolvedInstructionAccount14(
             "juror",
             accounts.juror.value
           )
         ),
-        getBytesEncoder45().encode(
+        getBytesEncoder46().encode(
           new Uint8Array([
             6,
             221,
@@ -5502,8 +5696,8 @@ async function getWithdrawFeesInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder24().encode(
-          getAddressFromResolvedInstructionAccount13(
+        getAddressEncoder25().encode(
+          getAddressFromResolvedInstructionAccount14(
             "feeToken",
             accounts.feeToken.value
           )
@@ -5512,16 +5706,16 @@ async function getWithdrawFeesInstructionAsync(input, config) {
     });
   }
   if (!accounts.feeVault.value) {
-    accounts.feeVault.value = await getProgramDerivedAddress16({
+    accounts.feeVault.value = await getProgramDerivedAddress17({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder24().encode(
-          getAddressFromResolvedInstructionAccount13(
+        getAddressEncoder25().encode(
+          getAddressFromResolvedInstructionAccount14(
             "subaccord",
             accounts.subaccord.value
           )
         ),
-        getBytesEncoder45().encode(
+        getBytesEncoder46().encode(
           new Uint8Array([
             6,
             221,
@@ -5557,8 +5751,8 @@ async function getWithdrawFeesInstructionAsync(input, config) {
             169
           ])
         ),
-        getAddressEncoder24().encode(
-          getAddressFromResolvedInstructionAccount13(
+        getAddressEncoder25().encode(
+          getAddressFromResolvedInstructionAccount14(
             "feeToken",
             accounts.feeToken.value
           )
@@ -5569,7 +5763,7 @@ async function getWithdrawFeesInstructionAsync(input, config) {
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
-  const getAccountMeta = getAccountMetaFactory29(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory30(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -5603,7 +5797,7 @@ function getWithdrawFeesInstruction(input, config) {
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
-  const getAccountMeta = getAccountMetaFactory29(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory30(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("juror", accounts.juror),
@@ -5621,8 +5815,8 @@ function getWithdrawFeesInstruction(input, config) {
 __name(getWithdrawFeesInstruction, "getWithdrawFeesInstruction");
 function parseWithdrawFeesInstruction(instruction) {
   if (instruction.accounts.length < 7) {
-    throw new SolanaError29(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS29,
+    throw new SolanaError30(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS30,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 7
@@ -5657,7 +5851,7 @@ function identifyAccordAccount(account) {
   const data = "data" in account ? account.data : account;
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([218, 6, 196, 225, 25, 89, 50, 183])
     ),
     0
@@ -5666,7 +5860,7 @@ function identifyAccordAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([84, 79, 238, 7, 49, 113, 35, 143])
     ),
     0
@@ -5675,7 +5869,7 @@ function identifyAccordAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([36, 49, 241, 67, 40, 36, 241, 74])
     ),
     0
@@ -5684,7 +5878,7 @@ function identifyAccordAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([139, 114, 205, 73, 247, 175, 133, 122])
     ),
     0
@@ -5693,7 +5887,7 @@ function identifyAccordAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([24, 212, 61, 73, 130, 111, 15, 112])
     ),
     0
@@ -5702,7 +5896,7 @@ function identifyAccordAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([87, 127, 165, 51, 73, 78, 116, 174])
     ),
     0
@@ -5711,14 +5905,14 @@ function identifyAccordAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([210, 63, 193, 190, 9, 166, 89, 170])
     ),
     0
   )) {
     return 6 /* Subaccord */;
   }
-  throw new SolanaError30(
+  throw new SolanaError31(
     SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
     { accountData: data, programName: "accord" }
   );
@@ -5728,7 +5922,7 @@ function identifyAccordInstruction(instruction) {
   const data = "data" in instruction ? instruction.data : instruction;
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([250, 91, 1, 244, 179, 52, 75, 236])
     ),
     0
@@ -5737,7 +5931,7 @@ function identifyAccordInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([23, 155, 220, 94, 76, 141, 231, 124])
     ),
     0
@@ -5746,7 +5940,7 @@ function identifyAccordInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([210, 169, 229, 146, 187, 30, 61, 176])
     ),
     0
@@ -5755,239 +5949,248 @@ function identifyAccordInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
+      new Uint8Array([0, 179, 28, 122, 171, 246, 12, 132])
+    ),
+    0
+  )) {
+    return 3 /* ClaimFilingBounty */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([223, 140, 142, 165, 229, 208, 156, 74])
     ),
     0
   )) {
-    return 3 /* Commit */;
+    return 4 /* Commit */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([51, 127, 131, 85, 83, 117, 121, 59])
     ),
     0
   )) {
-    return 4 /* CommitVrfCallback */;
+    return 5 /* CommitVrfCallback */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([161, 99, 53, 116, 60, 79, 149, 105])
     ),
     0
   )) {
-    return 5 /* CreateDispute */;
+    return 6 /* CreateDispute */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([135, 240, 91, 50, 192, 161, 177, 22])
     ),
     0
   )) {
-    return 6 /* CreateSubaccord */;
+    return 7 /* CreateSubaccord */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([52, 26, 56, 16, 128, 4, 149, 236])
     ),
     0
   )) {
-    return 7 /* DrawSeat */;
+    return 8 /* DrawSeat */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([145, 99, 105, 27, 63, 159, 254, 203])
     ),
     0
   )) {
-    return 8 /* ExecuteSubaccordUpdate */;
+    return 9 /* ExecuteSubaccordUpdate */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([55, 43, 56, 5, 154, 156, 52, 232])
     ),
     0
   )) {
-    return 9 /* ExecuteUnpause */;
+    return 10 /* ExecuteUnpause */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([190, 211, 17, 122, 247, 157, 27, 223])
     ),
     0
   )) {
-    return 10 /* FinalizeDispute */;
+    return 11 /* FinalizeDispute */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([239, 160, 254, 11, 254, 144, 53, 148])
     ),
     0
   )) {
-    return 11 /* FinalizeRound */;
+    return 12 /* FinalizeRound */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([196, 52, 54, 1, 180, 75, 86, 16])
     ),
     0
   )) {
-    return 12 /* GetRuling */;
+    return 13 /* GetRuling */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([235, 42, 47, 99, 10, 7, 249, 16])
     ),
     0
   )) {
-    return 13 /* Health */;
+    return 14 /* Health */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([70, 32, 55, 248, 231, 46, 123, 153])
     ),
     0
   )) {
-    return 14 /* InitializePause */;
+    return 15 /* InitializePause */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([211, 22, 221, 251, 74, 121, 193, 47])
     ),
     0
   )) {
-    return 15 /* Pause */;
+    return 16 /* Pause */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([8, 224, 186, 131, 130, 76, 165, 172])
     ),
     0
   )) {
-    return 16 /* ProposeSubaccordUpdate */;
+    return 17 /* ProposeSubaccordUpdate */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([45, 136, 163, 143, 156, 57, 113, 132])
     ),
     0
   )) {
-    return 17 /* ProposeUnpause */;
+    return 18 /* ProposeUnpause */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([49, 219, 100, 132, 202, 120, 18, 167])
     ),
     0
   )) {
-    return 18 /* PruneJuror */;
+    return 19 /* PruneJuror */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([44, 216, 234, 229, 129, 82, 98, 5])
     ),
     0
   )) {
-    return 19 /* ReclaimSlot */;
+    return 20 /* ReclaimSlot */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([40, 103, 128, 85, 211, 11, 34, 80])
     ),
     0
   )) {
-    return 20 /* ReconcileStake */;
+    return 21 /* ReconcileStake */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([86, 111, 66, 164, 105, 158, 114, 164])
     ),
     0
   )) {
-    return 21 /* Redraw */;
+    return 22 /* Redraw */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([5, 87, 79, 152, 164, 176, 190, 226])
     ),
     0
   )) {
-    return 22 /* RequestVrf */;
+    return 23 /* RequestVrf */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([137, 95, 187, 96, 250, 138, 31, 182])
     ),
     0
   )) {
-    return 23 /* RequestWithdraw */;
+    return 24 /* RequestWithdraw */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([9, 35, 59, 190, 167, 249, 76, 115])
     ),
     0
   )) {
-    return 24 /* Reveal */;
+    return 25 /* Reveal */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([40, 101, 18, 1, 31, 129, 52, 77])
     ),
     0
   )) {
-    return 25 /* SettleRound */;
+    return 26 /* SettleRound */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([206, 176, 202, 18, 200, 209, 179, 108])
     ),
     0
   )) {
-    return 26 /* Stake */;
+    return 27 /* Stake */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([183, 18, 70, 156, 148, 109, 161, 34])
     ),
     0
   )) {
-    return 27 /* Withdraw */;
+    return 28 /* Withdraw */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize39(getBytesEncoder46(), 8).encode(
+    fixEncoderSize40(getBytesEncoder47(), 8).encode(
       new Uint8Array([198, 212, 171, 109, 144, 215, 174, 89])
     ),
     0
   )) {
-    return 28 /* WithdrawFees */;
+    return 29 /* WithdrawFees */;
   }
-  throw new SolanaError30(
+  throw new SolanaError31(
     SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
     { instructionData: data, programName: "accord" }
   );
@@ -6017,190 +6220,197 @@ function parseAccordInstruction(instruction) {
         ...parseClaimAppealRefundInstruction(instruction)
       };
     }
-    case 3 /* Commit */: {
+    case 3 /* ClaimFilingBounty */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 3 /* ClaimFilingBounty */,
+        ...parseClaimFilingBountyInstruction(instruction)
+      };
+    }
+    case 4 /* Commit */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 3 /* Commit */,
+        instructionType: 4 /* Commit */,
         ...parseCommitInstruction(instruction)
       };
     }
-    case 4 /* CommitVrfCallback */: {
+    case 5 /* CommitVrfCallback */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 4 /* CommitVrfCallback */,
+        instructionType: 5 /* CommitVrfCallback */,
         ...parseCommitVrfCallbackInstruction(instruction)
       };
     }
-    case 5 /* CreateDispute */: {
+    case 6 /* CreateDispute */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 5 /* CreateDispute */,
+        instructionType: 6 /* CreateDispute */,
         ...parseCreateDisputeInstruction(instruction)
       };
     }
-    case 6 /* CreateSubaccord */: {
+    case 7 /* CreateSubaccord */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 6 /* CreateSubaccord */,
+        instructionType: 7 /* CreateSubaccord */,
         ...parseCreateSubaccordInstruction(instruction)
       };
     }
-    case 7 /* DrawSeat */: {
+    case 8 /* DrawSeat */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 7 /* DrawSeat */,
+        instructionType: 8 /* DrawSeat */,
         ...parseDrawSeatInstruction(instruction)
       };
     }
-    case 8 /* ExecuteSubaccordUpdate */: {
+    case 9 /* ExecuteSubaccordUpdate */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 8 /* ExecuteSubaccordUpdate */,
+        instructionType: 9 /* ExecuteSubaccordUpdate */,
         ...parseExecuteSubaccordUpdateInstruction(instruction)
       };
     }
-    case 9 /* ExecuteUnpause */: {
+    case 10 /* ExecuteUnpause */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 9 /* ExecuteUnpause */,
+        instructionType: 10 /* ExecuteUnpause */,
         ...parseExecuteUnpauseInstruction(instruction)
       };
     }
-    case 10 /* FinalizeDispute */: {
+    case 11 /* FinalizeDispute */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 10 /* FinalizeDispute */,
+        instructionType: 11 /* FinalizeDispute */,
         ...parseFinalizeDisputeInstruction(instruction)
       };
     }
-    case 11 /* FinalizeRound */: {
+    case 12 /* FinalizeRound */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 11 /* FinalizeRound */,
+        instructionType: 12 /* FinalizeRound */,
         ...parseFinalizeRoundInstruction(instruction)
       };
     }
-    case 12 /* GetRuling */: {
+    case 13 /* GetRuling */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 12 /* GetRuling */,
+        instructionType: 13 /* GetRuling */,
         ...parseGetRulingInstruction(instruction)
       };
     }
-    case 13 /* Health */: {
+    case 14 /* Health */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 13 /* Health */,
+        instructionType: 14 /* Health */,
         ...parseHealthInstruction(instruction)
       };
     }
-    case 14 /* InitializePause */: {
+    case 15 /* InitializePause */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 14 /* InitializePause */,
+        instructionType: 15 /* InitializePause */,
         ...parseInitializePauseInstruction(instruction)
       };
     }
-    case 15 /* Pause */: {
+    case 16 /* Pause */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 15 /* Pause */,
+        instructionType: 16 /* Pause */,
         ...parsePauseInstruction(instruction)
       };
     }
-    case 16 /* ProposeSubaccordUpdate */: {
+    case 17 /* ProposeSubaccordUpdate */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 16 /* ProposeSubaccordUpdate */,
+        instructionType: 17 /* ProposeSubaccordUpdate */,
         ...parseProposeSubaccordUpdateInstruction(instruction)
       };
     }
-    case 17 /* ProposeUnpause */: {
+    case 18 /* ProposeUnpause */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 17 /* ProposeUnpause */,
+        instructionType: 18 /* ProposeUnpause */,
         ...parseProposeUnpauseInstruction(instruction)
       };
     }
-    case 18 /* PruneJuror */: {
+    case 19 /* PruneJuror */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 18 /* PruneJuror */,
+        instructionType: 19 /* PruneJuror */,
         ...parsePruneJurorInstruction(instruction)
       };
     }
-    case 19 /* ReclaimSlot */: {
+    case 20 /* ReclaimSlot */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 19 /* ReclaimSlot */,
+        instructionType: 20 /* ReclaimSlot */,
         ...parseReclaimSlotInstruction(instruction)
       };
     }
-    case 20 /* ReconcileStake */: {
+    case 21 /* ReconcileStake */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 20 /* ReconcileStake */,
+        instructionType: 21 /* ReconcileStake */,
         ...parseReconcileStakeInstruction(instruction)
       };
     }
-    case 21 /* Redraw */: {
+    case 22 /* Redraw */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 21 /* Redraw */,
+        instructionType: 22 /* Redraw */,
         ...parseRedrawInstruction(instruction)
       };
     }
-    case 22 /* RequestVrf */: {
+    case 23 /* RequestVrf */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 22 /* RequestVrf */,
+        instructionType: 23 /* RequestVrf */,
         ...parseRequestVrfInstruction(instruction)
       };
     }
-    case 23 /* RequestWithdraw */: {
+    case 24 /* RequestWithdraw */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 23 /* RequestWithdraw */,
+        instructionType: 24 /* RequestWithdraw */,
         ...parseRequestWithdrawInstruction(instruction)
       };
     }
-    case 24 /* Reveal */: {
+    case 25 /* Reveal */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 24 /* Reveal */,
+        instructionType: 25 /* Reveal */,
         ...parseRevealInstruction(instruction)
       };
     }
-    case 25 /* SettleRound */: {
+    case 26 /* SettleRound */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 25 /* SettleRound */,
+        instructionType: 26 /* SettleRound */,
         ...parseSettleRoundInstruction(instruction)
       };
     }
-    case 26 /* Stake */: {
+    case 27 /* Stake */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 26 /* Stake */,
+        instructionType: 27 /* Stake */,
         ...parseStakeInstruction(instruction)
       };
     }
-    case 27 /* Withdraw */: {
+    case 28 /* Withdraw */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 27 /* Withdraw */,
+        instructionType: 28 /* Withdraw */,
         ...parseWithdrawInstruction(instruction)
       };
     }
-    case 28 /* WithdrawFees */: {
+    case 29 /* WithdrawFees */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 28 /* WithdrawFees */,
+        instructionType: 29 /* WithdrawFees */,
         ...parseWithdrawFeesInstruction(instruction)
       };
     }
     default:
-      throw new SolanaError30(
+      throw new SolanaError31(
         SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
         { instructionType, programName: "accord" }
       );
@@ -6233,6 +6443,10 @@ function accordProgram() {
             client,
             getClaimAppealRefundInstructionAsync(input)
           ), "claimAppealRefund"),
+          claimFilingBounty: /* @__PURE__ */ __name((input) => addSelfPlanAndSendFunctions(
+            client,
+            getClaimFilingBountyInstructionAsync(input)
+          ), "claimFilingBounty"),
           commit: /* @__PURE__ */ __name((input) => addSelfPlanAndSendFunctions(client, getCommitInstruction(input)), "commit"),
           commitVrfCallback: /* @__PURE__ */ __name((input) => addSelfPlanAndSendFunctions(
             client,
@@ -6344,20 +6558,20 @@ __name(accordProgram, "accordProgram");
 
 // src/pda.ts
 import {
-  getAddressEncoder as getAddressEncoder25,
-  getBytesEncoder as getBytesEncoder47,
-  getProgramDerivedAddress as getProgramDerivedAddress17,
+  getAddressEncoder as getAddressEncoder26,
+  getBytesEncoder as getBytesEncoder48,
+  getProgramDerivedAddress as getProgramDerivedAddress18,
   getU32Encoder as getU32Encoder13
 } from "@solana/kit";
 var ACCORD_PROGRAM_ID = "cordhVoshqRV6kzGBmM89A66wuusJGsDCvLMHPLyKed";
 var ROUND_SEED = new Uint8Array([114, 111, 117, 110, 100]);
 async function findRoundPda2(seeds, config = {}) {
   const { programAddress = ACCORD_PROGRAM_ID } = config;
-  return await getProgramDerivedAddress17({
+  return await getProgramDerivedAddress18({
     programAddress,
     seeds: [
-      getBytesEncoder47().encode(ROUND_SEED),
-      getAddressEncoder25().encode(seeds.dispute),
+      getBytesEncoder48().encode(ROUND_SEED),
+      getAddressEncoder26().encode(seeds.dispute),
       getU32Encoder13().encode(seeds.roundIdx)
     ]
   });
@@ -6368,19 +6582,20 @@ __name(findRoundPda2, "findRoundPda");
 import {
   AccountRole,
   getAddressDecoder as getAddressDecoder11,
-  getAddressEncoder as getAddressEncoder27
+  getAddressEncoder as getAddressEncoder28
 } from "@solana/kit";
 
 // src/methods/dispute.ts
 import {
-  getAddressEncoder as getAddressEncoder26,
-  getProgramDerivedAddress as getProgramDerivedAddress18
+  getAddressEncoder as getAddressEncoder27,
+  getProgramDerivedAddress as getProgramDerivedAddress19
 } from "@solana/kit";
 
 // src/constants.ts
 var MAX_JURORS = 31;
 var MAX_APPEALS = 3;
 var MAX_OPTIONS = 8;
+var MAX_SORTITION_RETRIES = 128;
 var UPDATE_TIMELOCK_SLOTS = 432000n;
 var UNPAUSE_TIMELOCK_SLOTS = 216000n;
 var DEFAULT_APPEAL_WINDOW_SECS = 259200n;
@@ -6428,7 +6643,7 @@ function requiredFee(feePerJuror, minJurySize = 3) {
   if (feePerJuror < 0n || !Number.isInteger(minJurySize) || minJurySize < 1) {
     return null;
   }
-  const product = BigInt(minJurySize) * feePerJuror;
+  const product = BigInt(minJurySize + 1) * feePerJuror;
   if (product < 0n || product > U64_MAX) return null;
   return product;
 }
@@ -6478,8 +6693,8 @@ function disputeSeeds(filerBytes, nonce) {
 }
 __name(disputeSeeds, "disputeSeeds");
 async function findDisputePda2(programAddress, filer, nonce) {
-  const filerBytes = new Uint8Array(getAddressEncoder26().encode(filer));
-  const [address, bump] = await getProgramDerivedAddress18({
+  const filerBytes = new Uint8Array(getAddressEncoder27().encode(filer));
+  const [address, bump] = await getProgramDerivedAddress19({
     programAddress,
     seeds: disputeSeeds(filerBytes, nonce)
   });
@@ -6823,7 +7038,7 @@ function createAccordAdapter(accord) {
       );
     },
     buildFinalizeRound(input) {
-      const ix = getFinalizeRoundInstruction(
+      return getFinalizeRoundInstruction(
         {
           caller: accord.signer,
           subaccord: input.accounts.subaccord,
@@ -6832,7 +7047,6 @@ function createAccordAdapter(accord) {
         },
         { programAddress: input.programId }
       );
-      return appendRemaining(ix, input.remainingAccounts ?? []);
     },
     buildFinalizeDispute(input) {
       const ix = getFinalizeDisputeInstruction(
@@ -6863,7 +7077,7 @@ function createAccordAdapter(accord) {
       return appendRemaining(ix, input.remainingAccounts ?? []);
     },
     encodeAddress(address) {
-      return new Uint8Array(getAddressEncoder27().encode(address));
+      return new Uint8Array(getAddressEncoder28().encode(address));
     },
     // ── appeal ─────────────────────────────────────────────────────────────
     buildAppeal(input) {
@@ -6890,6 +7104,19 @@ function createAccordAdapter(accord) {
         },
         { programAddress: input.programId }
       );
+    },
+    buildClaimFilingBounty(input) {
+      return getClaimFilingBountyInstruction(
+        {
+          caller: accord.signer,
+          subaccord: input.accounts.subaccord,
+          dispute: input.accounts.dispute,
+          feeToken: input.accounts.feeToken,
+          filerTokenAccount: input.accounts.filerTokenAccount,
+          feeVault: input.accounts.feeVault
+        },
+        { programAddress: input.programId }
+      );
     }
   };
 }
@@ -6969,8 +7196,8 @@ __name(appendRemaining, "appendRemaining");
 
 // src/methods/lifecycle.ts
 import {
-  getAddressEncoder as getAddressEncoder28,
-  getProgramDerivedAddress as getProgramDerivedAddress19
+  getAddressEncoder as getAddressEncoder29,
+  getProgramDerivedAddress as getProgramDerivedAddress20
 } from "@solana/kit";
 var SEED_SUBACCORD = new Uint8Array([
   115,
@@ -7086,8 +7313,8 @@ function canExecuteAt(executeAfterSlot, currentSlot) {
 }
 __name(canExecuteAt, "canExecuteAt");
 async function findSubaccordPda2(programAddress, creator, domainRef) {
-  const creatorBytes = new Uint8Array(getAddressEncoder28().encode(creator));
-  const [address, bump] = await getProgramDerivedAddress19({
+  const creatorBytes = new Uint8Array(getAddressEncoder29().encode(creator));
+  const [address, bump] = await getProgramDerivedAddress20({
     programAddress,
     seeds: subaccordSeeds(creatorBytes, domainRef)
   });
@@ -7095,8 +7322,8 @@ async function findSubaccordPda2(programAddress, creator, domainRef) {
 }
 __name(findSubaccordPda2, "findSubaccordPda");
 async function findPendingUpdatePda2(programAddress, subaccord, nonce) {
-  const subBytes = new Uint8Array(getAddressEncoder28().encode(subaccord));
-  const [address, bump] = await getProgramDerivedAddress19({
+  const subBytes = new Uint8Array(getAddressEncoder29().encode(subaccord));
+  const [address, bump] = await getProgramDerivedAddress20({
     programAddress,
     seeds: pendingUpdateSeeds(subBytes, nonce)
   });
@@ -7104,7 +7331,7 @@ async function findPendingUpdatePda2(programAddress, subaccord, nonce) {
 }
 __name(findPendingUpdatePda2, "findPendingUpdatePda");
 async function findAccordStatePdaWithBump(programAddress) {
-  const [address, bump] = await getProgramDerivedAddress19({
+  const [address, bump] = await getProgramDerivedAddress20({
     programAddress,
     seeds: accordStateSeeds()
   });
@@ -7189,8 +7416,8 @@ __name(executeUnpause, "executeUnpause");
 // src/methods/staking.ts
 import {
   AccountRole as AccountRole2,
-  getAddressEncoder as getAddressEncoder29,
-  getProgramDerivedAddress as getProgramDerivedAddress20
+  getAddressEncoder as getAddressEncoder30,
+  getProgramDerivedAddress as getProgramDerivedAddress21
 } from "@solana/kit";
 var SEED_JUROR_STAKE = new Uint8Array([115, 116, 97, 107, 101]);
 var U64_MAX3 = 0xffffffffffffffffn;
@@ -7225,15 +7452,21 @@ function jurorStakeSeeds(subaccordBytes, jurorBytes) {
   return [SEED_JUROR_STAKE, subaccordBytes, jurorBytes];
 }
 __name(jurorStakeSeeds, "jurorStakeSeeds");
-function stake(client, programId, accounts, amount, path, attestation, freedSlotAccount) {
+function stake(client, programId, accounts, amount, path, attestation, freedSlotAccount, nextNeighborAccount) {
   assertValidAmount(amount);
   const ix = client.buildStake({ programId, accounts, amount, path, attestation });
-  if (freedSlotAccount) {
+  const neighbors = [freedSlotAccount, nextNeighborAccount].filter(
+    (a) => a !== void 0
+  );
+  if (neighbors.length > 0) {
     return {
       ...ix,
       accounts: [
         ...ix.accounts ?? [],
-        { address: freedSlotAccount, role: AccountRole2.WRITABLE }
+        ...neighbors.map((address) => ({
+          address,
+          role: AccountRole2.WRITABLE
+        }))
       ]
     };
   }
@@ -7258,8 +7491,18 @@ function reconcileStake(client, programId, accounts, path) {
   return client.buildReconcileStake({ programId, accounts, path });
 }
 __name(reconcileStake, "reconcileStake");
-function reclaimSlot(client, programId, accounts, path) {
-  return client.buildReclaimSlot({ programId, accounts, path });
+function reclaimSlot(client, programId, accounts, path, headSlotAccount) {
+  const ix = client.buildReclaimSlot({ programId, accounts, path });
+  if (headSlotAccount) {
+    return {
+      ...ix,
+      accounts: [
+        ...ix.accounts ?? [],
+        { address: headSlotAccount, role: AccountRole2.WRITABLE }
+      ]
+    };
+  }
+  return ix;
 }
 __name(reclaimSlot, "reclaimSlot");
 function withdrawFees(client, programId, accounts) {
@@ -7297,6 +7540,10 @@ function cancelDispute(client, programId, accounts, remainingAccounts) {
   });
 }
 __name(cancelDispute, "cancelDispute");
+function claimFilingBounty(client, programId, accounts) {
+  return client.buildClaimFilingBounty({ programId, accounts });
+}
+__name(claimFilingBounty, "claimFilingBounty");
 
 // src/methods/mst.ts
 var MAX_SDK_DEPTH = 20;
@@ -7523,7 +7770,7 @@ async function findLeafForSlot(tree, slot) {
   return null;
 }
 __name(findLeafForSlot, "findLeafForSlot");
-async function resolveSeat(committedVrf, disputeBytes, roundIdx, seat, tree, alreadyDrawn, maxRetries = 1024, drawAttempt = 0) {
+async function resolveSeat(committedVrf, disputeBytes, roundIdx, seat, tree, alreadyDrawn, maxRetries = MAX_SORTITION_RETRIES, drawAttempt = 0) {
   const total = tree.rootSum;
   if (total <= 0n) throw new Error("InvalidTotalStake: must be > 0");
   const drawnHex = new Set(alreadyDrawn.map((j) => hex(j)));
@@ -7704,8 +7951,8 @@ function reveal(client, programId, accounts, args) {
   });
 }
 __name(reveal, "reveal");
-function finalizeRound(client, programId, accounts, remainingAccounts = []) {
-  return client.buildFinalizeRound({ programId, accounts, remainingAccounts });
+function finalizeRound(client, programId, accounts) {
+  return client.buildFinalizeRound({ programId, accounts });
 }
 __name(finalizeRound, "finalizeRound");
 function finalizeDispute(client, programId, accounts, remainingAccounts) {
@@ -7723,8 +7970,8 @@ __name(redraw, "redraw");
 
 // src/methods/appeal.ts
 import {
-  getAddressEncoder as getAddressEncoder30,
-  getProgramDerivedAddress as getProgramDerivedAddress21
+  getAddressEncoder as getAddressEncoder31,
+  getProgramDerivedAddress as getProgramDerivedAddress22
 } from "@solana/kit";
 var SEED_APPEAL_BOND = new Uint8Array([98, 111, 110, 100]);
 function le42(v) {
@@ -7739,7 +7986,8 @@ function appealCost(currentRound, feePerJuror, minJurySize = 3) {
   if (panel === null) return null;
   const fee = BigInt(panel) * feePerJuror;
   const bond = fee;
-  return { newRound, panel, fee, bond, total: fee + bond };
+  const bounty = feePerJuror;
+  return { newRound, panel, fee, bond, bounty, total: fee + bond + bounty };
 }
 __name(appealCost, "appealCost");
 function canAppeal(currentRound, maxAppeals) {
@@ -7820,6 +8068,7 @@ function createAccordMethods(adapter, programId = ACCORD_PROGRAM_ID, _signer) {
       remainingAccounts
     ), "settleRound"),
     cancelDispute: /* @__PURE__ */ __name((accounts, remainingAccounts) => cancelDispute(adapter, programId, accounts, remainingAccounts), "cancelDispute"),
+    claimFilingBounty: /* @__PURE__ */ __name((accounts) => claimFilingBounty(adapter, programId, accounts), "claimFilingBounty"),
     // vrf + per-seat draw
     requestVrf: /* @__PURE__ */ __name((accounts, extras) => requestVrf(adapter, programId, accounts, extras), "requestVrf"),
     awaitCommittedVrf: /* @__PURE__ */ __name((dispute, opts) => awaitCommittedVrf(adapter, dispute, opts), "awaitCommittedVrf"),
@@ -7827,7 +8076,7 @@ function createAccordMethods(adapter, programId = ACCORD_PROGRAM_ID, _signer) {
     // voting
     commit: /* @__PURE__ */ __name((accounts, args) => commit(adapter, programId, accounts, args), "commit"),
     reveal: /* @__PURE__ */ __name((accounts, args) => reveal(adapter, programId, accounts, args), "reveal"),
-    finalizeRound: /* @__PURE__ */ __name((accounts, remainingAccounts = []) => finalizeRound(adapter, programId, accounts, remainingAccounts), "finalizeRound"),
+    finalizeRound: /* @__PURE__ */ __name((accounts) => finalizeRound(adapter, programId, accounts), "finalizeRound"),
     finalizeDispute: /* @__PURE__ */ __name((accounts, remainingAccounts) => finalizeDispute(adapter, programId, accounts, remainingAccounts), "finalizeDispute"),
     redraw: /* @__PURE__ */ __name((accounts, remainingAccounts = []) => redraw(adapter, programId, accounts, remainingAccounts), "redraw"),
     // appeal
@@ -7899,14 +8148,14 @@ __name(signerFromWallet, "signerFromWallet");
 
 // src/token.ts
 import {
-  getAddressEncoder as getAddressEncoder31,
-  getProgramDerivedAddress as getProgramDerivedAddress22
+  getAddressEncoder as getAddressEncoder32,
+  getProgramDerivedAddress as getProgramDerivedAddress23
 } from "@solana/kit";
 var TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 var ASSOCIATED_TOKEN_PROGRAM_ADDRESS = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
 async function findAssociatedTokenAddress(mint, owner) {
-  const enc = getAddressEncoder31();
-  const [ata] = await getProgramDerivedAddress22({
+  const enc = getAddressEncoder32();
+  const [ata] = await getProgramDerivedAddress23({
     programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     seeds: [enc.encode(owner), enc.encode(TOKEN_PROGRAM_ADDRESS), enc.encode(mint)]
   });
@@ -7916,12 +8165,12 @@ __name(findAssociatedTokenAddress, "findAssociatedTokenAddress");
 
 // src/query.ts
 import {
-  getAddressEncoder as getAddressEncoder32,
+  getAddressEncoder as getAddressEncoder33,
   getBase58Decoder,
   getBase64Encoder
 } from "@solana/kit";
 var base58 = getBase58Decoder();
-var addressEncoder = getAddressEncoder32();
+var addressEncoder = getAddressEncoder33();
 function discriminatorFilter(discriminator) {
   return {
     memcmp: {
@@ -8274,9 +8523,9 @@ var AccordErrors = {
 };
 
 // src/methods/stakeFlow.ts
-import { getAddressEncoder as getAddressEncoder33 } from "@solana/kit";
+import { getAddressEncoder as getAddressEncoder34 } from "@solana/kit";
 function addrBytes(addr) {
-  return new Uint8Array(getAddressEncoder33().encode(addr));
+  return new Uint8Array(getAddressEncoder34().encode(addr));
 }
 __name(addrBytes, "addrBytes");
 async function prepareStakeProof(subaccord, jurorStakes, juror) {
@@ -8553,6 +8802,7 @@ export {
   MAX_JURORS,
   MAX_OPTIONS,
   MAX_SAFE_TREE_DEPTH,
+  MAX_SORTITION_RETRIES,
   MIN_APPEAL_WINDOW_SECS,
   NO_RULING,
   NO_VOTE,
@@ -8594,6 +8844,7 @@ export {
   canUnstake,
   cancelDispute,
   claimAppealRefund,
+  claimFilingBounty,
   commit,
   commitHash,
   createAccordAdapter,