@satrush/client 0.1.10 → 0.1.11

package/dist/index.mjs

@@ -49,7 +49,9 @@ function getBoardEncoder() {
       ["strikeUsdAmount", getU64Encoder()],
       ["strikeBtcAmount", getU64Encoder()],
       ["strikeLastTriggerRoundId", getU32Encoder()],
-      ["reserved", fixEncoderSize(getBytesEncoder(), 30)]
+      ["strikeReserveUsdAmount", getU64Encoder()],
+      ["strikeReserveBtcAmount", getU64Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 14)]
     ]),
     (value) => ({ ...value, discriminator: BOARD_DISCRIMINATOR })
   );
@@ -67,7 +69,9 @@ function getBoardDecoder() {
     ["strikeUsdAmount", getU64Decoder()],
     ["strikeBtcAmount", getU64Decoder()],
     ["strikeLastTriggerRoundId", getU32Decoder()],
-    ["reserved", fixDecoderSize(getBytesDecoder(), 30)]
+    ["strikeReserveUsdAmount", getU64Decoder()],
+    ["strikeReserveBtcAmount", getU64Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 14)]
   ]);
 }
 function getBoardCodec() {
@@ -886,6 +890,12 @@ function getRoundRevealedEncoder() {
       ["isStrikeTriggered", getBooleanEncoder3()],
       ["strikeBonusUsd", getU64Encoder12()],
       ["strikeBonusBtc", getU64Encoder12()],
+      ["strikeEpochUsd", getU64Encoder12()],
+      ["strikeEpochBtc", getU64Encoder12()],
+      ["strikeReserveUsd", getU64Encoder12()],
+      ["strikeReserveBtc", getU64Encoder12()],
+      ["strikeSeedFromReserveUsd", getU64Encoder12()],
+      ["strikeSeedFromReserveBtc", getU64Encoder12()],
       ["epochFeeUsdAmount", getU64Encoder12()],
       ["oneBtcFeeUsdAmount", getU64Encoder12()],
       ["protocolFeeUsdAmount", getU64Encoder12()]
@@ -907,6 +917,12 @@ function getRoundRevealedDecoder() {
       ["isStrikeTriggered", getBooleanDecoder3()],
       ["strikeBonusUsd", getU64Decoder12()],
       ["strikeBonusBtc", getU64Decoder12()],
+      ["strikeEpochUsd", getU64Decoder12()],
+      ["strikeEpochBtc", getU64Decoder12()],
+      ["strikeReserveUsd", getU64Decoder12()],
+      ["strikeReserveBtc", getU64Decoder12()],
+      ["strikeSeedFromReserveUsd", getU64Decoder12()],
+      ["strikeSeedFromReserveBtc", getU64Decoder12()],
       ["epochFeeUsdAmount", getU64Decoder12()],
       ["oneBtcFeeUsdAmount", getU64Decoder12()],
       ["protocolFeeUsdAmount", getU64Decoder12()]
@@ -1948,6 +1964,8 @@ import {
   fixEncoderSize as fixEncoderSize22,
   getArrayDecoder as getArrayDecoder3,
   getArrayEncoder as getArrayEncoder3,
+  getBooleanDecoder as getBooleanDecoder7,
+  getBooleanEncoder as getBooleanEncoder7,
   getBytesDecoder as getBytesDecoder12,
   getBytesEncoder as getBytesEncoder22,
   getOptionDecoder as getOptionDecoder2,
@@ -2006,7 +2024,8 @@ function getRoundEncoder() {
       ["pendingEpochFeeUsdAmount", getU64Encoder25()],
       ["pendingOneBtcFeeUsdAmount", getU64Encoder25()],
       ["pendingProtocolFeeUsdAmount", getU64Encoder25()],
-      ["reserved", fixEncoderSize22(getBytesEncoder22(), 40)]
+      ["isHashrateBoosted", getBooleanEncoder7()],
+      ["reserved", fixEncoderSize22(getBytesEncoder22(), 39)]
     ]),
     (value) => ({ ...value, discriminator: ROUND_DISCRIMINATOR })
   );
@@ -2036,7 +2055,8 @@ function getRoundDecoder() {
     ["pendingEpochFeeUsdAmount", getU64Decoder25()],
     ["pendingOneBtcFeeUsdAmount", getU64Decoder25()],
     ["pendingProtocolFeeUsdAmount", getU64Decoder25()],
-    ["reserved", fixDecoderSize12(getBytesDecoder12(), 40)]
+    ["isHashrateBoosted", getBooleanDecoder7()],
+    ["reserved", fixDecoderSize12(getBytesDecoder12(), 39)]
   ]);
 }
 function getRoundCodec() {
@@ -2386,12 +2406,12 @@ import {
   assertIsInstructionWithAccounts,
   containsBytes,
   extendClient,
-  fixEncoderSize as fixEncoderSize66,
-  getBytesEncoder as getBytesEncoder78,
+  fixEncoderSize as fixEncoderSize67,
+  getBytesEncoder as getBytesEncoder79,
   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 SolanaError41
+  SolanaError as SolanaError42
 } from "@solana/kit";
 import {
   addSelfFetchFunctions,
@@ -4750,7 +4770,8 @@ async function getCloseEpochEntryInstructionAsync(input, config) {
       value: input.epochVaultIteration ?? null,
       isWritable: false
     },
-    epochVaultEntry: { value: input.epochVaultEntry ?? null, isWritable: true }
+    epochVaultEntry: { value: input.epochVaultEntry ?? null, isWritable: true },
+    entryOwner: { value: input.entryOwner ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
   if (!accounts.satrushConfig.value) {
@@ -4762,7 +4783,8 @@ async function getCloseEpochEntryInstructionAsync(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig),
       getAccountMeta("epochVaultIteration", accounts.epochVaultIteration),
-      getAccountMeta("epochVaultEntry", accounts.epochVaultEntry)
+      getAccountMeta("epochVaultEntry", accounts.epochVaultEntry),
+      getAccountMeta("entryOwner", accounts.entryOwner)
     ],
     data: getCloseEpochEntryInstructionDataEncoder().encode({}),
     programAddress
@@ -4777,7 +4799,8 @@ function getCloseEpochEntryInstruction(input, config) {
       value: input.epochVaultIteration ?? null,
       isWritable: false
     },
-    epochVaultEntry: { value: input.epochVaultEntry ?? null, isWritable: true }
+    epochVaultEntry: { value: input.epochVaultEntry ?? null, isWritable: true },
+    entryOwner: { value: input.entryOwner ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
   const getAccountMeta = getAccountMetaFactory8(programAddress, "programId");
@@ -4786,19 +4809,20 @@ function getCloseEpochEntryInstruction(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig),
       getAccountMeta("epochVaultIteration", accounts.epochVaultIteration),
-      getAccountMeta("epochVaultEntry", accounts.epochVaultEntry)
+      getAccountMeta("epochVaultEntry", accounts.epochVaultEntry),
+      getAccountMeta("entryOwner", accounts.entryOwner)
     ],
     data: getCloseEpochEntryInstructionDataEncoder().encode({}),
     programAddress
   });
 }
 function parseCloseEpochEntryInstruction(instruction) {
-  if (instruction.accounts.length < 4) {
+  if (instruction.accounts.length < 5) {
     throw new SolanaError8(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS8,
       {
         actualAccountMetas: instruction.accounts.length,
-        expectedAccountMetas: 4
+        expectedAccountMetas: 5
       }
     );
   }
@@ -4814,7 +4838,8 @@ function parseCloseEpochEntryInstruction(instruction) {
       authority: getNextAccount(),
       satrushConfig: getNextAccount(),
       epochVaultIteration: getNextAccount(),
-      epochVaultEntry: getNextAccount()
+      epochVaultEntry: getNextAccount(),
+      entryOwner: getNextAccount()
     },
     data: getCloseEpochEntryInstructionDataDecoder().decode(instruction.data)
   };
@@ -5210,35 +5235,68 @@ function getCloseOneBtcTicketInstructionDataCodec() {
     getCloseOneBtcTicketInstructionDataDecoder()
   );
 }
+async function getCloseOneBtcTicketInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: true },
+    satrushConfig: { value: input.satrushConfig ?? null, isWritable: false },
+    oneBtcVaultIteration: {
+      value: input.oneBtcVaultIteration ?? null,
+      isWritable: false
+    },
+    ticket: { value: input.ticket ?? null, isWritable: true },
+    ticketOwner: { value: input.ticketOwner ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.satrushConfig.value) {
+    accounts.satrushConfig.value = await findSatrushConfigPda();
+  }
+  const getAccountMeta = getAccountMetaFactory12(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("satrushConfig", accounts.satrushConfig),
+      getAccountMeta("oneBtcVaultIteration", accounts.oneBtcVaultIteration),
+      getAccountMeta("ticket", accounts.ticket),
+      getAccountMeta("ticketOwner", accounts.ticketOwner)
+    ],
+    data: getCloseOneBtcTicketInstructionDataEncoder().encode({}),
+    programAddress
+  });
+}
 function getCloseOneBtcTicketInstruction(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: true },
+    satrushConfig: { value: input.satrushConfig ?? null, isWritable: false },
     oneBtcVaultIteration: {
       value: input.oneBtcVaultIteration ?? null,
       isWritable: false
     },
-    ticket: { value: input.ticket ?? null, isWritable: true }
+    ticket: { value: input.ticket ?? null, isWritable: true },
+    ticketOwner: { value: input.ticketOwner ?? null, isWritable: true }
   };
   const accounts = originalAccounts;
   const getAccountMeta = getAccountMetaFactory12(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
+      getAccountMeta("satrushConfig", accounts.satrushConfig),
       getAccountMeta("oneBtcVaultIteration", accounts.oneBtcVaultIteration),
-      getAccountMeta("ticket", accounts.ticket)
+      getAccountMeta("ticket", accounts.ticket),
+      getAccountMeta("ticketOwner", accounts.ticketOwner)
     ],
     data: getCloseOneBtcTicketInstructionDataEncoder().encode({}),
     programAddress
   });
 }
 function parseCloseOneBtcTicketInstruction(instruction) {
-  if (instruction.accounts.length < 3) {
+  if (instruction.accounts.length < 5) {
     throw new SolanaError12(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS12,
       {
         actualAccountMetas: instruction.accounts.length,
-        expectedAccountMetas: 3
+        expectedAccountMetas: 5
       }
     );
   }
@@ -5252,8 +5310,10 @@ function parseCloseOneBtcTicketInstruction(instruction) {
     programAddress: instruction.programAddress,
     accounts: {
       authority: getNextAccount(),
+      satrushConfig: getNextAccount(),
       oneBtcVaultIteration: getNextAccount(),
-      ticket: getNextAccount()
+      ticket: getNextAccount(),
+      ticketOwner: getNextAccount()
     },
     data: getCloseOneBtcTicketInstructionDataDecoder().decode(instruction.data)
   };
@@ -6612,8 +6672,8 @@ import {
   fixDecoderSize as fixDecoderSize32,
   fixEncoderSize as fixEncoderSize42,
   getAddressEncoder as getAddressEncoder27,
-  getBooleanDecoder as getBooleanDecoder7,
-  getBooleanEncoder as getBooleanEncoder7,
+  getBooleanDecoder as getBooleanDecoder8,
+  getBooleanEncoder as getBooleanEncoder8,
   getBytesDecoder as getBytesDecoder32,
   getBytesEncoder as getBytesEncoder54,
   getProgramDerivedAddress as getProgramDerivedAddress22,
@@ -6644,7 +6704,7 @@ function getCreatePublicAutomationInstructionDataEncoder() {
       ["strategy", getAutomationStrategyEncoder()],
       ["selectionMask", getU32Encoder24()],
       ["perRoundUsdAmount", getU64Encoder33()],
-      ["reload", getBooleanEncoder7()],
+      ["reload", getBooleanEncoder8()],
       ["depositUsdAmount", getU64Encoder33()]
     ]),
     (value) => ({
@@ -6659,7 +6719,7 @@ function getCreatePublicAutomationInstructionDataDecoder() {
     ["strategy", getAutomationStrategyDecoder()],
     ["selectionMask", getU32Decoder24()],
     ["perRoundUsdAmount", getU64Decoder33()],
-    ["reload", getBooleanDecoder7()],
+    ["reload", getBooleanDecoder8()],
     ["depositUsdAmount", getU64Decoder33()]
   ]);
 }
@@ -8072,12 +8132,18 @@ async function getRotateRoundInstructionAsync(input, config) {
     currentRound: { value: input.currentRound ?? null, isWritable: true },
     nextRound: { value: input.nextRound ?? null, isWritable: true },
     usdMint: { value: input.usdMint ?? null, isWritable: false },
+    btcMint: { value: input.btcMint ?? null, isWritable: false },
     boardUsdAta: { value: input.boardUsdAta ?? null, isWritable: true },
+    boardBtcAta: { value: input.boardBtcAta ?? null, isWritable: true },
     epochVault: { value: input.epochVault ?? null, isWritable: true },
     epochVaultUsdAta: {
       value: input.epochVaultUsdAta ?? null,
       isWritable: true
     },
+    epochVaultBtcAta: {
+      value: input.epochVaultBtcAta ?? null,
+      isWritable: true
+    },
     oneBtcVault: { value: input.oneBtcVault ?? null, isWritable: true },
     oneBtcVaultUsdAta: {
       value: input.oneBtcVaultUsdAta ?? null,
@@ -8222,61 +8288,6 @@ async function getRotateRoundInstructionAsync(input, config) {
   if (!accounts.oneBtcVault.value) {
     accounts.oneBtcVault.value = await findOneBtcVaultPda();
   }
-  if (!accounts.oneBtcVaultUsdAta.value) {
-    accounts.oneBtcVaultUsdAta.value = await getProgramDerivedAddress27({
-      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
-      seeds: [
-        getAddressEncoder33().encode(
-          getAddressFromResolvedInstructionAccount17(
-            "oneBtcVault",
-            accounts.oneBtcVault.value
-          )
-        ),
-        getBytesEncoder60().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
-          ])
-        ),
-        getAddressEncoder33().encode(
-          getAddressFromResolvedInstructionAccount17(
-            "usdMint",
-            accounts.usdMint.value
-          )
-        )
-      ]
-    });
-  }
   if (!accounts.treasuryUsdAta.value) {
     accounts.treasuryUsdAta.value = await getProgramDerivedAddress27({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
@@ -8350,9 +8361,12 @@ async function getRotateRoundInstructionAsync(input, config) {
       getAccountMeta("currentRound", accounts.currentRound),
       getAccountMeta("nextRound", accounts.nextRound),
       getAccountMeta("usdMint", accounts.usdMint),
+      getAccountMeta("btcMint", accounts.btcMint),
       getAccountMeta("boardUsdAta", accounts.boardUsdAta),
+      getAccountMeta("boardBtcAta", accounts.boardBtcAta),
       getAccountMeta("epochVault", accounts.epochVault),
       getAccountMeta("epochVaultUsdAta", accounts.epochVaultUsdAta),
+      getAccountMeta("epochVaultBtcAta", accounts.epochVaultBtcAta),
       getAccountMeta("oneBtcVault", accounts.oneBtcVault),
       getAccountMeta("oneBtcVaultUsdAta", accounts.oneBtcVaultUsdAta),
       getAccountMeta("treasury", accounts.treasury),
@@ -8376,12 +8390,18 @@ function getRotateRoundInstruction(input, config) {
     currentRound: { value: input.currentRound ?? null, isWritable: true },
     nextRound: { value: input.nextRound ?? null, isWritable: true },
     usdMint: { value: input.usdMint ?? null, isWritable: false },
+    btcMint: { value: input.btcMint ?? null, isWritable: false },
     boardUsdAta: { value: input.boardUsdAta ?? null, isWritable: true },
+    boardBtcAta: { value: input.boardBtcAta ?? null, isWritable: true },
     epochVault: { value: input.epochVault ?? null, isWritable: true },
     epochVaultUsdAta: {
       value: input.epochVaultUsdAta ?? null,
       isWritable: true
     },
+    epochVaultBtcAta: {
+      value: input.epochVaultBtcAta ?? null,
+      isWritable: true
+    },
     oneBtcVault: { value: input.oneBtcVault ?? null, isWritable: true },
     oneBtcVaultUsdAta: {
       value: input.oneBtcVaultUsdAta ?? null,
@@ -8414,9 +8434,12 @@ function getRotateRoundInstruction(input, config) {
       getAccountMeta("currentRound", accounts.currentRound),
       getAccountMeta("nextRound", accounts.nextRound),
       getAccountMeta("usdMint", accounts.usdMint),
+      getAccountMeta("btcMint", accounts.btcMint),
       getAccountMeta("boardUsdAta", accounts.boardUsdAta),
+      getAccountMeta("boardBtcAta", accounts.boardBtcAta),
       getAccountMeta("epochVault", accounts.epochVault),
       getAccountMeta("epochVaultUsdAta", accounts.epochVaultUsdAta),
+      getAccountMeta("epochVaultBtcAta", accounts.epochVaultBtcAta),
       getAccountMeta("oneBtcVault", accounts.oneBtcVault),
       getAccountMeta("oneBtcVaultUsdAta", accounts.oneBtcVaultUsdAta),
       getAccountMeta("treasury", accounts.treasury),
@@ -8432,12 +8455,12 @@ function getRotateRoundInstruction(input, config) {
   });
 }
 function parseRotateRoundInstruction(instruction) {
-  if (instruction.accounts.length < 18) {
+  if (instruction.accounts.length < 21) {
     throw new SolanaError23(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS23,
       {
         actualAccountMetas: instruction.accounts.length,
-        expectedAccountMetas: 18
+        expectedAccountMetas: 21
       }
     );
   }
@@ -8456,9 +8479,12 @@ function parseRotateRoundInstruction(instruction) {
       currentRound: getNextAccount(),
       nextRound: getNextAccount(),
       usdMint: getNextAccount(),
+      btcMint: getNextAccount(),
       boardUsdAta: getNextAccount(),
+      boardBtcAta: getNextAccount(),
       epochVault: getNextAccount(),
       epochVaultUsdAta: getNextAccount(),
+      epochVaultBtcAta: getNextAccount(),
       oneBtcVault: getNextAccount(),
       oneBtcVaultUsdAta: getNextAccount(),
       treasury: getNextAccount(),
@@ -11030,7 +11056,7 @@ function parseUpdateBoardRoundDurationInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/updateDeploymentSettleGraceDuration.ts
+// src/generated/instructions/updateDeployFees.ts
 import {
   combineCodec as combineCodec67,
   fixDecoderSize as fixDecoderSize50,
@@ -11039,8 +11065,8 @@ import {
   getBytesEncoder as getBytesEncoder72,
   getStructDecoder as getStructDecoder63,
   getStructEncoder as getStructEncoder63,
-  getU64Decoder as getU64Decoder40,
-  getU64Encoder as getU64Encoder40,
+  getU32Decoder as getU32Decoder32,
+  getU32Encoder as getU32Encoder32,
   SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS35,
   SolanaError as SolanaError35,
   transformEncoder as transformEncoder50
@@ -11048,37 +11074,40 @@ import {
 import {
   getAccountMetaFactory as getAccountMetaFactory35
 } from "@solana/program-client-core";
-var UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR = new Uint8Array([2, 212, 246, 89, 139, 64, 104, 74]);
-function getUpdateDeploymentSettleGraceDurationDiscriminatorBytes() {
+var UPDATE_DEPLOY_FEES_DISCRIMINATOR = new Uint8Array([0, 170, 26, 215, 156, 171, 22, 68]);
+function getUpdateDeployFeesDiscriminatorBytes() {
   return fixEncoderSize60(getBytesEncoder72(), 8).encode(
-    UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR
+    UPDATE_DEPLOY_FEES_DISCRIMINATOR
   );
 }
-function getUpdateDeploymentSettleGraceDurationInstructionDataEncoder() {
+function getUpdateDeployFeesInstructionDataEncoder() {
   return transformEncoder50(
     getStructEncoder63([
       ["discriminator", fixEncoderSize60(getBytesEncoder72(), 8)],
-      ["newGraceDuration", getU64Encoder40()]
+      ["newStrikeFeeBps", getU32Encoder32()],
+      ["newEpochFeeBps", getU32Encoder32()],
+      ["newOneBtcFeeBps", getU32Encoder32()],
+      ["newProtocolFeeBps", getU32Encoder32()]
     ]),
-    (value) => ({
-      ...value,
-      discriminator: UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR
-    })
+    (value) => ({ ...value, discriminator: UPDATE_DEPLOY_FEES_DISCRIMINATOR })
   );
 }
-function getUpdateDeploymentSettleGraceDurationInstructionDataDecoder() {
+function getUpdateDeployFeesInstructionDataDecoder() {
   return getStructDecoder63([
     ["discriminator", fixDecoderSize50(getBytesDecoder50(), 8)],
-    ["newGraceDuration", getU64Decoder40()]
+    ["newStrikeFeeBps", getU32Decoder32()],
+    ["newEpochFeeBps", getU32Decoder32()],
+    ["newOneBtcFeeBps", getU32Decoder32()],
+    ["newProtocolFeeBps", getU32Decoder32()]
   ]);
 }
-function getUpdateDeploymentSettleGraceDurationInstructionDataCodec() {
+function getUpdateDeployFeesInstructionDataCodec() {
   return combineCodec67(
-    getUpdateDeploymentSettleGraceDurationInstructionDataEncoder(),
-    getUpdateDeploymentSettleGraceDurationInstructionDataDecoder()
+    getUpdateDeployFeesInstructionDataEncoder(),
+    getUpdateDeployFeesInstructionDataDecoder()
   );
 }
-async function getUpdateDeploymentSettleGraceDurationInstructionAsync(input, config) {
+async function getUpdateDeployFeesInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11095,13 +11124,13 @@ async function getUpdateDeploymentSettleGraceDurationInstructionAsync(input, con
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateDeploymentSettleGraceDurationInstructionDataEncoder().encode(
+    data: getUpdateDeployFeesInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getUpdateDeploymentSettleGraceDurationInstruction(input, config) {
+function getUpdateDeployFeesInstruction(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11115,13 +11144,13 @@ function getUpdateDeploymentSettleGraceDurationInstruction(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateDeploymentSettleGraceDurationInstructionDataEncoder().encode(
+    data: getUpdateDeployFeesInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseUpdateDeploymentSettleGraceDurationInstruction(instruction) {
+function parseUpdateDeployFeesInstruction(instruction) {
   if (instruction.accounts.length < 2) {
     throw new SolanaError35(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS35,
@@ -11140,13 +11169,11 @@ function parseUpdateDeploymentSettleGraceDurationInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: { authority: getNextAccount(), satrushConfig: getNextAccount() },
-    data: getUpdateDeploymentSettleGraceDurationInstructionDataDecoder().decode(
-      instruction.data
-    )
+    data: getUpdateDeployFeesInstructionDataDecoder().decode(instruction.data)
   };
 }
 
-// src/generated/instructions/updateEpochVaultIterationDuration.ts
+// src/generated/instructions/updateDeploymentSettleGraceDuration.ts
 import {
   combineCodec as combineCodec68,
   fixDecoderSize as fixDecoderSize51,
@@ -11155,8 +11182,8 @@ import {
   getBytesEncoder as getBytesEncoder73,
   getStructDecoder as getStructDecoder64,
   getStructEncoder as getStructEncoder64,
-  getU64Decoder as getU64Decoder41,
-  getU64Encoder as getU64Encoder41,
+  getU64Decoder as getU64Decoder40,
+  getU64Encoder as getU64Encoder40,
   SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS36,
   SolanaError as SolanaError36,
   transformEncoder as transformEncoder51
@@ -11164,37 +11191,37 @@ import {
 import {
   getAccountMetaFactory as getAccountMetaFactory36
 } from "@solana/program-client-core";
-var UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR = new Uint8Array([171, 103, 59, 229, 174, 188, 210, 121]);
-function getUpdateEpochVaultIterationDurationDiscriminatorBytes() {
+var UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR = new Uint8Array([2, 212, 246, 89, 139, 64, 104, 74]);
+function getUpdateDeploymentSettleGraceDurationDiscriminatorBytes() {
   return fixEncoderSize61(getBytesEncoder73(), 8).encode(
-    UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR
+    UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR
   );
 }
-function getUpdateEpochVaultIterationDurationInstructionDataEncoder() {
+function getUpdateDeploymentSettleGraceDurationInstructionDataEncoder() {
   return transformEncoder51(
     getStructEncoder64([
       ["discriminator", fixEncoderSize61(getBytesEncoder73(), 8)],
-      ["newIterationDuration", getU64Encoder41()]
+      ["newGraceDuration", getU64Encoder40()]
     ]),
     (value) => ({
       ...value,
-      discriminator: UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR
+      discriminator: UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR
     })
   );
 }
-function getUpdateEpochVaultIterationDurationInstructionDataDecoder() {
+function getUpdateDeploymentSettleGraceDurationInstructionDataDecoder() {
   return getStructDecoder64([
     ["discriminator", fixDecoderSize51(getBytesDecoder51(), 8)],
-    ["newIterationDuration", getU64Decoder41()]
+    ["newGraceDuration", getU64Decoder40()]
   ]);
 }
-function getUpdateEpochVaultIterationDurationInstructionDataCodec() {
+function getUpdateDeploymentSettleGraceDurationInstructionDataCodec() {
   return combineCodec68(
-    getUpdateEpochVaultIterationDurationInstructionDataEncoder(),
-    getUpdateEpochVaultIterationDurationInstructionDataDecoder()
+    getUpdateDeploymentSettleGraceDurationInstructionDataEncoder(),
+    getUpdateDeploymentSettleGraceDurationInstructionDataDecoder()
   );
 }
-async function getUpdateEpochVaultIterationDurationInstructionAsync(input, config) {
+async function getUpdateDeploymentSettleGraceDurationInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11211,13 +11238,13 @@ async function getUpdateEpochVaultIterationDurationInstructionAsync(input, confi
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateEpochVaultIterationDurationInstructionDataEncoder().encode(
+    data: getUpdateDeploymentSettleGraceDurationInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getUpdateEpochVaultIterationDurationInstruction(input, config) {
+function getUpdateDeploymentSettleGraceDurationInstruction(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11231,13 +11258,13 @@ function getUpdateEpochVaultIterationDurationInstruction(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateEpochVaultIterationDurationInstructionDataEncoder().encode(
+    data: getUpdateDeploymentSettleGraceDurationInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseUpdateEpochVaultIterationDurationInstruction(instruction) {
+function parseUpdateDeploymentSettleGraceDurationInstruction(instruction) {
   if (instruction.accounts.length < 2) {
     throw new SolanaError36(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS36,
@@ -11256,13 +11283,13 @@ function parseUpdateEpochVaultIterationDurationInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: { authority: getNextAccount(), satrushConfig: getNextAccount() },
-    data: getUpdateEpochVaultIterationDurationInstructionDataDecoder().decode(
+    data: getUpdateDeploymentSettleGraceDurationInstructionDataDecoder().decode(
       instruction.data
     )
   };
 }
 
-// src/generated/instructions/updateMinDeployUsdAmount.ts
+// src/generated/instructions/updateEpochVaultIterationDuration.ts
 import {
   combineCodec as combineCodec69,
   fixDecoderSize as fixDecoderSize52,
@@ -11271,8 +11298,8 @@ import {
   getBytesEncoder as getBytesEncoder74,
   getStructDecoder as getStructDecoder65,
   getStructEncoder as getStructEncoder65,
-  getU64Decoder as getU64Decoder42,
-  getU64Encoder as getU64Encoder42,
+  getU64Decoder as getU64Decoder41,
+  getU64Encoder as getU64Encoder41,
   SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS37,
   SolanaError as SolanaError37,
   transformEncoder as transformEncoder52
@@ -11280,37 +11307,37 @@ import {
 import {
   getAccountMetaFactory as getAccountMetaFactory37
 } from "@solana/program-client-core";
-var UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR = new Uint8Array([187, 108, 89, 178, 249, 101, 187, 33]);
-function getUpdateMinDeployUsdAmountDiscriminatorBytes() {
+var UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR = new Uint8Array([171, 103, 59, 229, 174, 188, 210, 121]);
+function getUpdateEpochVaultIterationDurationDiscriminatorBytes() {
   return fixEncoderSize62(getBytesEncoder74(), 8).encode(
-    UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR
+    UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR
   );
 }
-function getUpdateMinDeployUsdAmountInstructionDataEncoder() {
+function getUpdateEpochVaultIterationDurationInstructionDataEncoder() {
   return transformEncoder52(
     getStructEncoder65([
       ["discriminator", fixEncoderSize62(getBytesEncoder74(), 8)],
-      ["newMinDeployUsdAmount", getU64Encoder42()]
+      ["newIterationDuration", getU64Encoder41()]
     ]),
     (value) => ({
       ...value,
-      discriminator: UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR
+      discriminator: UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR
     })
   );
 }
-function getUpdateMinDeployUsdAmountInstructionDataDecoder() {
+function getUpdateEpochVaultIterationDurationInstructionDataDecoder() {
   return getStructDecoder65([
     ["discriminator", fixDecoderSize52(getBytesDecoder52(), 8)],
-    ["newMinDeployUsdAmount", getU64Decoder42()]
+    ["newIterationDuration", getU64Decoder41()]
   ]);
 }
-function getUpdateMinDeployUsdAmountInstructionDataCodec() {
+function getUpdateEpochVaultIterationDurationInstructionDataCodec() {
   return combineCodec69(
-    getUpdateMinDeployUsdAmountInstructionDataEncoder(),
-    getUpdateMinDeployUsdAmountInstructionDataDecoder()
+    getUpdateEpochVaultIterationDurationInstructionDataEncoder(),
+    getUpdateEpochVaultIterationDurationInstructionDataDecoder()
   );
 }
-async function getUpdateMinDeployUsdAmountInstructionAsync(input, config) {
+async function getUpdateEpochVaultIterationDurationInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11327,13 +11354,13 @@ async function getUpdateMinDeployUsdAmountInstructionAsync(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateMinDeployUsdAmountInstructionDataEncoder().encode(
+    data: getUpdateEpochVaultIterationDurationInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getUpdateMinDeployUsdAmountInstruction(input, config) {
+function getUpdateEpochVaultIterationDurationInstruction(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11347,13 +11374,13 @@ function getUpdateMinDeployUsdAmountInstruction(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateMinDeployUsdAmountInstructionDataEncoder().encode(
+    data: getUpdateEpochVaultIterationDurationInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseUpdateMinDeployUsdAmountInstruction(instruction) {
+function parseUpdateEpochVaultIterationDurationInstruction(instruction) {
   if (instruction.accounts.length < 2) {
     throw new SolanaError37(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS37,
@@ -11372,13 +11399,13 @@ function parseUpdateMinDeployUsdAmountInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: { authority: getNextAccount(), satrushConfig: getNextAccount() },
-    data: getUpdateMinDeployUsdAmountInstructionDataDecoder().decode(
+    data: getUpdateEpochVaultIterationDurationInstructionDataDecoder().decode(
       instruction.data
     )
   };
 }
 
-// src/generated/instructions/updateStrikeTriggerModulus.ts
+// src/generated/instructions/updateMinDeployUsdAmount.ts
 import {
   combineCodec as combineCodec70,
   fixDecoderSize as fixDecoderSize53,
@@ -11387,8 +11414,8 @@ import {
   getBytesEncoder as getBytesEncoder75,
   getStructDecoder as getStructDecoder66,
   getStructEncoder as getStructEncoder66,
-  getU16Decoder as getU16Decoder21,
-  getU16Encoder as getU16Encoder21,
+  getU64Decoder as getU64Decoder42,
+  getU64Encoder as getU64Encoder42,
   SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS38,
   SolanaError as SolanaError38,
   transformEncoder as transformEncoder53
@@ -11396,37 +11423,37 @@ import {
 import {
   getAccountMetaFactory as getAccountMetaFactory38
 } from "@solana/program-client-core";
-var UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR = new Uint8Array([241, 172, 229, 62, 191, 163, 60, 186]);
-function getUpdateStrikeTriggerModulusDiscriminatorBytes() {
+var UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR = new Uint8Array([187, 108, 89, 178, 249, 101, 187, 33]);
+function getUpdateMinDeployUsdAmountDiscriminatorBytes() {
   return fixEncoderSize63(getBytesEncoder75(), 8).encode(
-    UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR
+    UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR
   );
 }
-function getUpdateStrikeTriggerModulusInstructionDataEncoder() {
+function getUpdateMinDeployUsdAmountInstructionDataEncoder() {
   return transformEncoder53(
     getStructEncoder66([
       ["discriminator", fixEncoderSize63(getBytesEncoder75(), 8)],
-      ["newModulus", getU16Encoder21()]
+      ["newMinDeployUsdAmount", getU64Encoder42()]
     ]),
     (value) => ({
       ...value,
-      discriminator: UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR
+      discriminator: UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR
     })
   );
 }
-function getUpdateStrikeTriggerModulusInstructionDataDecoder() {
+function getUpdateMinDeployUsdAmountInstructionDataDecoder() {
   return getStructDecoder66([
     ["discriminator", fixDecoderSize53(getBytesDecoder53(), 8)],
-    ["newModulus", getU16Decoder21()]
+    ["newMinDeployUsdAmount", getU64Decoder42()]
   ]);
 }
-function getUpdateStrikeTriggerModulusInstructionDataCodec() {
+function getUpdateMinDeployUsdAmountInstructionDataCodec() {
   return combineCodec70(
-    getUpdateStrikeTriggerModulusInstructionDataEncoder(),
-    getUpdateStrikeTriggerModulusInstructionDataDecoder()
+    getUpdateMinDeployUsdAmountInstructionDataEncoder(),
+    getUpdateMinDeployUsdAmountInstructionDataDecoder()
   );
 }
-async function getUpdateStrikeTriggerModulusInstructionAsync(input, config) {
+async function getUpdateMinDeployUsdAmountInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11443,13 +11470,13 @@ async function getUpdateStrikeTriggerModulusInstructionAsync(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateStrikeTriggerModulusInstructionDataEncoder().encode(
+    data: getUpdateMinDeployUsdAmountInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getUpdateStrikeTriggerModulusInstruction(input, config) {
+function getUpdateMinDeployUsdAmountInstruction(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11463,13 +11490,13 @@ function getUpdateStrikeTriggerModulusInstruction(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateStrikeTriggerModulusInstructionDataEncoder().encode(
+    data: getUpdateMinDeployUsdAmountInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseUpdateStrikeTriggerModulusInstruction(instruction) {
+function parseUpdateMinDeployUsdAmountInstruction(instruction) {
   if (instruction.accounts.length < 2) {
     throw new SolanaError38(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS38,
@@ -11488,13 +11515,13 @@ function parseUpdateStrikeTriggerModulusInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: { authority: getNextAccount(), satrushConfig: getNextAccount() },
-    data: getUpdateStrikeTriggerModulusInstructionDataDecoder().decode(
+    data: getUpdateMinDeployUsdAmountInstructionDataDecoder().decode(
       instruction.data
     )
   };
 }
 
-// src/generated/instructions/updateUnclaimedHashrateBps.ts
+// src/generated/instructions/updateStrikeTriggerModulus.ts
 import {
   combineCodec as combineCodec71,
   fixDecoderSize as fixDecoderSize54,
@@ -11503,8 +11530,8 @@ import {
   getBytesEncoder as getBytesEncoder76,
   getStructDecoder as getStructDecoder67,
   getStructEncoder as getStructEncoder67,
-  getU32Decoder as getU32Decoder32,
-  getU32Encoder as getU32Encoder32,
+  getU16Decoder as getU16Decoder21,
+  getU16Encoder as getU16Encoder21,
   SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS39,
   SolanaError as SolanaError39,
   transformEncoder as transformEncoder54
@@ -11512,37 +11539,37 @@ import {
 import {
   getAccountMetaFactory as getAccountMetaFactory39
 } from "@solana/program-client-core";
-var UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR = new Uint8Array([237, 38, 26, 14, 73, 161, 208, 157]);
-function getUpdateUnclaimedHashrateBpsDiscriminatorBytes() {
+var UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR = new Uint8Array([241, 172, 229, 62, 191, 163, 60, 186]);
+function getUpdateStrikeTriggerModulusDiscriminatorBytes() {
   return fixEncoderSize64(getBytesEncoder76(), 8).encode(
-    UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR
+    UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR
   );
 }
-function getUpdateUnclaimedHashrateBpsInstructionDataEncoder() {
+function getUpdateStrikeTriggerModulusInstructionDataEncoder() {
   return transformEncoder54(
     getStructEncoder67([
       ["discriminator", fixEncoderSize64(getBytesEncoder76(), 8)],
-      ["newUnclaimedHashrateBps", getU32Encoder32()]
+      ["newModulus", getU16Encoder21()]
     ]),
     (value) => ({
       ...value,
-      discriminator: UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR
+      discriminator: UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR
     })
   );
 }
-function getUpdateUnclaimedHashrateBpsInstructionDataDecoder() {
+function getUpdateStrikeTriggerModulusInstructionDataDecoder() {
   return getStructDecoder67([
     ["discriminator", fixDecoderSize54(getBytesDecoder54(), 8)],
-    ["newUnclaimedHashrateBps", getU32Decoder32()]
+    ["newModulus", getU16Decoder21()]
   ]);
 }
-function getUpdateUnclaimedHashrateBpsInstructionDataCodec() {
+function getUpdateStrikeTriggerModulusInstructionDataCodec() {
   return combineCodec71(
-    getUpdateUnclaimedHashrateBpsInstructionDataEncoder(),
-    getUpdateUnclaimedHashrateBpsInstructionDataDecoder()
+    getUpdateStrikeTriggerModulusInstructionDataEncoder(),
+    getUpdateStrikeTriggerModulusInstructionDataDecoder()
   );
 }
-async function getUpdateUnclaimedHashrateBpsInstructionAsync(input, config) {
+async function getUpdateStrikeTriggerModulusInstructionAsync(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11559,13 +11586,13 @@ async function getUpdateUnclaimedHashrateBpsInstructionAsync(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateUnclaimedHashrateBpsInstructionDataEncoder().encode(
+    data: getUpdateStrikeTriggerModulusInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function getUpdateUnclaimedHashrateBpsInstruction(input, config) {
+function getUpdateStrikeTriggerModulusInstruction(input, config) {
   const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: false },
@@ -11579,13 +11606,13 @@ function getUpdateUnclaimedHashrateBpsInstruction(input, config) {
       getAccountMeta("authority", accounts.authority),
       getAccountMeta("satrushConfig", accounts.satrushConfig)
     ],
-    data: getUpdateUnclaimedHashrateBpsInstructionDataEncoder().encode(
+    data: getUpdateStrikeTriggerModulusInstructionDataEncoder().encode(
       args
     ),
     programAddress
   });
 }
-function parseUpdateUnclaimedHashrateBpsInstruction(instruction) {
+function parseUpdateStrikeTriggerModulusInstruction(instruction) {
   if (instruction.accounts.length < 2) {
     throw new SolanaError39(
       SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS39,
@@ -11604,50 +11631,166 @@ function parseUpdateUnclaimedHashrateBpsInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: { authority: getNextAccount(), satrushConfig: getNextAccount() },
-    data: getUpdateUnclaimedHashrateBpsInstructionDataDecoder().decode(
+    data: getUpdateStrikeTriggerModulusInstructionDataDecoder().decode(
       instruction.data
     )
   };
 }
 
-// src/generated/instructions/withdrawProtocolFees.ts
+// src/generated/instructions/updateUnclaimedHashrateBps.ts
 import {
   combineCodec as combineCodec72,
   fixDecoderSize as fixDecoderSize55,
   fixEncoderSize as fixEncoderSize65,
-  getAddressEncoder as getAddressEncoder40,
   getBytesDecoder as getBytesDecoder55,
   getBytesEncoder as getBytesEncoder77,
-  getProgramDerivedAddress as getProgramDerivedAddress34,
   getStructDecoder as getStructDecoder68,
   getStructEncoder as getStructEncoder68,
+  getU32Decoder as getU32Decoder33,
+  getU32Encoder as getU32Encoder33,
   SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS40,
   SolanaError as SolanaError40,
   transformEncoder as transformEncoder55
 } from "@solana/kit";
 import {
-  getAccountMetaFactory as getAccountMetaFactory40,
+  getAccountMetaFactory as getAccountMetaFactory40
+} from "@solana/program-client-core";
+var UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR = new Uint8Array([237, 38, 26, 14, 73, 161, 208, 157]);
+function getUpdateUnclaimedHashrateBpsDiscriminatorBytes() {
+  return fixEncoderSize65(getBytesEncoder77(), 8).encode(
+    UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR
+  );
+}
+function getUpdateUnclaimedHashrateBpsInstructionDataEncoder() {
+  return transformEncoder55(
+    getStructEncoder68([
+      ["discriminator", fixEncoderSize65(getBytesEncoder77(), 8)],
+      ["newUnclaimedHashrateBps", getU32Encoder33()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: UPDATE_UNCLAIMED_HASHRATE_BPS_DISCRIMINATOR
+    })
+  );
+}
+function getUpdateUnclaimedHashrateBpsInstructionDataDecoder() {
+  return getStructDecoder68([
+    ["discriminator", fixDecoderSize55(getBytesDecoder55(), 8)],
+    ["newUnclaimedHashrateBps", getU32Decoder33()]
+  ]);
+}
+function getUpdateUnclaimedHashrateBpsInstructionDataCodec() {
+  return combineCodec72(
+    getUpdateUnclaimedHashrateBpsInstructionDataEncoder(),
+    getUpdateUnclaimedHashrateBpsInstructionDataDecoder()
+  );
+}
+async function getUpdateUnclaimedHashrateBpsInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    satrushConfig: { value: input.satrushConfig ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.satrushConfig.value) {
+    accounts.satrushConfig.value = await findSatrushConfigPda();
+  }
+  const getAccountMeta = getAccountMetaFactory40(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("satrushConfig", accounts.satrushConfig)
+    ],
+    data: getUpdateUnclaimedHashrateBpsInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getUpdateUnclaimedHashrateBpsInstruction(input, config) {
+  const programAddress = config?.programAddress ?? SATRUSH_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    satrushConfig: { value: input.satrushConfig ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = getAccountMetaFactory40(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("authority", accounts.authority),
+      getAccountMeta("satrushConfig", accounts.satrushConfig)
+    ],
+    data: getUpdateUnclaimedHashrateBpsInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseUpdateUnclaimedHashrateBpsInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new SolanaError40(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS40,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { authority: getNextAccount(), satrushConfig: getNextAccount() },
+    data: getUpdateUnclaimedHashrateBpsInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/generated/instructions/withdrawProtocolFees.ts
+import {
+  combineCodec as combineCodec73,
+  fixDecoderSize as fixDecoderSize56,
+  fixEncoderSize as fixEncoderSize66,
+  getAddressEncoder as getAddressEncoder40,
+  getBytesDecoder as getBytesDecoder56,
+  getBytesEncoder as getBytesEncoder78,
+  getProgramDerivedAddress as getProgramDerivedAddress34,
+  getStructDecoder as getStructDecoder69,
+  getStructEncoder as getStructEncoder69,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS as SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS41,
+  SolanaError as SolanaError41,
+  transformEncoder as transformEncoder56
+} from "@solana/kit";
+import {
+  getAccountMetaFactory as getAccountMetaFactory41,
   getAddressFromResolvedInstructionAccount as getAddressFromResolvedInstructionAccount24
 } from "@solana/program-client-core";
 var WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR = new Uint8Array([11, 68, 165, 98, 18, 208, 134, 73]);
 function getWithdrawProtocolFeesDiscriminatorBytes() {
-  return fixEncoderSize65(getBytesEncoder77(), 8).encode(
+  return fixEncoderSize66(getBytesEncoder78(), 8).encode(
     WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR
   );
 }
 function getWithdrawProtocolFeesInstructionDataEncoder() {
-  return transformEncoder55(
-    getStructEncoder68([["discriminator", fixEncoderSize65(getBytesEncoder77(), 8)]]),
+  return transformEncoder56(
+    getStructEncoder69([["discriminator", fixEncoderSize66(getBytesEncoder78(), 8)]]),
     (value) => ({ ...value, discriminator: WITHDRAW_PROTOCOL_FEES_DISCRIMINATOR })
   );
 }
 function getWithdrawProtocolFeesInstructionDataDecoder() {
-  return getStructDecoder68([
-    ["discriminator", fixDecoderSize55(getBytesDecoder55(), 8)]
+  return getStructDecoder69([
+    ["discriminator", fixDecoderSize56(getBytesDecoder56(), 8)]
   ]);
 }
 function getWithdrawProtocolFeesInstructionDataCodec() {
-  return combineCodec72(
+  return combineCodec73(
     getWithdrawProtocolFeesInstructionDataEncoder(),
     getWithdrawProtocolFeesInstructionDataDecoder()
   );
@@ -11695,7 +11838,7 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
             accounts.treasury.value
           )
         ),
-        getBytesEncoder77().encode(
+        getBytesEncoder78().encode(
           new Uint8Array([
             6,
             221,
@@ -11750,7 +11893,7 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
             accounts.treasury.value
           )
         ),
-        getBytesEncoder77().encode(
+        getBytesEncoder78().encode(
           new Uint8Array([
             6,
             221,
@@ -11805,7 +11948,7 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
             accounts.feeRecipient.value
           )
         ),
-        getBytesEncoder77().encode(
+        getBytesEncoder78().encode(
           new Uint8Array([
             6,
             221,
@@ -11860,7 +12003,7 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
             accounts.feeRecipient.value
           )
         ),
-        getBytesEncoder77().encode(
+        getBytesEncoder78().encode(
           new Uint8Array([
             6,
             221,
@@ -11914,7 +12057,7 @@ async function getWithdrawProtocolFeesInstructionAsync(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory40(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory41(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -11971,7 +12114,7 @@ function getWithdrawProtocolFeesInstruction(input, config) {
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
-  const getAccountMeta = getAccountMetaFactory40(programAddress, "programId");
+  const getAccountMeta = getAccountMetaFactory41(programAddress, "programId");
   return Object.freeze({
     accounts: [
       getAccountMeta("authority", accounts.authority),
@@ -11994,8 +12137,8 @@ function getWithdrawProtocolFeesInstruction(input, config) {
 }
 function parseWithdrawProtocolFeesInstruction(instruction) {
   if (instruction.accounts.length < 13) {
-    throw new SolanaError40(
-      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS40,
+    throw new SolanaError41(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS41,
       {
         actualAccountMetas: instruction.accounts.length,
         expectedAccountMetas: 13
@@ -12055,7 +12198,7 @@ function identifySatrushAccount(account) {
   const data = "data" in account ? account.data : account;
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([79, 48, 160, 63, 153, 132, 240, 56])
     ),
     0
@@ -12064,7 +12207,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([100, 209, 6, 66, 115, 53, 132, 9])
     ),
     0
@@ -12073,7 +12216,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([75, 243, 246, 41, 173, 130, 196, 91])
     ),
     0
@@ -12082,7 +12225,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([116, 108, 198, 176, 193, 190, 91, 125])
     ),
     0
@@ -12091,7 +12234,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([121, 238, 146, 107, 234, 24, 227, 31])
     ),
     0
@@ -12100,7 +12243,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([223, 113, 15, 54, 123, 122, 140, 100])
     ),
     0
@@ -12109,7 +12252,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([134, 90, 53, 34, 240, 221, 175, 212])
     ),
     0
@@ -12118,7 +12261,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([255, 64, 185, 130, 97, 37, 230, 219])
     ),
     0
@@ -12127,7 +12270,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([190, 205, 75, 222, 220, 249, 43, 126])
     ),
     0
@@ -12136,7 +12279,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([16, 128, 211, 70, 213, 109, 108, 216])
     ),
     0
@@ -12145,7 +12288,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([209, 64, 180, 169, 40, 181, 110, 236])
     ),
     0
@@ -12154,7 +12297,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([87, 127, 165, 51, 73, 78, 116, 174])
     ),
     0
@@ -12163,7 +12306,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([113, 169, 164, 118, 148, 217, 160, 200])
     ),
     0
@@ -12172,7 +12315,7 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([97, 10, 251, 68, 215, 103, 124, 183])
     ),
     0
@@ -12181,14 +12324,14 @@ function identifySatrushAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([238, 239, 123, 238, 89, 1, 168, 253])
     ),
     0
   )) {
     return 14 /* Treasury */;
   }
-  throw new SolanaError41(
+  throw new SolanaError42(
     SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
     { accountData: data, programName: "satrush" }
   );
@@ -12228,19 +12371,20 @@ var SatrushInstruction = /* @__PURE__ */ ((SatrushInstruction2) => {
   SatrushInstruction2[SatrushInstruction2["TriggerEpochDraw"] = 31] = "TriggerEpochDraw";
   SatrushInstruction2[SatrushInstruction2["TriggerOneBtcDraw"] = 32] = "TriggerOneBtcDraw";
   SatrushInstruction2[SatrushInstruction2["UpdateBoardRoundDuration"] = 33] = "UpdateBoardRoundDuration";
-  SatrushInstruction2[SatrushInstruction2["UpdateDeploymentSettleGraceDuration"] = 34] = "UpdateDeploymentSettleGraceDuration";
-  SatrushInstruction2[SatrushInstruction2["UpdateEpochVaultIterationDuration"] = 35] = "UpdateEpochVaultIterationDuration";
-  SatrushInstruction2[SatrushInstruction2["UpdateMinDeployUsdAmount"] = 36] = "UpdateMinDeployUsdAmount";
-  SatrushInstruction2[SatrushInstruction2["UpdateStrikeTriggerModulus"] = 37] = "UpdateStrikeTriggerModulus";
-  SatrushInstruction2[SatrushInstruction2["UpdateUnclaimedHashrateBps"] = 38] = "UpdateUnclaimedHashrateBps";
-  SatrushInstruction2[SatrushInstruction2["WithdrawProtocolFees"] = 39] = "WithdrawProtocolFees";
+  SatrushInstruction2[SatrushInstruction2["UpdateDeployFees"] = 34] = "UpdateDeployFees";
+  SatrushInstruction2[SatrushInstruction2["UpdateDeploymentSettleGraceDuration"] = 35] = "UpdateDeploymentSettleGraceDuration";
+  SatrushInstruction2[SatrushInstruction2["UpdateEpochVaultIterationDuration"] = 36] = "UpdateEpochVaultIterationDuration";
+  SatrushInstruction2[SatrushInstruction2["UpdateMinDeployUsdAmount"] = 37] = "UpdateMinDeployUsdAmount";
+  SatrushInstruction2[SatrushInstruction2["UpdateStrikeTriggerModulus"] = 38] = "UpdateStrikeTriggerModulus";
+  SatrushInstruction2[SatrushInstruction2["UpdateUnclaimedHashrateBps"] = 39] = "UpdateUnclaimedHashrateBps";
+  SatrushInstruction2[SatrushInstruction2["WithdrawProtocolFees"] = 40] = "WithdrawProtocolFees";
   return SatrushInstruction2;
 })(SatrushInstruction || {});
 function identifySatrushInstruction(instruction) {
   const data = "data" in instruction ? instruction.data : instruction;
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([90, 201, 98, 189, 106, 249, 86, 109])
     ),
     0
@@ -12249,7 +12393,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([4, 48, 106, 230, 146, 124, 140, 167])
     ),
     0
@@ -12258,7 +12402,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([87, 135, 14, 43, 190, 79, 45, 212])
     ),
     0
@@ -12267,7 +12411,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([226, 196, 170, 104, 125, 21, 190, 232])
     ),
     0
@@ -12276,7 +12420,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([53, 168, 61, 211, 206, 81, 133, 175])
     ),
     0
@@ -12285,7 +12429,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([196, 77, 168, 181, 6, 119, 249, 154])
     ),
     0
@@ -12294,7 +12438,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([241, 89, 98, 124, 223, 205, 215, 104])
     ),
     0
@@ -12303,7 +12447,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([27, 23, 127, 47, 147, 184, 239, 190])
     ),
     0
@@ -12312,7 +12456,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([80, 74, 10, 29, 63, 106, 63, 192])
     ),
     0
@@ -12321,7 +12465,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([11, 123, 237, 176, 25, 240, 59, 135])
     ),
     0
@@ -12330,7 +12474,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([181, 42, 174, 200, 192, 21, 27, 187])
     ),
     0
@@ -12339,7 +12483,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([251, 62, 143, 106, 218, 1, 162, 181])
     ),
     0
@@ -12348,7 +12492,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([149, 14, 81, 88, 230, 226, 234, 37])
     ),
     0
@@ -12357,7 +12501,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([81, 129, 130, 38, 99, 204, 224, 177])
     ),
     0
@@ -12366,7 +12510,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([69, 146, 29, 218, 228, 29, 229, 241])
     ),
     0
@@ -12375,7 +12519,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([156, 160, 69, 94, 108, 6, 145, 211])
     ),
     0
@@ -12384,7 +12528,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([195, 44, 245, 180, 58, 206, 203, 229])
     ),
     0
@@ -12393,7 +12537,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([96, 175, 39, 171, 158, 44, 117, 18])
     ),
     0
@@ -12402,7 +12546,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([159, 29, 126, 216, 29, 240, 141, 61])
     ),
     0
@@ -12411,7 +12555,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([254, 98, 217, 51, 25, 88, 140, 45])
     ),
     0
@@ -12420,7 +12564,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([193, 31, 240, 159, 30, 224, 157, 85])
     ),
     0
@@ -12429,7 +12573,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([212, 191, 100, 136, 18, 213, 42, 72])
     ),
     0
@@ -12438,7 +12582,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([3, 245, 202, 88, 161, 29, 51, 141])
     ),
     0
@@ -12447,7 +12591,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([89, 228, 101, 114, 103, 98, 126, 229])
     ),
     0
@@ -12456,7 +12600,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([222, 36, 211, 175, 4, 220, 2, 251])
     ),
     0
@@ -12465,7 +12609,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([249, 111, 122, 103, 93, 86, 76, 198])
     ),
     0
@@ -12474,7 +12618,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([82, 124, 95, 215, 213, 107, 134, 122])
     ),
     0
@@ -12483,7 +12627,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([61, 147, 13, 247, 164, 34, 14, 57])
     ),
     0
@@ -12492,7 +12636,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([86, 168, 42, 98, 2, 164, 250, 185])
     ),
     0
@@ -12501,7 +12645,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([129, 112, 9, 43, 91, 154, 157, 135])
     ),
     0
@@ -12510,7 +12654,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([1, 96, 199, 199, 107, 118, 193, 87])
     ),
     0
@@ -12519,7 +12663,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([93, 12, 139, 55, 235, 88, 37, 117])
     ),
     0
@@ -12528,7 +12672,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([252, 210, 238, 28, 169, 118, 28, 11])
     ),
     0
@@ -12537,7 +12681,7 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([12, 130, 188, 85, 167, 187, 204, 183])
     ),
     0
@@ -12546,59 +12690,68 @@ function identifySatrushInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
+      new Uint8Array([0, 170, 26, 215, 156, 171, 22, 68])
+    ),
+    0
+  )) {
+    return 34 /* UpdateDeployFees */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([2, 212, 246, 89, 139, 64, 104, 74])
     ),
     0
   )) {
-    return 34 /* UpdateDeploymentSettleGraceDuration */;
+    return 35 /* UpdateDeploymentSettleGraceDuration */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([171, 103, 59, 229, 174, 188, 210, 121])
     ),
     0
   )) {
-    return 35 /* UpdateEpochVaultIterationDuration */;
+    return 36 /* UpdateEpochVaultIterationDuration */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([187, 108, 89, 178, 249, 101, 187, 33])
     ),
     0
   )) {
-    return 36 /* UpdateMinDeployUsdAmount */;
+    return 37 /* UpdateMinDeployUsdAmount */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([241, 172, 229, 62, 191, 163, 60, 186])
     ),
     0
   )) {
-    return 37 /* UpdateStrikeTriggerModulus */;
+    return 38 /* UpdateStrikeTriggerModulus */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([237, 38, 26, 14, 73, 161, 208, 157])
     ),
     0
   )) {
-    return 38 /* UpdateUnclaimedHashrateBps */;
+    return 39 /* UpdateUnclaimedHashrateBps */;
   }
   if (containsBytes(
     data,
-    fixEncoderSize66(getBytesEncoder78(), 8).encode(
+    fixEncoderSize67(getBytesEncoder79(), 8).encode(
       new Uint8Array([11, 68, 165, 98, 18, 208, 134, 73])
     ),
     0
   )) {
-    return 39 /* WithdrawProtocolFees */;
+    return 40 /* WithdrawProtocolFees */;
   }
-  throw new SolanaError41(
+  throw new SolanaError42(
     SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
     { instructionData: data, programName: "satrush" }
   );
@@ -12844,50 +12997,57 @@ function parseSatrushInstruction(instruction) {
         ...parseUpdateBoardRoundDurationInstruction(instruction)
       };
     }
-    case 34 /* UpdateDeploymentSettleGraceDuration */: {
+    case 34 /* UpdateDeployFees */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 34 /* UpdateDeploymentSettleGraceDuration */,
+        instructionType: 34 /* UpdateDeployFees */,
+        ...parseUpdateDeployFeesInstruction(instruction)
+      };
+    }
+    case 35 /* UpdateDeploymentSettleGraceDuration */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 35 /* UpdateDeploymentSettleGraceDuration */,
         ...parseUpdateDeploymentSettleGraceDurationInstruction(instruction)
       };
     }
-    case 35 /* UpdateEpochVaultIterationDuration */: {
+    case 36 /* UpdateEpochVaultIterationDuration */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 35 /* UpdateEpochVaultIterationDuration */,
+        instructionType: 36 /* UpdateEpochVaultIterationDuration */,
         ...parseUpdateEpochVaultIterationDurationInstruction(instruction)
       };
     }
-    case 36 /* UpdateMinDeployUsdAmount */: {
+    case 37 /* UpdateMinDeployUsdAmount */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 36 /* UpdateMinDeployUsdAmount */,
+        instructionType: 37 /* UpdateMinDeployUsdAmount */,
         ...parseUpdateMinDeployUsdAmountInstruction(instruction)
       };
     }
-    case 37 /* UpdateStrikeTriggerModulus */: {
+    case 38 /* UpdateStrikeTriggerModulus */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 37 /* UpdateStrikeTriggerModulus */,
+        instructionType: 38 /* UpdateStrikeTriggerModulus */,
         ...parseUpdateStrikeTriggerModulusInstruction(instruction)
       };
     }
-    case 38 /* UpdateUnclaimedHashrateBps */: {
+    case 39 /* UpdateUnclaimedHashrateBps */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 38 /* UpdateUnclaimedHashrateBps */,
+        instructionType: 39 /* UpdateUnclaimedHashrateBps */,
         ...parseUpdateUnclaimedHashrateBpsInstruction(instruction)
       };
     }
-    case 39 /* WithdrawProtocolFees */: {
+    case 40 /* WithdrawProtocolFees */: {
       assertIsInstructionWithAccounts(instruction);
       return {
-        instructionType: 39 /* WithdrawProtocolFees */,
+        instructionType: 40 /* WithdrawProtocolFees */,
         ...parseWithdrawProtocolFeesInstruction(instruction)
       };
     }
     default:
-      throw new SolanaError41(
+      throw new SolanaError42(
         SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
         { instructionType, programName: "satrush" }
       );
@@ -12982,7 +13142,7 @@ function satrushProgram() {
           ),
           closeOneBtcTicket: (input) => addSelfPlanAndSendFunctions(
             client,
-            getCloseOneBtcTicketInstruction(input)
+            getCloseOneBtcTicketInstructionAsync(input)
           ),
           closeRound: (input) => addSelfPlanAndSendFunctions(
             client,
@@ -13072,6 +13232,10 @@ function satrushProgram() {
             client,
             getUpdateBoardRoundDurationInstructionAsync(input)
           ),
+          updateDeployFees: (input) => addSelfPlanAndSendFunctions(
+            client,
+            getUpdateDeployFeesInstructionAsync(input)
+          ),
           updateDeploymentSettleGraceDuration: (input) => addSelfPlanAndSendFunctions(
             client,
             getUpdateDeploymentSettleGraceDurationInstructionAsync(input)
@@ -13172,6 +13336,8 @@ var SATRUSH_ERROR__INVALID_EPOCH_ITERATION_DURATION = 6048;
 var SATRUSH_ERROR__INVALID_UNCLAIMED_HASHRATE_BPS = 6049;
 var SATRUSH_ERROR__INVALID_STRIKE_TRIGGER_MODULUS = 6050;
 var SATRUSH_ERROR__INVALID_SWAP_BPS = 6051;
+var SATRUSH_ERROR__INVALID_MINT_DATA = 6052;
+var SATRUSH_ERROR__INVALID_DEPLOY_FEES = 6053;
 var satrushErrorMessages;
 if (process.env["NODE_ENV"] !== "production") {
   satrushErrorMessages = {
@@ -13196,9 +13362,11 @@ if (process.env["NODE_ENV"] !== "production") {
     [SATRUSH_ERROR__INVALID_AUTOMATION_AMOUNT]: `Automation amount must be greater than zero`,
     [SATRUSH_ERROR__INVALID_AUTOMATION_STRATEGY_MASK]: `Selection mask does not match the automation strategy`,
     [SATRUSH_ERROR__INVALID_CLAIM_AMOUNT]: `Claim amount must be greater than zero`,
+    [SATRUSH_ERROR__INVALID_DEPLOY_FEES]: `Deploy fee legs must each be at least 1 bps and sum to exactly 800 bps`,
     [SATRUSH_ERROR__INVALID_DEPLOYMENT_AMOUNT]: `Deployment amount must be greater than zero`,
     [SATRUSH_ERROR__INVALID_ENTROPY]: `Entropy value is invalid`,
     [SATRUSH_ERROR__INVALID_EPOCH_ITERATION_DURATION]: `Epoch iteration duration must be greater than zero`,
+    [SATRUSH_ERROR__INVALID_MINT_DATA]: `Mint account data is too short to contain the decimals field`,
     [SATRUSH_ERROR__INVALID_ROUND_DURATION]: `Round duration must be greater than zero`,
     [SATRUSH_ERROR__INVALID_ROUND_ID]: `Invalid round id supplied to create round`,
     [SATRUSH_ERROR__INVALID_SELECTION_MASK]: `Selection mask must pick between 1 and 21 tiles within the 21-bit range`,
@@ -13256,7 +13424,7 @@ import {
   getAddressEncoder as getAddressEncoder41,
   getProgramDerivedAddress as getProgramDerivedAddress35,
   getU16Encoder as getU16Encoder22,
-  getU32Encoder as getU32Encoder33
+  getU32Encoder as getU32Encoder34
 } from "@solana/kit";
 async function getSatrushConfigAddress() {
   return await getProgramDerivedAddress35({
@@ -13279,7 +13447,7 @@ async function getBoardAddress() {
 async function getRoundAddress(roundId) {
   return await getProgramDerivedAddress35({
     programAddress: SATRUSH_PROGRAM_ADDRESS,
-    seeds: ["round", getU32Encoder33().encode(roundId)]
+    seeds: ["round", getU32Encoder34().encode(roundId)]
   });
 }
 async function getPublicDeploymentAddress(authority, roundId) {
@@ -13288,7 +13456,7 @@ async function getPublicDeploymentAddress(authority, roundId) {
     seeds: [
       "public_deployment",
       getAddressEncoder41().encode(authority),
-      getU32Encoder33().encode(roundId)
+      getU32Encoder34().encode(roundId)
     ]
   });
 }
@@ -13313,7 +13481,7 @@ async function getEpochVaultAddress() {
 async function getEpochVaultIterationAddress(iterationId) {
   return await getProgramDerivedAddress35({
     programAddress: SATRUSH_PROGRAM_ADDRESS,
-    seeds: ["epoch_vault_iteration", getU32Encoder33().encode(iterationId)]
+    seeds: ["epoch_vault_iteration", getU32Encoder34().encode(iterationId)]
   });
 }
 async function getEpochVaultEntryAddress(iterationId, authority) {
@@ -13321,7 +13489,7 @@ async function getEpochVaultEntryAddress(iterationId, authority) {
     programAddress: SATRUSH_PROGRAM_ADDRESS,
     seeds: [
       "epoch_vault_entry",
-      getU32Encoder33().encode(iterationId),
+      getU32Encoder34().encode(iterationId),
       getAddressEncoder41().encode(authority)
     ]
   });
@@ -13331,7 +13499,7 @@ async function getEpochVaultPageAddress(iterationId, pageIndex) {
     programAddress: SATRUSH_PROGRAM_ADDRESS,
     seeds: [
       "epoch_vault_page",
-      getU32Encoder33().encode(iterationId),
+      getU32Encoder34().encode(iterationId),
       getU16Encoder22().encode(pageIndex)
     ]
   });
@@ -13345,7 +13513,7 @@ async function getOneBtcVaultAddress() {
 async function getOneBtcVaultIterationAddress(iterationId) {
   return await getProgramDerivedAddress35({
     programAddress: SATRUSH_PROGRAM_ADDRESS,
-    seeds: ["one_btc_vault_iteration", getU32Encoder33().encode(iterationId)]
+    seeds: ["one_btc_vault_iteration", getU32Encoder34().encode(iterationId)]
   });
 }
 async function getTreasuryAddress() {
@@ -13512,6 +13680,8 @@ var HASHRATE_DECIMALS = 2;
 var HASHRATE_PER_TICKET = 100n;
 var LOYALTY_WEIGHT = 1n;
 var SKILL_WEIGHT = 1n;
+var STRIKE_BOOST_ROUNDS = 240;
+var STRIKE_BOOST_HASHRATE_MULTIPLIER = 2n;
 function getHashrateUiAmount(hashrate) {
   assertU64(hashrate, "hashrate");
   const whole = hashrate / HASHRATE_PER_TICKET;
@@ -13527,9 +13697,10 @@ var ZERO_REWARD = {
   skillPoints: 0n,
   total: 0n
 };
-function hashrateReward(stake, streak, covered, totalTiles, usdUnit) {
+function hashrateReward(stake, streak, covered, totalTiles, usdUnit, hashrateMultiplier = 1n) {
   assertU64(stake, "stake");
   assertU64(usdUnit, "usdUnit");
+  assertU64(hashrateMultiplier, "hashrateMultiplier");
   if (stake === 0n || covered === 0) {
     return ZERO_REWARD;
   }
@@ -13537,9 +13708,9 @@ function hashrateReward(stake, streak, covered, totalTiles, usdUnit) {
   const denom = coveredBig * usdUnit;
   const skillNum = stake * (SKILL_WEIGHT * BigInt(totalTiles));
   const loyaltyNum = stake * (LOYALTY_WEIGHT * BigInt(streak) * coveredBig);
-  const total = (loyaltyNum + skillNum) / denom;
+  const total = (loyaltyNum + skillNum) / denom * hashrateMultiplier;
   assertU64(total, "hashrate reward total");
-  const skillPoints = skillNum / denom;
+  const skillPoints = skillNum / denom * hashrateMultiplier;
   const loyaltyPoints = total - skillPoints;
   return { loyaltyPoints, skillPoints, total };
 }
@@ -13681,8 +13852,10 @@ export {
   SATRUSH_ERROR__INVALID_AUTOMATION_STRATEGY_MASK,
   SATRUSH_ERROR__INVALID_CLAIM_AMOUNT,
   SATRUSH_ERROR__INVALID_DEPLOYMENT_AMOUNT,
+  SATRUSH_ERROR__INVALID_DEPLOY_FEES,
   SATRUSH_ERROR__INVALID_ENTROPY,
   SATRUSH_ERROR__INVALID_EPOCH_ITERATION_DURATION,
+  SATRUSH_ERROR__INVALID_MINT_DATA,
   SATRUSH_ERROR__INVALID_ROUND_DURATION,
   SATRUSH_ERROR__INVALID_ROUND_ID,
   SATRUSH_ERROR__INVALID_SELECTION_MASK,
@@ -13718,6 +13891,8 @@ export {
   SETTLE_DEPLOY_PUBLIC_DISCRIMINATOR,
   SHARE_OFFSET,
   SKILL_WEIGHT,
+  STRIKE_BOOST_HASHRATE_MULTIPLIER,
+  STRIKE_BOOST_ROUNDS,
   SWAP_EPOCH_STAKE_DISCRIMINATOR,
   SWAP_ONE_BTC_STAKE_DISCRIMINATOR,
   SWAP_ROUND_STAKE_DISCRIMINATOR,
@@ -13731,6 +13906,7 @@ export {
   TRIGGER_ONE_BTC_DRAW_DISCRIMINATOR,
   UPDATE_BOARD_ROUND_DURATION_DISCRIMINATOR,
   UPDATE_DEPLOYMENT_SETTLE_GRACE_DURATION_DISCRIMINATOR,
+  UPDATE_DEPLOY_FEES_DISCRIMINATOR,
   UPDATE_EPOCH_VAULT_ITERATION_DURATION_DISCRIMINATOR,
   UPDATE_MIN_DEPLOY_USD_AMOUNT_DISCRIMINATOR,
   UPDATE_STRIKE_TRIGGER_MODULUS_DISCRIMINATOR,
@@ -13909,6 +14085,7 @@ export {
   getCloseOneBtcIterationInstructionDataEncoder,
   getCloseOneBtcTicketDiscriminatorBytes,
   getCloseOneBtcTicketInstruction,
+  getCloseOneBtcTicketInstructionAsync,
   getCloseOneBtcTicketInstructionDataCodec,
   getCloseOneBtcTicketInstructionDataDecoder,
   getCloseOneBtcTicketInstructionDataEncoder,
@@ -14174,6 +14351,12 @@ export {
   getUpdateBoardRoundDurationInstructionDataCodec,
   getUpdateBoardRoundDurationInstructionDataDecoder,
   getUpdateBoardRoundDurationInstructionDataEncoder,
+  getUpdateDeployFeesDiscriminatorBytes,
+  getUpdateDeployFeesInstruction,
+  getUpdateDeployFeesInstructionAsync,
+  getUpdateDeployFeesInstructionDataCodec,
+  getUpdateDeployFeesInstructionDataDecoder,
+  getUpdateDeployFeesInstructionDataEncoder,
   getUpdateDeploymentSettleGraceDurationDiscriminatorBytes,
   getUpdateDeploymentSettleGraceDurationInstruction,
   getUpdateDeploymentSettleGraceDurationInstructionAsync,
@@ -14253,6 +14436,7 @@ export {
   parseTriggerEpochDrawInstruction,
   parseTriggerOneBtcDrawInstruction,
   parseUpdateBoardRoundDurationInstruction,
+  parseUpdateDeployFeesInstruction,
   parseUpdateDeploymentSettleGraceDurationInstruction,
   parseUpdateEpochVaultIterationDurationInstruction,
   parseUpdateMinDeployUsdAmountInstruction,