@crypticdot/defituna-client 3.2.6 → 3.2.7

package/dist/index.mjs

@@ -993,28 +993,27 @@ var TunaInstruction = /* @__PURE__ */ ((TunaInstruction2) => {
   TunaInstruction2[TunaInstruction2["OpenLendingPosition"] = 32] = "OpenLendingPosition";
   TunaInstruction2[TunaInstruction2["OpenTunaLpPositionFusion"] = 33] = "OpenTunaLpPositionFusion";
   TunaInstruction2[TunaInstruction2["OpenTunaLpPositionOrca"] = 34] = "OpenTunaLpPositionOrca";
-  TunaInstruction2[TunaInstruction2["OpenTunaSpotPositionFusion"] = 35] = "OpenTunaSpotPositionFusion";
-  TunaInstruction2[TunaInstruction2["OpenTunaSpotPositionOrca"] = 36] = "OpenTunaSpotPositionOrca";
-  TunaInstruction2[TunaInstruction2["RebalanceTunaLpPositionFusion"] = 37] = "RebalanceTunaLpPositionFusion";
-  TunaInstruction2[TunaInstruction2["RebalanceTunaLpPositionOrca"] = 38] = "RebalanceTunaLpPositionOrca";
-  TunaInstruction2[TunaInstruction2["RepayBadDebt"] = 39] = "RepayBadDebt";
-  TunaInstruction2[TunaInstruction2["RepayTunaLpPositionDebt"] = 40] = "RepayTunaLpPositionDebt";
-  TunaInstruction2[TunaInstruction2["ResetTunaSpotPosition"] = 41] = "ResetTunaSpotPosition";
-  TunaInstruction2[TunaInstruction2["SetAdminAuthority"] = 42] = "SetAdminAuthority";
-  TunaInstruction2[TunaInstruction2["SetDefaultMaxPercentageOfLeftovers"] = 43] = "SetDefaultMaxPercentageOfLeftovers";
-  TunaInstruction2[TunaInstruction2["SetDefaultMaxSwapSlippage"] = 44] = "SetDefaultMaxSwapSlippage";
-  TunaInstruction2[TunaInstruction2["SetDefaultOraclePriceDeviationThreshold"] = 45] = "SetDefaultOraclePriceDeviationThreshold";
-  TunaInstruction2[TunaInstruction2["SetFeeRecipient"] = 46] = "SetFeeRecipient";
-  TunaInstruction2[TunaInstruction2["SetLiquidatorAuthority"] = 47] = "SetLiquidatorAuthority";
-  TunaInstruction2[TunaInstruction2["SetOwnerAuthority"] = 48] = "SetOwnerAuthority";
-  TunaInstruction2[TunaInstruction2["SetSuspendedState"] = 49] = "SetSuspendedState";
-  TunaInstruction2[TunaInstruction2["SetTunaLpPositionFlags"] = 50] = "SetTunaLpPositionFlags";
-  TunaInstruction2[TunaInstruction2["SetTunaLpPositionLimitOrders"] = 51] = "SetTunaLpPositionLimitOrders";
-  TunaInstruction2[TunaInstruction2["SetTunaLpPositionRebalanceThreshold"] = 52] = "SetTunaLpPositionRebalanceThreshold";
-  TunaInstruction2[TunaInstruction2["SetTunaSpotPositionLimitOrders"] = 53] = "SetTunaSpotPositionLimitOrders";
-  TunaInstruction2[TunaInstruction2["UpdateMarket"] = 54] = "UpdateMarket";
-  TunaInstruction2[TunaInstruction2["UpdateVault"] = 55] = "UpdateVault";
-  TunaInstruction2[TunaInstruction2["Withdraw"] = 56] = "Withdraw";
+  TunaInstruction2[TunaInstruction2["OpenTunaSpotPosition"] = 35] = "OpenTunaSpotPosition";
+  TunaInstruction2[TunaInstruction2["RebalanceTunaLpPositionFusion"] = 36] = "RebalanceTunaLpPositionFusion";
+  TunaInstruction2[TunaInstruction2["RebalanceTunaLpPositionOrca"] = 37] = "RebalanceTunaLpPositionOrca";
+  TunaInstruction2[TunaInstruction2["RepayBadDebt"] = 38] = "RepayBadDebt";
+  TunaInstruction2[TunaInstruction2["RepayTunaLpPositionDebt"] = 39] = "RepayTunaLpPositionDebt";
+  TunaInstruction2[TunaInstruction2["ResetTunaSpotPosition"] = 40] = "ResetTunaSpotPosition";
+  TunaInstruction2[TunaInstruction2["SetAdminAuthority"] = 41] = "SetAdminAuthority";
+  TunaInstruction2[TunaInstruction2["SetDefaultMaxPercentageOfLeftovers"] = 42] = "SetDefaultMaxPercentageOfLeftovers";
+  TunaInstruction2[TunaInstruction2["SetDefaultMaxSwapSlippage"] = 43] = "SetDefaultMaxSwapSlippage";
+  TunaInstruction2[TunaInstruction2["SetDefaultOraclePriceDeviationThreshold"] = 44] = "SetDefaultOraclePriceDeviationThreshold";
+  TunaInstruction2[TunaInstruction2["SetFeeRecipient"] = 45] = "SetFeeRecipient";
+  TunaInstruction2[TunaInstruction2["SetLiquidatorAuthority"] = 46] = "SetLiquidatorAuthority";
+  TunaInstruction2[TunaInstruction2["SetOwnerAuthority"] = 47] = "SetOwnerAuthority";
+  TunaInstruction2[TunaInstruction2["SetSuspendedState"] = 48] = "SetSuspendedState";
+  TunaInstruction2[TunaInstruction2["SetTunaLpPositionFlags"] = 49] = "SetTunaLpPositionFlags";
+  TunaInstruction2[TunaInstruction2["SetTunaLpPositionLimitOrders"] = 50] = "SetTunaLpPositionLimitOrders";
+  TunaInstruction2[TunaInstruction2["SetTunaLpPositionRebalanceThreshold"] = 51] = "SetTunaLpPositionRebalanceThreshold";
+  TunaInstruction2[TunaInstruction2["SetTunaSpotPositionLimitOrders"] = 52] = "SetTunaSpotPositionLimitOrders";
+  TunaInstruction2[TunaInstruction2["UpdateMarket"] = 53] = "UpdateMarket";
+  TunaInstruction2[TunaInstruction2["UpdateVault"] = 54] = "UpdateVault";
+  TunaInstruction2[TunaInstruction2["Withdraw"] = 55] = "Withdraw";
   return TunaInstruction2;
 })(TunaInstruction || {});
 function identifyTunaInstruction(instruction) {
@@ -1337,20 +1336,11 @@ function identifyTunaInstruction(instruction) {
   if (containsBytes(
     data,
     fixEncoderSize7(getBytesEncoder7(), 8).encode(
-      new Uint8Array([110, 65, 149, 32, 32, 51, 135, 243])
+      new Uint8Array([87, 208, 173, 48, 231, 62, 210, 220])
     ),
     0
   )) {
-    return 35 /* OpenTunaSpotPositionFusion */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize7(getBytesEncoder7(), 8).encode(
-      new Uint8Array([90, 70, 21, 186, 147, 80, 191, 94])
-    ),
-    0
-  )) {
-    return 36 /* OpenTunaSpotPositionOrca */;
+    return 35 /* OpenTunaSpotPosition */;
   }
   if (containsBytes(
     data,
@@ -1359,7 +1349,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 37 /* RebalanceTunaLpPositionFusion */;
+    return 36 /* RebalanceTunaLpPositionFusion */;
   }
   if (containsBytes(
     data,
@@ -1368,7 +1358,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 38 /* RebalanceTunaLpPositionOrca */;
+    return 37 /* RebalanceTunaLpPositionOrca */;
   }
   if (containsBytes(
     data,
@@ -1377,7 +1367,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 39 /* RepayBadDebt */;
+    return 38 /* RepayBadDebt */;
   }
   if (containsBytes(
     data,
@@ -1386,7 +1376,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 40 /* RepayTunaLpPositionDebt */;
+    return 39 /* RepayTunaLpPositionDebt */;
   }
   if (containsBytes(
     data,
@@ -1395,7 +1385,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 41 /* ResetTunaSpotPosition */;
+    return 40 /* ResetTunaSpotPosition */;
   }
   if (containsBytes(
     data,
@@ -1404,7 +1394,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 42 /* SetAdminAuthority */;
+    return 41 /* SetAdminAuthority */;
   }
   if (containsBytes(
     data,
@@ -1413,7 +1403,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 43 /* SetDefaultMaxPercentageOfLeftovers */;
+    return 42 /* SetDefaultMaxPercentageOfLeftovers */;
   }
   if (containsBytes(
     data,
@@ -1422,7 +1412,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 44 /* SetDefaultMaxSwapSlippage */;
+    return 43 /* SetDefaultMaxSwapSlippage */;
   }
   if (containsBytes(
     data,
@@ -1431,7 +1421,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 45 /* SetDefaultOraclePriceDeviationThreshold */;
+    return 44 /* SetDefaultOraclePriceDeviationThreshold */;
   }
   if (containsBytes(
     data,
@@ -1440,7 +1430,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 46 /* SetFeeRecipient */;
+    return 45 /* SetFeeRecipient */;
   }
   if (containsBytes(
     data,
@@ -1449,7 +1439,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 47 /* SetLiquidatorAuthority */;
+    return 46 /* SetLiquidatorAuthority */;
   }
   if (containsBytes(
     data,
@@ -1458,7 +1448,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 48 /* SetOwnerAuthority */;
+    return 47 /* SetOwnerAuthority */;
   }
   if (containsBytes(
     data,
@@ -1467,7 +1457,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 49 /* SetSuspendedState */;
+    return 48 /* SetSuspendedState */;
   }
   if (containsBytes(
     data,
@@ -1476,7 +1466,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 50 /* SetTunaLpPositionFlags */;
+    return 49 /* SetTunaLpPositionFlags */;
   }
   if (containsBytes(
     data,
@@ -1485,7 +1475,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 51 /* SetTunaLpPositionLimitOrders */;
+    return 50 /* SetTunaLpPositionLimitOrders */;
   }
   if (containsBytes(
     data,
@@ -1494,7 +1484,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 52 /* SetTunaLpPositionRebalanceThreshold */;
+    return 51 /* SetTunaLpPositionRebalanceThreshold */;
   }
   if (containsBytes(
     data,
@@ -1503,7 +1493,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 53 /* SetTunaSpotPositionLimitOrders */;
+    return 52 /* SetTunaSpotPositionLimitOrders */;
   }
   if (containsBytes(
     data,
@@ -1512,7 +1502,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 54 /* UpdateMarket */;
+    return 53 /* UpdateMarket */;
   }
   if (containsBytes(
     data,
@@ -1521,7 +1511,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 55 /* UpdateVault */;
+    return 54 /* UpdateVault */;
   }
   if (containsBytes(
     data,
@@ -1530,7 +1520,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 56 /* Withdraw */;
+    return 55 /* Withdraw */;
   }
   throw new Error(
     "The provided instruction could not be identified as a tuna instruction."
@@ -1605,6 +1595,7 @@ var TUNA_ERROR__INCORRECT_SWAP_INPUT_AMOUNT = 6063;
 var TUNA_ERROR__INSUFFICIENT_SWAP_OUTPUT_AMOUNT = 6064;
 var TUNA_ERROR__ACCOUNT_NOT_INITIALIZED = 6065;
 var TUNA_ERROR__INVALID_ACCOUNT_DISCRIMINATOR = 6066;
+var TUNA_ERROR__INVALID_POOL = 6067;
 var tunaErrorMessages;
 if (process.env.NODE_ENV !== "production") {
   tunaErrorMessages = {
@@ -1621,6 +1612,7 @@ if (process.env.NODE_ENV !== "production") {
     [TUNA_ERROR__INVALID_INSTRUCTION_ARGUMENTS]: `Invalid instruction arguments`,
     [TUNA_ERROR__INVALID_JUPITER_ROUTE]: `Invalid jupiter route data`,
     [TUNA_ERROR__INVALID_MARKET_MAKER]: `Invalid market maker`,
+    [TUNA_ERROR__INVALID_POOL]: `Invalid Fusion or Orca pool`,
     [TUNA_ERROR__INVALID_REMAINING_ACCOUNTS_LENGTH]: `Invalid number of remaining accounts`,
     [TUNA_ERROR__INVALID_SQRT_PRICE_LIMIT_DIRECTION]: `Provided SqrtPriceLimit not in the same direction as the swap.`,
     [TUNA_ERROR__INVALID_TICK_ARRAY_SEQUENCE]: `Invalid tick array sequence provided for instruction`,
@@ -7827,7 +7819,7 @@ function parseOpenTunaLpPositionOrcaInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/openTunaSpotPositionFusion.ts
+// src/generated/instructions/openTunaSpotPosition.ts
 import {
   combineCodec as combineCodec48,
   fixDecoderSize as fixDecoderSize42,
@@ -7838,22 +7830,22 @@ import {
   getStructEncoder as getStructEncoder44,
   transformEncoder as transformEncoder42
 } from "@solana/kit";
-var OPEN_TUNA_SPOT_POSITION_FUSION_DISCRIMINATOR = new Uint8Array([
-  110,
-  65,
-  149,
-  32,
-  32,
-  51,
-  135,
-  243
+var OPEN_TUNA_SPOT_POSITION_DISCRIMINATOR = new Uint8Array([
+  87,
+  208,
+  173,
+  48,
+  231,
+  62,
+  210,
+  220
 ]);
-function getOpenTunaSpotPositionFusionDiscriminatorBytes() {
+function getOpenTunaSpotPositionDiscriminatorBytes() {
   return fixEncoderSize43(getBytesEncoder43(), 8).encode(
-    OPEN_TUNA_SPOT_POSITION_FUSION_DISCRIMINATOR
+    OPEN_TUNA_SPOT_POSITION_DISCRIMINATOR
   );
 }
-function getOpenTunaSpotPositionFusionInstructionDataEncoder() {
+function getOpenTunaSpotPositionInstructionDataEncoder() {
   return transformEncoder42(
     getStructEncoder44([
       ["discriminator", fixEncoderSize43(getBytesEncoder43(), 8)],
@@ -7862,24 +7854,24 @@ function getOpenTunaSpotPositionFusionInstructionDataEncoder() {
     ]),
     (value) => ({
       ...value,
-      discriminator: OPEN_TUNA_SPOT_POSITION_FUSION_DISCRIMINATOR
+      discriminator: OPEN_TUNA_SPOT_POSITION_DISCRIMINATOR
     })
   );
 }
-function getOpenTunaSpotPositionFusionInstructionDataDecoder() {
+function getOpenTunaSpotPositionInstructionDataDecoder() {
   return getStructDecoder44([
     ["discriminator", fixDecoderSize42(getBytesDecoder42(), 8)],
     ["positionToken", getPoolTokenDecoder()],
     ["collateralToken", getPoolTokenDecoder()]
   ]);
 }
-function getOpenTunaSpotPositionFusionInstructionDataCodec() {
+function getOpenTunaSpotPositionInstructionDataCodec() {
   return combineCodec48(
-    getOpenTunaSpotPositionFusionInstructionDataEncoder(),
-    getOpenTunaSpotPositionFusionInstructionDataDecoder()
+    getOpenTunaSpotPositionInstructionDataEncoder(),
+    getOpenTunaSpotPositionInstructionDataDecoder()
   );
 }
-function getOpenTunaSpotPositionFusionInstruction(input, config) {
+function getOpenTunaSpotPositionInstruction(input, config) {
   const programAddress = config?.programAddress ?? TUNA_PROGRAM_ADDRESS;
   const originalAccounts = {
     authority: { value: input.authority ?? null, isWritable: true },
@@ -7896,7 +7888,7 @@ function getOpenTunaSpotPositionFusionInstruction(input, config) {
       value: input.tunaPositionAtaB ?? null,
       isWritable: true
     },
-    fusionPool: { value: input.fusionPool ?? null, isWritable: true },
+    pool: { value: input.pool ?? null, isWritable: false },
     systemProgram: { value: input.systemProgram ?? null, isWritable: false },
     associatedTokenProgram: {
       value: input.associatedTokenProgram ?? null,
@@ -7919,18 +7911,18 @@ function getOpenTunaSpotPositionFusionInstruction(input, config) {
       getAccountMeta(accounts.tunaPosition),
       getAccountMeta(accounts.tunaPositionAtaA),
       getAccountMeta(accounts.tunaPositionAtaB),
-      getAccountMeta(accounts.fusionPool),
+      getAccountMeta(accounts.pool),
       getAccountMeta(accounts.systemProgram),
       getAccountMeta(accounts.associatedTokenProgram)
     ],
     programAddress,
-    data: getOpenTunaSpotPositionFusionInstructionDataEncoder().encode(
+    data: getOpenTunaSpotPositionInstructionDataEncoder().encode(
       args
     )
   };
   return instruction;
 }
-function parseOpenTunaSpotPositionFusionInstruction(instruction) {
+function parseOpenTunaSpotPositionInstruction(instruction) {
   if (instruction.accounts.length < 11) {
     throw new Error("Not enough accounts");
   }
@@ -7951,17 +7943,17 @@ function parseOpenTunaSpotPositionFusionInstruction(instruction) {
       tunaPosition: getNextAccount(),
       tunaPositionAtaA: getNextAccount(),
       tunaPositionAtaB: getNextAccount(),
-      fusionPool: getNextAccount(),
+      pool: getNextAccount(),
       systemProgram: getNextAccount(),
       associatedTokenProgram: getNextAccount()
     },
-    data: getOpenTunaSpotPositionFusionInstructionDataDecoder().decode(
+    data: getOpenTunaSpotPositionInstructionDataDecoder().decode(
       instruction.data
     )
   };
 }
 
-// src/generated/instructions/openTunaSpotPositionOrca.ts
+// src/generated/instructions/rebalanceTunaLpPositionFusion.ts
 import {
   combineCodec as combineCodec49,
   fixDecoderSize as fixDecoderSize43,
@@ -7972,140 +7964,6 @@ import {
   getStructEncoder as getStructEncoder45,
   transformEncoder as transformEncoder43
 } from "@solana/kit";
-var OPEN_TUNA_SPOT_POSITION_ORCA_DISCRIMINATOR = new Uint8Array([
-  90,
-  70,
-  21,
-  186,
-  147,
-  80,
-  191,
-  94
-]);
-function getOpenTunaSpotPositionOrcaDiscriminatorBytes() {
-  return fixEncoderSize44(getBytesEncoder44(), 8).encode(
-    OPEN_TUNA_SPOT_POSITION_ORCA_DISCRIMINATOR
-  );
-}
-function getOpenTunaSpotPositionOrcaInstructionDataEncoder() {
-  return transformEncoder43(
-    getStructEncoder45([
-      ["discriminator", fixEncoderSize44(getBytesEncoder44(), 8)],
-      ["positionToken", getPoolTokenEncoder()],
-      ["collateralToken", getPoolTokenEncoder()]
-    ]),
-    (value) => ({
-      ...value,
-      discriminator: OPEN_TUNA_SPOT_POSITION_ORCA_DISCRIMINATOR
-    })
-  );
-}
-function getOpenTunaSpotPositionOrcaInstructionDataDecoder() {
-  return getStructDecoder45([
-    ["discriminator", fixDecoderSize43(getBytesDecoder43(), 8)],
-    ["positionToken", getPoolTokenDecoder()],
-    ["collateralToken", getPoolTokenDecoder()]
-  ]);
-}
-function getOpenTunaSpotPositionOrcaInstructionDataCodec() {
-  return combineCodec49(
-    getOpenTunaSpotPositionOrcaInstructionDataEncoder(),
-    getOpenTunaSpotPositionOrcaInstructionDataDecoder()
-  );
-}
-function getOpenTunaSpotPositionOrcaInstruction(input, config) {
-  const programAddress = config?.programAddress ?? TUNA_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    authority: { value: input.authority ?? null, isWritable: true },
-    mintA: { value: input.mintA ?? null, isWritable: false },
-    mintB: { value: input.mintB ?? null, isWritable: false },
-    tokenProgramA: { value: input.tokenProgramA ?? null, isWritable: false },
-    tokenProgramB: { value: input.tokenProgramB ?? null, isWritable: false },
-    tunaPosition: { value: input.tunaPosition ?? null, isWritable: true },
-    tunaPositionAtaA: {
-      value: input.tunaPositionAtaA ?? null,
-      isWritable: true
-    },
-    tunaPositionAtaB: {
-      value: input.tunaPositionAtaB ?? null,
-      isWritable: true
-    },
-    whirlpool: { value: input.whirlpool ?? null, isWritable: true },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  const instruction = {
-    accounts: [
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.mintA),
-      getAccountMeta(accounts.mintB),
-      getAccountMeta(accounts.tokenProgramA),
-      getAccountMeta(accounts.tokenProgramB),
-      getAccountMeta(accounts.tunaPosition),
-      getAccountMeta(accounts.tunaPositionAtaA),
-      getAccountMeta(accounts.tunaPositionAtaB),
-      getAccountMeta(accounts.whirlpool),
-      getAccountMeta(accounts.systemProgram),
-      getAccountMeta(accounts.associatedTokenProgram)
-    ],
-    programAddress,
-    data: getOpenTunaSpotPositionOrcaInstructionDataEncoder().encode(
-      args
-    )
-  };
-  return instruction;
-}
-function parseOpenTunaSpotPositionOrcaInstruction(instruction) {
-  if (instruction.accounts.length < 11) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      authority: getNextAccount(),
-      mintA: getNextAccount(),
-      mintB: getNextAccount(),
-      tokenProgramA: getNextAccount(),
-      tokenProgramB: getNextAccount(),
-      tunaPosition: getNextAccount(),
-      tunaPositionAtaA: getNextAccount(),
-      tunaPositionAtaB: getNextAccount(),
-      whirlpool: getNextAccount(),
-      systemProgram: getNextAccount(),
-      associatedTokenProgram: getNextAccount()
-    },
-    data: getOpenTunaSpotPositionOrcaInstructionDataDecoder().decode(
-      instruction.data
-    )
-  };
-}
-
-// src/generated/instructions/rebalanceTunaLpPositionFusion.ts
-import {
-  combineCodec as combineCodec50,
-  fixDecoderSize as fixDecoderSize44,
-  fixEncoderSize as fixEncoderSize45,
-  getBytesDecoder as getBytesDecoder44,
-  getBytesEncoder as getBytesEncoder45,
-  getStructDecoder as getStructDecoder46,
-  getStructEncoder as getStructEncoder46,
-  transformEncoder as transformEncoder44
-} from "@solana/kit";
 var REBALANCE_TUNA_LP_POSITION_FUSION_DISCRIMINATOR = new Uint8Array([
   190,
   86,
@@ -8117,14 +7975,14 @@ var REBALANCE_TUNA_LP_POSITION_FUSION_DISCRIMINATOR = new Uint8Array([
   51
 ]);
 function getRebalanceTunaLpPositionFusionDiscriminatorBytes() {
-  return fixEncoderSize45(getBytesEncoder45(), 8).encode(
+  return fixEncoderSize44(getBytesEncoder44(), 8).encode(
     REBALANCE_TUNA_LP_POSITION_FUSION_DISCRIMINATOR
   );
 }
 function getRebalanceTunaLpPositionFusionInstructionDataEncoder() {
-  return transformEncoder44(
-    getStructEncoder46([
-      ["discriminator", fixEncoderSize45(getBytesEncoder45(), 8)],
+  return transformEncoder43(
+    getStructEncoder45([
+      ["discriminator", fixEncoderSize44(getBytesEncoder44(), 8)],
       ["remainingAccountsInfo", getRemainingAccountsInfoEncoder()]
     ]),
     (value) => ({
@@ -8134,13 +7992,13 @@ function getRebalanceTunaLpPositionFusionInstructionDataEncoder() {
   );
 }
 function getRebalanceTunaLpPositionFusionInstructionDataDecoder() {
-  return getStructDecoder46([
-    ["discriminator", fixDecoderSize44(getBytesDecoder44(), 8)],
+  return getStructDecoder45([
+    ["discriminator", fixDecoderSize43(getBytesDecoder43(), 8)],
     ["remainingAccountsInfo", getRemainingAccountsInfoDecoder()]
   ]);
 }
 function getRebalanceTunaLpPositionFusionInstructionDataCodec() {
-  return combineCodec50(
+  return combineCodec49(
     getRebalanceTunaLpPositionFusionInstructionDataEncoder(),
     getRebalanceTunaLpPositionFusionInstructionDataDecoder()
   );
@@ -8268,14 +8126,14 @@ function parseRebalanceTunaLpPositionFusionInstruction(instruction) {
 
 // src/generated/instructions/rebalanceTunaLpPositionOrca.ts
 import {
-  combineCodec as combineCodec51,
-  fixDecoderSize as fixDecoderSize45,
-  fixEncoderSize as fixEncoderSize46,
-  getBytesDecoder as getBytesDecoder45,
-  getBytesEncoder as getBytesEncoder46,
-  getStructDecoder as getStructDecoder47,
-  getStructEncoder as getStructEncoder47,
-  transformEncoder as transformEncoder45
+  combineCodec as combineCodec50,
+  fixDecoderSize as fixDecoderSize44,
+  fixEncoderSize as fixEncoderSize45,
+  getBytesDecoder as getBytesDecoder44,
+  getBytesEncoder as getBytesEncoder45,
+  getStructDecoder as getStructDecoder46,
+  getStructEncoder as getStructEncoder46,
+  transformEncoder as transformEncoder44
 } from "@solana/kit";
 var REBALANCE_TUNA_LP_POSITION_ORCA_DISCRIMINATOR = new Uint8Array([
   124,
@@ -8288,14 +8146,14 @@ var REBALANCE_TUNA_LP_POSITION_ORCA_DISCRIMINATOR = new Uint8Array([
   231
 ]);
 function getRebalanceTunaLpPositionOrcaDiscriminatorBytes() {
-  return fixEncoderSize46(getBytesEncoder46(), 8).encode(
+  return fixEncoderSize45(getBytesEncoder45(), 8).encode(
     REBALANCE_TUNA_LP_POSITION_ORCA_DISCRIMINATOR
   );
 }
 function getRebalanceTunaLpPositionOrcaInstructionDataEncoder() {
-  return transformEncoder45(
-    getStructEncoder47([
-      ["discriminator", fixEncoderSize46(getBytesEncoder46(), 8)],
+  return transformEncoder44(
+    getStructEncoder46([
+      ["discriminator", fixEncoderSize45(getBytesEncoder45(), 8)],
       ["remainingAccountsInfo", getRemainingAccountsInfoEncoder()]
     ]),
     (value) => ({
@@ -8305,13 +8163,13 @@ function getRebalanceTunaLpPositionOrcaInstructionDataEncoder() {
   );
 }
 function getRebalanceTunaLpPositionOrcaInstructionDataDecoder() {
-  return getStructDecoder47([
-    ["discriminator", fixDecoderSize45(getBytesDecoder45(), 8)],
+  return getStructDecoder46([
+    ["discriminator", fixDecoderSize44(getBytesDecoder44(), 8)],
     ["remainingAccountsInfo", getRemainingAccountsInfoDecoder()]
   ]);
 }
 function getRebalanceTunaLpPositionOrcaInstructionDataCodec() {
-  return combineCodec51(
+  return combineCodec50(
     getRebalanceTunaLpPositionOrcaInstructionDataEncoder(),
     getRebalanceTunaLpPositionOrcaInstructionDataDecoder()
   );
@@ -8445,16 +8303,16 @@ function parseRebalanceTunaLpPositionOrcaInstruction(instruction) {
 
 // src/generated/instructions/repayBadDebt.ts
 import {
-  combineCodec as combineCodec52,
-  fixDecoderSize as fixDecoderSize46,
-  fixEncoderSize as fixEncoderSize47,
-  getBytesDecoder as getBytesDecoder46,
-  getBytesEncoder as getBytesEncoder47,
-  getStructDecoder as getStructDecoder48,
-  getStructEncoder as getStructEncoder48,
+  combineCodec as combineCodec51,
+  fixDecoderSize as fixDecoderSize45,
+  fixEncoderSize as fixEncoderSize46,
+  getBytesDecoder as getBytesDecoder45,
+  getBytesEncoder as getBytesEncoder46,
+  getStructDecoder as getStructDecoder47,
+  getStructEncoder as getStructEncoder47,
   getU64Decoder as getU64Decoder24,
   getU64Encoder as getU64Encoder24,
-  transformEncoder as transformEncoder46
+  transformEncoder as transformEncoder45
 } from "@solana/kit";
 var REPAY_BAD_DEBT_DISCRIMINATOR = new Uint8Array([
   112,
@@ -8467,14 +8325,14 @@ var REPAY_BAD_DEBT_DISCRIMINATOR = new Uint8Array([
   34
 ]);
 function getRepayBadDebtDiscriminatorBytes() {
-  return fixEncoderSize47(getBytesEncoder47(), 8).encode(
+  return fixEncoderSize46(getBytesEncoder46(), 8).encode(
     REPAY_BAD_DEBT_DISCRIMINATOR
   );
 }
 function getRepayBadDebtInstructionDataEncoder() {
-  return transformEncoder46(
-    getStructEncoder48([
-      ["discriminator", fixEncoderSize47(getBytesEncoder47(), 8)],
+  return transformEncoder45(
+    getStructEncoder47([
+      ["discriminator", fixEncoderSize46(getBytesEncoder46(), 8)],
       ["funds", getU64Encoder24()],
       ["shares", getU64Encoder24()]
     ]),
@@ -8482,14 +8340,14 @@ function getRepayBadDebtInstructionDataEncoder() {
   );
 }
 function getRepayBadDebtInstructionDataDecoder() {
-  return getStructDecoder48([
-    ["discriminator", fixDecoderSize46(getBytesDecoder46(), 8)],
+  return getStructDecoder47([
+    ["discriminator", fixDecoderSize45(getBytesDecoder45(), 8)],
     ["funds", getU64Decoder24()],
     ["shares", getU64Decoder24()]
   ]);
 }
 function getRepayBadDebtInstructionDataCodec() {
-  return combineCodec52(
+  return combineCodec51(
     getRepayBadDebtInstructionDataEncoder(),
     getRepayBadDebtInstructionDataDecoder()
   );
@@ -8558,16 +8416,16 @@ function parseRepayBadDebtInstruction(instruction) {
 
 // src/generated/instructions/repayTunaLpPositionDebt.ts
 import {
-  combineCodec as combineCodec53,
-  fixDecoderSize as fixDecoderSize47,
-  fixEncoderSize as fixEncoderSize48,
-  getBytesDecoder as getBytesDecoder47,
-  getBytesEncoder as getBytesEncoder48,
-  getStructDecoder as getStructDecoder49,
-  getStructEncoder as getStructEncoder49,
+  combineCodec as combineCodec52,
+  fixDecoderSize as fixDecoderSize46,
+  fixEncoderSize as fixEncoderSize47,
+  getBytesDecoder as getBytesDecoder46,
+  getBytesEncoder as getBytesEncoder47,
+  getStructDecoder as getStructDecoder48,
+  getStructEncoder as getStructEncoder48,
   getU64Decoder as getU64Decoder25,
   getU64Encoder as getU64Encoder25,
-  transformEncoder as transformEncoder47
+  transformEncoder as transformEncoder46
 } from "@solana/kit";
 var REPAY_TUNA_LP_POSITION_DEBT_DISCRIMINATOR = new Uint8Array([
   79,
@@ -8580,14 +8438,14 @@ var REPAY_TUNA_LP_POSITION_DEBT_DISCRIMINATOR = new Uint8Array([
   8
 ]);
 function getRepayTunaLpPositionDebtDiscriminatorBytes() {
-  return fixEncoderSize48(getBytesEncoder48(), 8).encode(
+  return fixEncoderSize47(getBytesEncoder47(), 8).encode(
     REPAY_TUNA_LP_POSITION_DEBT_DISCRIMINATOR
   );
 }
 function getRepayTunaLpPositionDebtInstructionDataEncoder() {
-  return transformEncoder47(
-    getStructEncoder49([
-      ["discriminator", fixEncoderSize48(getBytesEncoder48(), 8)],
+  return transformEncoder46(
+    getStructEncoder48([
+      ["discriminator", fixEncoderSize47(getBytesEncoder47(), 8)],
       ["collateralFundsA", getU64Encoder25()],
       ["collateralFundsB", getU64Encoder25()]
     ]),
@@ -8598,14 +8456,14 @@ function getRepayTunaLpPositionDebtInstructionDataEncoder() {
   );
 }
 function getRepayTunaLpPositionDebtInstructionDataDecoder() {
-  return getStructDecoder49([
-    ["discriminator", fixDecoderSize47(getBytesDecoder47(), 8)],
+  return getStructDecoder48([
+    ["discriminator", fixDecoderSize46(getBytesDecoder46(), 8)],
     ["collateralFundsA", getU64Decoder25()],
     ["collateralFundsB", getU64Decoder25()]
   ]);
 }
 function getRepayTunaLpPositionDebtInstructionDataCodec() {
-  return combineCodec53(
+  return combineCodec52(
     getRepayTunaLpPositionDebtInstructionDataEncoder(),
     getRepayTunaLpPositionDebtInstructionDataDecoder()
   );
@@ -8709,14 +8567,14 @@ function parseRepayTunaLpPositionDebtInstruction(instruction) {
 
 // src/generated/instructions/resetTunaSpotPosition.ts
 import {
-  combineCodec as combineCodec54,
-  fixDecoderSize as fixDecoderSize48,
-  fixEncoderSize as fixEncoderSize49,
-  getBytesDecoder as getBytesDecoder48,
-  getBytesEncoder as getBytesEncoder49,
-  getStructDecoder as getStructDecoder50,
-  getStructEncoder as getStructEncoder50,
-  transformEncoder as transformEncoder48
+  combineCodec as combineCodec53,
+  fixDecoderSize as fixDecoderSize47,
+  fixEncoderSize as fixEncoderSize48,
+  getBytesDecoder as getBytesDecoder47,
+  getBytesEncoder as getBytesEncoder48,
+  getStructDecoder as getStructDecoder49,
+  getStructEncoder as getStructEncoder49,
+  transformEncoder as transformEncoder47
 } from "@solana/kit";
 var RESET_TUNA_SPOT_POSITION_DISCRIMINATOR = new Uint8Array([
   194,
@@ -8729,14 +8587,14 @@ var RESET_TUNA_SPOT_POSITION_DISCRIMINATOR = new Uint8Array([
   127
 ]);
 function getResetTunaSpotPositionDiscriminatorBytes() {
-  return fixEncoderSize49(getBytesEncoder49(), 8).encode(
+  return fixEncoderSize48(getBytesEncoder48(), 8).encode(
     RESET_TUNA_SPOT_POSITION_DISCRIMINATOR
   );
 }
 function getResetTunaSpotPositionInstructionDataEncoder() {
-  return transformEncoder48(
-    getStructEncoder50([
-      ["discriminator", fixEncoderSize49(getBytesEncoder49(), 8)],
+  return transformEncoder47(
+    getStructEncoder49([
+      ["discriminator", fixEncoderSize48(getBytesEncoder48(), 8)],
       ["positionToken", getPoolTokenEncoder()],
       ["collateralToken", getPoolTokenEncoder()]
     ]),
@@ -8747,14 +8605,14 @@ function getResetTunaSpotPositionInstructionDataEncoder() {
   );
 }
 function getResetTunaSpotPositionInstructionDataDecoder() {
-  return getStructDecoder50([
-    ["discriminator", fixDecoderSize48(getBytesDecoder48(), 8)],
+  return getStructDecoder49([
+    ["discriminator", fixDecoderSize47(getBytesDecoder47(), 8)],
     ["positionToken", getPoolTokenDecoder()],
     ["collateralToken", getPoolTokenDecoder()]
   ]);
 }
 function getResetTunaSpotPositionInstructionDataCodec() {
-  return combineCodec54(
+  return combineCodec53(
     getResetTunaSpotPositionInstructionDataEncoder(),
     getResetTunaSpotPositionInstructionDataDecoder()
   );
@@ -8822,16 +8680,16 @@ function parseResetTunaSpotPositionInstruction(instruction) {
 
 // src/generated/instructions/setAdminAuthority.ts
 import {
-  combineCodec as combineCodec55,
-  fixDecoderSize as fixDecoderSize49,
-  fixEncoderSize as fixEncoderSize50,
+  combineCodec as combineCodec54,
+  fixDecoderSize as fixDecoderSize48,
+  fixEncoderSize as fixEncoderSize49,
   getAddressDecoder as getAddressDecoder10,
   getAddressEncoder as getAddressEncoder10,
-  getBytesDecoder as getBytesDecoder49,
-  getBytesEncoder as getBytesEncoder50,
-  getStructDecoder as getStructDecoder51,
-  getStructEncoder as getStructEncoder51,
-  transformEncoder as transformEncoder49
+  getBytesDecoder as getBytesDecoder48,
+  getBytesEncoder as getBytesEncoder49,
+  getStructDecoder as getStructDecoder50,
+  getStructEncoder as getStructEncoder50,
+  transformEncoder as transformEncoder48
 } from "@solana/kit";
 var SET_ADMIN_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   72,
@@ -8844,27 +8702,27 @@ var SET_ADMIN_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   174
 ]);
 function getSetAdminAuthorityDiscriminatorBytes() {
-  return fixEncoderSize50(getBytesEncoder50(), 8).encode(
+  return fixEncoderSize49(getBytesEncoder49(), 8).encode(
     SET_ADMIN_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetAdminAuthorityInstructionDataEncoder() {
-  return transformEncoder49(
-    getStructEncoder51([
-      ["discriminator", fixEncoderSize50(getBytesEncoder50(), 8)],
+  return transformEncoder48(
+    getStructEncoder50([
+      ["discriminator", fixEncoderSize49(getBytesEncoder49(), 8)],
       ["adminAuthority", getAddressEncoder10()]
     ]),
     (value) => ({ ...value, discriminator: SET_ADMIN_AUTHORITY_DISCRIMINATOR })
   );
 }
 function getSetAdminAuthorityInstructionDataDecoder() {
-  return getStructDecoder51([
-    ["discriminator", fixDecoderSize49(getBytesDecoder49(), 8)],
+  return getStructDecoder50([
+    ["discriminator", fixDecoderSize48(getBytesDecoder48(), 8)],
     ["adminAuthority", getAddressDecoder10()]
   ]);
 }
 function getSetAdminAuthorityInstructionDataCodec() {
-  return combineCodec55(
+  return combineCodec54(
     getSetAdminAuthorityInstructionDataEncoder(),
     getSetAdminAuthorityInstructionDataDecoder()
   );
@@ -8912,27 +8770,27 @@ function parseSetAdminAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setDefaultMaxPercentageOfLeftovers.ts
 import {
-  combineCodec as combineCodec56,
-  fixDecoderSize as fixDecoderSize50,
-  fixEncoderSize as fixEncoderSize51,
-  getBytesDecoder as getBytesDecoder50,
-  getBytesEncoder as getBytesEncoder51,
-  getStructDecoder as getStructDecoder52,
-  getStructEncoder as getStructEncoder52,
+  combineCodec as combineCodec55,
+  fixDecoderSize as fixDecoderSize49,
+  fixEncoderSize as fixEncoderSize50,
+  getBytesDecoder as getBytesDecoder49,
+  getBytesEncoder as getBytesEncoder50,
+  getStructDecoder as getStructDecoder51,
+  getStructEncoder as getStructEncoder51,
   getU32Decoder as getU32Decoder22,
   getU32Encoder as getU32Encoder22,
-  transformEncoder as transformEncoder50
+  transformEncoder as transformEncoder49
 } from "@solana/kit";
 var SET_DEFAULT_MAX_PERCENTAGE_OF_LEFTOVERS_DISCRIMINATOR = new Uint8Array([37, 179, 107, 65, 203, 141, 183, 27]);
 function getSetDefaultMaxPercentageOfLeftoversDiscriminatorBytes() {
-  return fixEncoderSize51(getBytesEncoder51(), 8).encode(
+  return fixEncoderSize50(getBytesEncoder50(), 8).encode(
     SET_DEFAULT_MAX_PERCENTAGE_OF_LEFTOVERS_DISCRIMINATOR
   );
 }
 function getSetDefaultMaxPercentageOfLeftoversInstructionDataEncoder() {
-  return transformEncoder50(
-    getStructEncoder52([
-      ["discriminator", fixEncoderSize51(getBytesEncoder51(), 8)],
+  return transformEncoder49(
+    getStructEncoder51([
+      ["discriminator", fixEncoderSize50(getBytesEncoder50(), 8)],
       ["maxPercentageOfLeftovers", getU32Encoder22()]
     ]),
     (value) => ({
@@ -8942,13 +8800,13 @@ function getSetDefaultMaxPercentageOfLeftoversInstructionDataEncoder() {
   );
 }
 function getSetDefaultMaxPercentageOfLeftoversInstructionDataDecoder() {
-  return getStructDecoder52([
-    ["discriminator", fixDecoderSize50(getBytesDecoder50(), 8)],
+  return getStructDecoder51([
+    ["discriminator", fixDecoderSize49(getBytesDecoder49(), 8)],
     ["maxPercentageOfLeftovers", getU32Decoder22()]
   ]);
 }
 function getSetDefaultMaxPercentageOfLeftoversInstructionDataCodec() {
-  return combineCodec56(
+  return combineCodec55(
     getSetDefaultMaxPercentageOfLeftoversInstructionDataEncoder(),
     getSetDefaultMaxPercentageOfLeftoversInstructionDataDecoder()
   );
@@ -8998,16 +8856,16 @@ function parseSetDefaultMaxPercentageOfLeftoversInstruction(instruction) {
 
 // src/generated/instructions/setDefaultMaxSwapSlippage.ts
 import {
-  combineCodec as combineCodec57,
-  fixDecoderSize as fixDecoderSize51,
-  fixEncoderSize as fixEncoderSize52,
-  getBytesDecoder as getBytesDecoder51,
-  getBytesEncoder as getBytesEncoder52,
-  getStructDecoder as getStructDecoder53,
-  getStructEncoder as getStructEncoder53,
+  combineCodec as combineCodec56,
+  fixDecoderSize as fixDecoderSize50,
+  fixEncoderSize as fixEncoderSize51,
+  getBytesDecoder as getBytesDecoder50,
+  getBytesEncoder as getBytesEncoder51,
+  getStructDecoder as getStructDecoder52,
+  getStructEncoder as getStructEncoder52,
   getU32Decoder as getU32Decoder23,
   getU32Encoder as getU32Encoder23,
-  transformEncoder as transformEncoder51
+  transformEncoder as transformEncoder50
 } from "@solana/kit";
 var SET_DEFAULT_MAX_SWAP_SLIPPAGE_DISCRIMINATOR = new Uint8Array([
   122,
@@ -9020,14 +8878,14 @@ var SET_DEFAULT_MAX_SWAP_SLIPPAGE_DISCRIMINATOR = new Uint8Array([
   181
 ]);
 function getSetDefaultMaxSwapSlippageDiscriminatorBytes() {
-  return fixEncoderSize52(getBytesEncoder52(), 8).encode(
+  return fixEncoderSize51(getBytesEncoder51(), 8).encode(
     SET_DEFAULT_MAX_SWAP_SLIPPAGE_DISCRIMINATOR
   );
 }
 function getSetDefaultMaxSwapSlippageInstructionDataEncoder() {
-  return transformEncoder51(
-    getStructEncoder53([
-      ["discriminator", fixEncoderSize52(getBytesEncoder52(), 8)],
+  return transformEncoder50(
+    getStructEncoder52([
+      ["discriminator", fixEncoderSize51(getBytesEncoder51(), 8)],
       ["maxSwapSlippage", getU32Encoder23()]
     ]),
     (value) => ({
@@ -9037,13 +8895,13 @@ function getSetDefaultMaxSwapSlippageInstructionDataEncoder() {
   );
 }
 function getSetDefaultMaxSwapSlippageInstructionDataDecoder() {
-  return getStructDecoder53([
-    ["discriminator", fixDecoderSize51(getBytesDecoder51(), 8)],
+  return getStructDecoder52([
+    ["discriminator", fixDecoderSize50(getBytesDecoder50(), 8)],
     ["maxSwapSlippage", getU32Decoder23()]
   ]);
 }
 function getSetDefaultMaxSwapSlippageInstructionDataCodec() {
-  return combineCodec57(
+  return combineCodec56(
     getSetDefaultMaxSwapSlippageInstructionDataEncoder(),
     getSetDefaultMaxSwapSlippageInstructionDataDecoder()
   );
@@ -9093,27 +8951,27 @@ function parseSetDefaultMaxSwapSlippageInstruction(instruction) {
 
 // src/generated/instructions/setDefaultOraclePriceDeviationThreshold.ts
 import {
-  combineCodec as combineCodec58,
-  fixDecoderSize as fixDecoderSize52,
-  fixEncoderSize as fixEncoderSize53,
-  getBytesDecoder as getBytesDecoder52,
-  getBytesEncoder as getBytesEncoder53,
-  getStructDecoder as getStructDecoder54,
-  getStructEncoder as getStructEncoder54,
+  combineCodec as combineCodec57,
+  fixDecoderSize as fixDecoderSize51,
+  fixEncoderSize as fixEncoderSize52,
+  getBytesDecoder as getBytesDecoder51,
+  getBytesEncoder as getBytesEncoder52,
+  getStructDecoder as getStructDecoder53,
+  getStructEncoder as getStructEncoder53,
   getU32Decoder as getU32Decoder24,
   getU32Encoder as getU32Encoder24,
-  transformEncoder as transformEncoder52
+  transformEncoder as transformEncoder51
 } from "@solana/kit";
 var SET_DEFAULT_ORACLE_PRICE_DEVIATION_THRESHOLD_DISCRIMINATOR = new Uint8Array([142, 158, 143, 67, 206, 91, 139, 120]);
 function getSetDefaultOraclePriceDeviationThresholdDiscriminatorBytes() {
-  return fixEncoderSize53(getBytesEncoder53(), 8).encode(
+  return fixEncoderSize52(getBytesEncoder52(), 8).encode(
     SET_DEFAULT_ORACLE_PRICE_DEVIATION_THRESHOLD_DISCRIMINATOR
   );
 }
 function getSetDefaultOraclePriceDeviationThresholdInstructionDataEncoder() {
-  return transformEncoder52(
-    getStructEncoder54([
-      ["discriminator", fixEncoderSize53(getBytesEncoder53(), 8)],
+  return transformEncoder51(
+    getStructEncoder53([
+      ["discriminator", fixEncoderSize52(getBytesEncoder52(), 8)],
       ["oraclePriceDeviationThreshold", getU32Encoder24()]
     ]),
     (value) => ({
@@ -9123,13 +8981,13 @@ function getSetDefaultOraclePriceDeviationThresholdInstructionDataEncoder() {
   );
 }
 function getSetDefaultOraclePriceDeviationThresholdInstructionDataDecoder() {
-  return getStructDecoder54([
-    ["discriminator", fixDecoderSize52(getBytesDecoder52(), 8)],
+  return getStructDecoder53([
+    ["discriminator", fixDecoderSize51(getBytesDecoder51(), 8)],
     ["oraclePriceDeviationThreshold", getU32Decoder24()]
   ]);
 }
 function getSetDefaultOraclePriceDeviationThresholdInstructionDataCodec() {
-  return combineCodec58(
+  return combineCodec57(
     getSetDefaultOraclePriceDeviationThresholdInstructionDataEncoder(),
     getSetDefaultOraclePriceDeviationThresholdInstructionDataDecoder()
   );
@@ -9179,16 +9037,16 @@ function parseSetDefaultOraclePriceDeviationThresholdInstruction(instruction) {
 
 // src/generated/instructions/setFeeRecipient.ts
 import {
-  combineCodec as combineCodec59,
-  fixDecoderSize as fixDecoderSize53,
-  fixEncoderSize as fixEncoderSize54,
+  combineCodec as combineCodec58,
+  fixDecoderSize as fixDecoderSize52,
+  fixEncoderSize as fixEncoderSize53,
   getAddressDecoder as getAddressDecoder11,
   getAddressEncoder as getAddressEncoder11,
-  getBytesDecoder as getBytesDecoder53,
-  getBytesEncoder as getBytesEncoder54,
-  getStructDecoder as getStructDecoder55,
-  getStructEncoder as getStructEncoder55,
-  transformEncoder as transformEncoder53
+  getBytesDecoder as getBytesDecoder52,
+  getBytesEncoder as getBytesEncoder53,
+  getStructDecoder as getStructDecoder54,
+  getStructEncoder as getStructEncoder54,
+  transformEncoder as transformEncoder52
 } from "@solana/kit";
 var SET_FEE_RECIPIENT_DISCRIMINATOR = new Uint8Array([
   227,
@@ -9201,27 +9059,27 @@ var SET_FEE_RECIPIENT_DISCRIMINATOR = new Uint8Array([
   66
 ]);
 function getSetFeeRecipientDiscriminatorBytes() {
-  return fixEncoderSize54(getBytesEncoder54(), 8).encode(
+  return fixEncoderSize53(getBytesEncoder53(), 8).encode(
     SET_FEE_RECIPIENT_DISCRIMINATOR
   );
 }
 function getSetFeeRecipientInstructionDataEncoder() {
-  return transformEncoder53(
-    getStructEncoder55([
-      ["discriminator", fixEncoderSize54(getBytesEncoder54(), 8)],
+  return transformEncoder52(
+    getStructEncoder54([
+      ["discriminator", fixEncoderSize53(getBytesEncoder53(), 8)],
       ["feeRecipient", getAddressEncoder11()]
     ]),
     (value) => ({ ...value, discriminator: SET_FEE_RECIPIENT_DISCRIMINATOR })
   );
 }
 function getSetFeeRecipientInstructionDataDecoder() {
-  return getStructDecoder55([
-    ["discriminator", fixDecoderSize53(getBytesDecoder53(), 8)],
+  return getStructDecoder54([
+    ["discriminator", fixDecoderSize52(getBytesDecoder52(), 8)],
     ["feeRecipient", getAddressDecoder11()]
   ]);
 }
 function getSetFeeRecipientInstructionDataCodec() {
-  return combineCodec59(
+  return combineCodec58(
     getSetFeeRecipientInstructionDataEncoder(),
     getSetFeeRecipientInstructionDataDecoder()
   );
@@ -9269,16 +9127,16 @@ function parseSetFeeRecipientInstruction(instruction) {
 
 // src/generated/instructions/setLiquidatorAuthority.ts
 import {
-  combineCodec as combineCodec60,
-  fixDecoderSize as fixDecoderSize54,
-  fixEncoderSize as fixEncoderSize55,
+  combineCodec as combineCodec59,
+  fixDecoderSize as fixDecoderSize53,
+  fixEncoderSize as fixEncoderSize54,
   getAddressDecoder as getAddressDecoder12,
   getAddressEncoder as getAddressEncoder12,
-  getBytesDecoder as getBytesDecoder54,
-  getBytesEncoder as getBytesEncoder55,
-  getStructDecoder as getStructDecoder56,
-  getStructEncoder as getStructEncoder56,
-  transformEncoder as transformEncoder54
+  getBytesDecoder as getBytesDecoder53,
+  getBytesEncoder as getBytesEncoder54,
+  getStructDecoder as getStructDecoder55,
+  getStructEncoder as getStructEncoder55,
+  transformEncoder as transformEncoder53
 } from "@solana/kit";
 var SET_LIQUIDATOR_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   246,
@@ -9291,14 +9149,14 @@ var SET_LIQUIDATOR_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   143
 ]);
 function getSetLiquidatorAuthorityDiscriminatorBytes() {
-  return fixEncoderSize55(getBytesEncoder55(), 8).encode(
+  return fixEncoderSize54(getBytesEncoder54(), 8).encode(
     SET_LIQUIDATOR_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetLiquidatorAuthorityInstructionDataEncoder() {
-  return transformEncoder54(
-    getStructEncoder56([
-      ["discriminator", fixEncoderSize55(getBytesEncoder55(), 8)],
+  return transformEncoder53(
+    getStructEncoder55([
+      ["discriminator", fixEncoderSize54(getBytesEncoder54(), 8)],
       ["liquidatorAuthority", getAddressEncoder12()]
     ]),
     (value) => ({
@@ -9308,13 +9166,13 @@ function getSetLiquidatorAuthorityInstructionDataEncoder() {
   );
 }
 function getSetLiquidatorAuthorityInstructionDataDecoder() {
-  return getStructDecoder56([
-    ["discriminator", fixDecoderSize54(getBytesDecoder54(), 8)],
+  return getStructDecoder55([
+    ["discriminator", fixDecoderSize53(getBytesDecoder53(), 8)],
     ["liquidatorAuthority", getAddressDecoder12()]
   ]);
 }
 function getSetLiquidatorAuthorityInstructionDataCodec() {
-  return combineCodec60(
+  return combineCodec59(
     getSetLiquidatorAuthorityInstructionDataEncoder(),
     getSetLiquidatorAuthorityInstructionDataDecoder()
   );
@@ -9364,16 +9222,16 @@ function parseSetLiquidatorAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setOwnerAuthority.ts
 import {
-  combineCodec as combineCodec61,
-  fixDecoderSize as fixDecoderSize55,
-  fixEncoderSize as fixEncoderSize56,
+  combineCodec as combineCodec60,
+  fixDecoderSize as fixDecoderSize54,
+  fixEncoderSize as fixEncoderSize55,
   getAddressDecoder as getAddressDecoder13,
   getAddressEncoder as getAddressEncoder13,
-  getBytesDecoder as getBytesDecoder55,
-  getBytesEncoder as getBytesEncoder56,
-  getStructDecoder as getStructDecoder57,
-  getStructEncoder as getStructEncoder57,
-  transformEncoder as transformEncoder55
+  getBytesDecoder as getBytesDecoder54,
+  getBytesEncoder as getBytesEncoder55,
+  getStructDecoder as getStructDecoder56,
+  getStructEncoder as getStructEncoder56,
+  transformEncoder as transformEncoder54
 } from "@solana/kit";
 var SET_OWNER_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   128,
@@ -9386,27 +9244,27 @@ var SET_OWNER_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   117
 ]);
 function getSetOwnerAuthorityDiscriminatorBytes() {
-  return fixEncoderSize56(getBytesEncoder56(), 8).encode(
+  return fixEncoderSize55(getBytesEncoder55(), 8).encode(
     SET_OWNER_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetOwnerAuthorityInstructionDataEncoder() {
-  return transformEncoder55(
-    getStructEncoder57([
-      ["discriminator", fixEncoderSize56(getBytesEncoder56(), 8)],
+  return transformEncoder54(
+    getStructEncoder56([
+      ["discriminator", fixEncoderSize55(getBytesEncoder55(), 8)],
       ["ownerAuthority", getAddressEncoder13()]
     ]),
     (value) => ({ ...value, discriminator: SET_OWNER_AUTHORITY_DISCRIMINATOR })
   );
 }
 function getSetOwnerAuthorityInstructionDataDecoder() {
-  return getStructDecoder57([
-    ["discriminator", fixDecoderSize55(getBytesDecoder55(), 8)],
+  return getStructDecoder56([
+    ["discriminator", fixDecoderSize54(getBytesDecoder54(), 8)],
     ["ownerAuthority", getAddressDecoder13()]
   ]);
 }
 function getSetOwnerAuthorityInstructionDataCodec() {
-  return combineCodec61(
+  return combineCodec60(
     getSetOwnerAuthorityInstructionDataEncoder(),
     getSetOwnerAuthorityInstructionDataDecoder()
   );
@@ -9454,16 +9312,16 @@ function parseSetOwnerAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setSuspendedState.ts
 import {
-  combineCodec as combineCodec62,
-  fixDecoderSize as fixDecoderSize56,
-  fixEncoderSize as fixEncoderSize57,
+  combineCodec as combineCodec61,
+  fixDecoderSize as fixDecoderSize55,
+  fixEncoderSize as fixEncoderSize56,
   getBooleanDecoder as getBooleanDecoder7,
   getBooleanEncoder as getBooleanEncoder7,
-  getBytesDecoder as getBytesDecoder56,
-  getBytesEncoder as getBytesEncoder57,
-  getStructDecoder as getStructDecoder58,
-  getStructEncoder as getStructEncoder58,
-  transformEncoder as transformEncoder56
+  getBytesDecoder as getBytesDecoder55,
+  getBytesEncoder as getBytesEncoder56,
+  getStructDecoder as getStructDecoder57,
+  getStructEncoder as getStructEncoder57,
+  transformEncoder as transformEncoder55
 } from "@solana/kit";
 var SET_SUSPENDED_STATE_DISCRIMINATOR = new Uint8Array([
   145,
@@ -9476,14 +9334,14 @@ var SET_SUSPENDED_STATE_DISCRIMINATOR = new Uint8Array([
   32
 ]);
 function getSetSuspendedStateDiscriminatorBytes() {
-  return fixEncoderSize57(getBytesEncoder57(), 8).encode(
+  return fixEncoderSize56(getBytesEncoder56(), 8).encode(
     SET_SUSPENDED_STATE_DISCRIMINATOR
   );
 }
 function getSetSuspendedStateInstructionDataEncoder() {
-  return transformEncoder56(
-    getStructEncoder58([
-      ["discriminator", fixEncoderSize57(getBytesEncoder57(), 8)],
+  return transformEncoder55(
+    getStructEncoder57([
+      ["discriminator", fixEncoderSize56(getBytesEncoder56(), 8)],
       ["suspendLendingDeposits", getBooleanEncoder7()],
       ["suspendLendingWithdrawals", getBooleanEncoder7()],
       ["suspendAddLiquidity", getBooleanEncoder7()],
@@ -9493,8 +9351,8 @@ function getSetSuspendedStateInstructionDataEncoder() {
   );
 }
 function getSetSuspendedStateInstructionDataDecoder() {
-  return getStructDecoder58([
-    ["discriminator", fixDecoderSize56(getBytesDecoder56(), 8)],
+  return getStructDecoder57([
+    ["discriminator", fixDecoderSize55(getBytesDecoder55(), 8)],
     ["suspendLendingDeposits", getBooleanDecoder7()],
     ["suspendLendingWithdrawals", getBooleanDecoder7()],
     ["suspendAddLiquidity", getBooleanDecoder7()],
@@ -9502,7 +9360,7 @@ function getSetSuspendedStateInstructionDataDecoder() {
   ]);
 }
 function getSetSuspendedStateInstructionDataCodec() {
-  return combineCodec62(
+  return combineCodec61(
     getSetSuspendedStateInstructionDataEncoder(),
     getSetSuspendedStateInstructionDataDecoder()
   );
@@ -9550,16 +9408,16 @@ function parseSetSuspendedStateInstruction(instruction) {
 
 // src/generated/instructions/setTunaLpPositionFlags.ts
 import {
-  combineCodec as combineCodec63,
-  fixDecoderSize as fixDecoderSize57,
-  fixEncoderSize as fixEncoderSize58,
-  getBytesDecoder as getBytesDecoder57,
-  getBytesEncoder as getBytesEncoder58,
-  getStructDecoder as getStructDecoder59,
-  getStructEncoder as getStructEncoder59,
+  combineCodec as combineCodec62,
+  fixDecoderSize as fixDecoderSize56,
+  fixEncoderSize as fixEncoderSize57,
+  getBytesDecoder as getBytesDecoder56,
+  getBytesEncoder as getBytesEncoder57,
+  getStructDecoder as getStructDecoder58,
+  getStructEncoder as getStructEncoder58,
   getU32Decoder as getU32Decoder25,
   getU32Encoder as getU32Encoder25,
-  transformEncoder as transformEncoder57
+  transformEncoder as transformEncoder56
 } from "@solana/kit";
 var SET_TUNA_LP_POSITION_FLAGS_DISCRIMINATOR = new Uint8Array([
   110,
@@ -9572,14 +9430,14 @@ var SET_TUNA_LP_POSITION_FLAGS_DISCRIMINATOR = new Uint8Array([
   57
 ]);
 function getSetTunaLpPositionFlagsDiscriminatorBytes() {
-  return fixEncoderSize58(getBytesEncoder58(), 8).encode(
+  return fixEncoderSize57(getBytesEncoder57(), 8).encode(
     SET_TUNA_LP_POSITION_FLAGS_DISCRIMINATOR
   );
 }
 function getSetTunaLpPositionFlagsInstructionDataEncoder() {
-  return transformEncoder57(
-    getStructEncoder59([
-      ["discriminator", fixEncoderSize58(getBytesEncoder58(), 8)],
+  return transformEncoder56(
+    getStructEncoder58([
+      ["discriminator", fixEncoderSize57(getBytesEncoder57(), 8)],
       ["flags", getU32Encoder25()]
     ]),
     (value) => ({
@@ -9589,13 +9447,13 @@ function getSetTunaLpPositionFlagsInstructionDataEncoder() {
   );
 }
 function getSetTunaLpPositionFlagsInstructionDataDecoder() {
-  return getStructDecoder59([
-    ["discriminator", fixDecoderSize57(getBytesDecoder57(), 8)],
+  return getStructDecoder58([
+    ["discriminator", fixDecoderSize56(getBytesDecoder56(), 8)],
     ["flags", getU32Decoder25()]
   ]);
 }
 function getSetTunaLpPositionFlagsInstructionDataCodec() {
-  return combineCodec63(
+  return combineCodec62(
     getSetTunaLpPositionFlagsInstructionDataEncoder(),
     getSetTunaLpPositionFlagsInstructionDataDecoder()
   );
@@ -9645,18 +9503,18 @@ function parseSetTunaLpPositionFlagsInstruction(instruction) {
 
 // src/generated/instructions/setTunaLpPositionLimitOrders.ts
 import {
-  combineCodec as combineCodec64,
-  fixDecoderSize as fixDecoderSize58,
-  fixEncoderSize as fixEncoderSize59,
-  getBytesDecoder as getBytesDecoder58,
-  getBytesEncoder as getBytesEncoder59,
-  getStructDecoder as getStructDecoder60,
-  getStructEncoder as getStructEncoder60,
+  combineCodec as combineCodec63,
+  fixDecoderSize as fixDecoderSize57,
+  fixEncoderSize as fixEncoderSize58,
+  getBytesDecoder as getBytesDecoder57,
+  getBytesEncoder as getBytesEncoder58,
+  getStructDecoder as getStructDecoder59,
+  getStructEncoder as getStructEncoder59,
   getU128Decoder as getU128Decoder7,
   getU128Encoder as getU128Encoder7,
   getU8Decoder as getU8Decoder5,
   getU8Encoder as getU8Encoder5,
-  transformEncoder as transformEncoder58
+  transformEncoder as transformEncoder57
 } from "@solana/kit";
 var SET_TUNA_LP_POSITION_LIMIT_ORDERS_DISCRIMINATOR = new Uint8Array([
   65,
@@ -9669,14 +9527,14 @@ var SET_TUNA_LP_POSITION_LIMIT_ORDERS_DISCRIMINATOR = new Uint8Array([
   255
 ]);
 function getSetTunaLpPositionLimitOrdersDiscriminatorBytes() {
-  return fixEncoderSize59(getBytesEncoder59(), 8).encode(
+  return fixEncoderSize58(getBytesEncoder58(), 8).encode(
     SET_TUNA_LP_POSITION_LIMIT_ORDERS_DISCRIMINATOR
   );
 }
 function getSetTunaLpPositionLimitOrdersInstructionDataEncoder() {
-  return transformEncoder58(
-    getStructEncoder60([
-      ["discriminator", fixEncoderSize59(getBytesEncoder59(), 8)],
+  return transformEncoder57(
+    getStructEncoder59([
+      ["discriminator", fixEncoderSize58(getBytesEncoder58(), 8)],
       ["lowerLimitOrderSqrtPrice", getU128Encoder7()],
       ["upperLimitOrderSqrtPrice", getU128Encoder7()],
       ["swapToTokenOnLimitOrder", getU8Encoder5()]
@@ -9688,15 +9546,15 @@ function getSetTunaLpPositionLimitOrdersInstructionDataEncoder() {
   );
 }
 function getSetTunaLpPositionLimitOrdersInstructionDataDecoder() {
-  return getStructDecoder60([
-    ["discriminator", fixDecoderSize58(getBytesDecoder58(), 8)],
+  return getStructDecoder59([
+    ["discriminator", fixDecoderSize57(getBytesDecoder57(), 8)],
     ["lowerLimitOrderSqrtPrice", getU128Decoder7()],
     ["upperLimitOrderSqrtPrice", getU128Decoder7()],
     ["swapToTokenOnLimitOrder", getU8Decoder5()]
   ]);
 }
 function getSetTunaLpPositionLimitOrdersInstructionDataCodec() {
-  return combineCodec64(
+  return combineCodec63(
     getSetTunaLpPositionLimitOrdersInstructionDataEncoder(),
     getSetTunaLpPositionLimitOrdersInstructionDataDecoder()
   );
@@ -9746,27 +9604,27 @@ function parseSetTunaLpPositionLimitOrdersInstruction(instruction) {
 
 // src/generated/instructions/setTunaLpPositionRebalanceThreshold.ts
 import {
-  combineCodec as combineCodec65,
-  fixDecoderSize as fixDecoderSize59,
-  fixEncoderSize as fixEncoderSize60,
-  getBytesDecoder as getBytesDecoder59,
-  getBytesEncoder as getBytesEncoder60,
-  getStructDecoder as getStructDecoder61,
-  getStructEncoder as getStructEncoder61,
+  combineCodec as combineCodec64,
+  fixDecoderSize as fixDecoderSize58,
+  fixEncoderSize as fixEncoderSize59,
+  getBytesDecoder as getBytesDecoder58,
+  getBytesEncoder as getBytesEncoder59,
+  getStructDecoder as getStructDecoder60,
+  getStructEncoder as getStructEncoder60,
   getU32Decoder as getU32Decoder26,
   getU32Encoder as getU32Encoder26,
-  transformEncoder as transformEncoder59
+  transformEncoder as transformEncoder58
 } from "@solana/kit";
 var SET_TUNA_LP_POSITION_REBALANCE_THRESHOLD_DISCRIMINATOR = new Uint8Array([244, 174, 185, 58, 90, 150, 162, 51]);
 function getSetTunaLpPositionRebalanceThresholdDiscriminatorBytes() {
-  return fixEncoderSize60(getBytesEncoder60(), 8).encode(
+  return fixEncoderSize59(getBytesEncoder59(), 8).encode(
     SET_TUNA_LP_POSITION_REBALANCE_THRESHOLD_DISCRIMINATOR
   );
 }
 function getSetTunaLpPositionRebalanceThresholdInstructionDataEncoder() {
-  return transformEncoder59(
-    getStructEncoder61([
-      ["discriminator", fixEncoderSize60(getBytesEncoder60(), 8)],
+  return transformEncoder58(
+    getStructEncoder60([
+      ["discriminator", fixEncoderSize59(getBytesEncoder59(), 8)],
       ["rebalanceThresholdTicks", getU32Encoder26()]
     ]),
     (value) => ({
@@ -9776,13 +9634,13 @@ function getSetTunaLpPositionRebalanceThresholdInstructionDataEncoder() {
   );
 }
 function getSetTunaLpPositionRebalanceThresholdInstructionDataDecoder() {
-  return getStructDecoder61([
-    ["discriminator", fixDecoderSize59(getBytesDecoder59(), 8)],
+  return getStructDecoder60([
+    ["discriminator", fixDecoderSize58(getBytesDecoder58(), 8)],
     ["rebalanceThresholdTicks", getU32Decoder26()]
   ]);
 }
 function getSetTunaLpPositionRebalanceThresholdInstructionDataCodec() {
-  return combineCodec65(
+  return combineCodec64(
     getSetTunaLpPositionRebalanceThresholdInstructionDataEncoder(),
     getSetTunaLpPositionRebalanceThresholdInstructionDataDecoder()
   );
@@ -9832,29 +9690,29 @@ function parseSetTunaLpPositionRebalanceThresholdInstruction(instruction) {
 
 // src/generated/instructions/setTunaSpotPositionLimitOrders.ts
 import {
-  combineCodec as combineCodec66,
-  fixDecoderSize as fixDecoderSize60,
-  fixEncoderSize as fixEncoderSize61,
-  getBytesDecoder as getBytesDecoder60,
-  getBytesEncoder as getBytesEncoder61,
-  getStructDecoder as getStructDecoder62,
-  getStructEncoder as getStructEncoder62,
+  combineCodec as combineCodec65,
+  fixDecoderSize as fixDecoderSize59,
+  fixEncoderSize as fixEncoderSize60,
+  getBytesDecoder as getBytesDecoder59,
+  getBytesEncoder as getBytesEncoder60,
+  getStructDecoder as getStructDecoder61,
+  getStructEncoder as getStructEncoder61,
   getU128Decoder as getU128Decoder8,
   getU128Encoder as getU128Encoder8,
-  transformEncoder as transformEncoder60
+  transformEncoder as transformEncoder59
 } from "@solana/kit";
 var SET_TUNA_SPOT_POSITION_LIMIT_ORDERS_DISCRIMINATOR = new Uint8Array(
   [10, 180, 19, 205, 169, 133, 52, 118]
 );
 function getSetTunaSpotPositionLimitOrdersDiscriminatorBytes() {
-  return fixEncoderSize61(getBytesEncoder61(), 8).encode(
+  return fixEncoderSize60(getBytesEncoder60(), 8).encode(
     SET_TUNA_SPOT_POSITION_LIMIT_ORDERS_DISCRIMINATOR
   );
 }
 function getSetTunaSpotPositionLimitOrdersInstructionDataEncoder() {
-  return transformEncoder60(
-    getStructEncoder62([
-      ["discriminator", fixEncoderSize61(getBytesEncoder61(), 8)],
+  return transformEncoder59(
+    getStructEncoder61([
+      ["discriminator", fixEncoderSize60(getBytesEncoder60(), 8)],
       ["lowerLimitOrderSqrtPrice", getU128Encoder8()],
       ["upperLimitOrderSqrtPrice", getU128Encoder8()]
     ]),
@@ -9865,14 +9723,14 @@ function getSetTunaSpotPositionLimitOrdersInstructionDataEncoder() {
   );
 }
 function getSetTunaSpotPositionLimitOrdersInstructionDataDecoder() {
-  return getStructDecoder62([
-    ["discriminator", fixDecoderSize60(getBytesDecoder60(), 8)],
+  return getStructDecoder61([
+    ["discriminator", fixDecoderSize59(getBytesDecoder59(), 8)],
     ["lowerLimitOrderSqrtPrice", getU128Decoder8()],
     ["upperLimitOrderSqrtPrice", getU128Decoder8()]
   ]);
 }
 function getSetTunaSpotPositionLimitOrdersInstructionDataCodec() {
-  return combineCodec66(
+  return combineCodec65(
     getSetTunaSpotPositionLimitOrdersInstructionDataEncoder(),
     getSetTunaSpotPositionLimitOrdersInstructionDataDecoder()
   );
@@ -9922,24 +9780,24 @@ function parseSetTunaSpotPositionLimitOrdersInstruction(instruction) {
 
 // src/generated/instructions/updateMarket.ts
 import {
-  combineCodec as combineCodec67,
-  fixDecoderSize as fixDecoderSize61,
-  fixEncoderSize as fixEncoderSize62,
+  combineCodec as combineCodec66,
+  fixDecoderSize as fixDecoderSize60,
+  fixEncoderSize as fixEncoderSize61,
   getAddressDecoder as getAddressDecoder14,
   getAddressEncoder as getAddressEncoder14,
   getBooleanDecoder as getBooleanDecoder8,
   getBooleanEncoder as getBooleanEncoder8,
-  getBytesDecoder as getBytesDecoder61,
-  getBytesEncoder as getBytesEncoder62,
-  getStructDecoder as getStructDecoder63,
-  getStructEncoder as getStructEncoder63,
+  getBytesDecoder as getBytesDecoder60,
+  getBytesEncoder as getBytesEncoder61,
+  getStructDecoder as getStructDecoder62,
+  getStructEncoder as getStructEncoder62,
   getU16Decoder as getU16Decoder8,
   getU16Encoder as getU16Encoder8,
   getU32Decoder as getU32Decoder27,
   getU32Encoder as getU32Encoder27,
   getU64Decoder as getU64Decoder26,
   getU64Encoder as getU64Encoder26,
-  transformEncoder as transformEncoder61
+  transformEncoder as transformEncoder60
 } from "@solana/kit";
 var UPDATE_MARKET_DISCRIMINATOR = new Uint8Array([
   153,
@@ -9952,14 +9810,14 @@ var UPDATE_MARKET_DISCRIMINATOR = new Uint8Array([
   217
 ]);
 function getUpdateMarketDiscriminatorBytes() {
-  return fixEncoderSize62(getBytesEncoder62(), 8).encode(
+  return fixEncoderSize61(getBytesEncoder61(), 8).encode(
     UPDATE_MARKET_DISCRIMINATOR
   );
 }
 function getUpdateMarketInstructionDataEncoder() {
-  return transformEncoder61(
-    getStructEncoder63([
-      ["discriminator", fixEncoderSize62(getBytesEncoder62(), 8)],
+  return transformEncoder60(
+    getStructEncoder62([
+      ["discriminator", fixEncoderSize61(getBytesEncoder61(), 8)],
       ["addressLookupTable", getAddressEncoder14()],
       ["maxLeverage", getU32Encoder27()],
       ["protocolFee", getU16Encoder8()],
@@ -9980,8 +9838,8 @@ function getUpdateMarketInstructionDataEncoder() {
   );
 }
 function getUpdateMarketInstructionDataDecoder() {
-  return getStructDecoder63([
-    ["discriminator", fixDecoderSize61(getBytesDecoder61(), 8)],
+  return getStructDecoder62([
+    ["discriminator", fixDecoderSize60(getBytesDecoder60(), 8)],
     ["addressLookupTable", getAddressDecoder14()],
     ["maxLeverage", getU32Decoder27()],
     ["protocolFee", getU16Decoder8()],
@@ -10000,7 +9858,7 @@ function getUpdateMarketInstructionDataDecoder() {
   ]);
 }
 function getUpdateMarketInstructionDataCodec() {
-  return combineCodec67(
+  return combineCodec66(
     getUpdateMarketInstructionDataEncoder(),
     getUpdateMarketInstructionDataDecoder()
   );
@@ -10051,18 +9909,18 @@ function parseUpdateMarketInstruction(instruction) {
 
 // src/generated/instructions/updateVault.ts
 import {
-  combineCodec as combineCodec68,
-  fixDecoderSize as fixDecoderSize62,
-  fixEncoderSize as fixEncoderSize63,
+  combineCodec as combineCodec67,
+  fixDecoderSize as fixDecoderSize61,
+  fixEncoderSize as fixEncoderSize62,
   getAddressDecoder as getAddressDecoder15,
   getAddressEncoder as getAddressEncoder15,
-  getBytesDecoder as getBytesDecoder62,
-  getBytesEncoder as getBytesEncoder63,
-  getStructDecoder as getStructDecoder64,
-  getStructEncoder as getStructEncoder64,
+  getBytesDecoder as getBytesDecoder61,
+  getBytesEncoder as getBytesEncoder62,
+  getStructDecoder as getStructDecoder63,
+  getStructEncoder as getStructEncoder63,
   getU64Decoder as getU64Decoder27,
   getU64Encoder as getU64Encoder27,
-  transformEncoder as transformEncoder62
+  transformEncoder as transformEncoder61
 } from "@solana/kit";
 var UPDATE_VAULT_DISCRIMINATOR = new Uint8Array([
   67,
@@ -10075,14 +9933,14 @@ var UPDATE_VAULT_DISCRIMINATOR = new Uint8Array([
   60
 ]);
 function getUpdateVaultDiscriminatorBytes() {
-  return fixEncoderSize63(getBytesEncoder63(), 8).encode(
+  return fixEncoderSize62(getBytesEncoder62(), 8).encode(
     UPDATE_VAULT_DISCRIMINATOR
   );
 }
 function getUpdateVaultInstructionDataEncoder() {
-  return transformEncoder62(
-    getStructEncoder64([
-      ["discriminator", fixEncoderSize63(getBytesEncoder63(), 8)],
+  return transformEncoder61(
+    getStructEncoder63([
+      ["discriminator", fixEncoderSize62(getBytesEncoder62(), 8)],
       ["interestRate", getU64Encoder27()],
       ["supplyLimit", getU64Encoder27()],
       ["pythOraclePriceUpdate", getAddressEncoder15()],
@@ -10092,8 +9950,8 @@ function getUpdateVaultInstructionDataEncoder() {
   );
 }
 function getUpdateVaultInstructionDataDecoder() {
-  return getStructDecoder64([
-    ["discriminator", fixDecoderSize62(getBytesDecoder62(), 8)],
+  return getStructDecoder63([
+    ["discriminator", fixDecoderSize61(getBytesDecoder61(), 8)],
     ["interestRate", getU64Decoder27()],
     ["supplyLimit", getU64Decoder27()],
     ["pythOraclePriceUpdate", getAddressDecoder15()],
@@ -10101,7 +9959,7 @@ function getUpdateVaultInstructionDataDecoder() {
   ]);
 }
 function getUpdateVaultInstructionDataCodec() {
-  return combineCodec68(
+  return combineCodec67(
     getUpdateVaultInstructionDataEncoder(),
     getUpdateVaultInstructionDataDecoder()
   );
@@ -10152,16 +10010,16 @@ function parseUpdateVaultInstruction(instruction) {
 
 // src/generated/instructions/withdraw.ts
 import {
-  combineCodec as combineCodec69,
-  fixDecoderSize as fixDecoderSize63,
-  fixEncoderSize as fixEncoderSize64,
-  getBytesDecoder as getBytesDecoder63,
-  getBytesEncoder as getBytesEncoder64,
-  getStructDecoder as getStructDecoder65,
-  getStructEncoder as getStructEncoder65,
+  combineCodec as combineCodec68,
+  fixDecoderSize as fixDecoderSize62,
+  fixEncoderSize as fixEncoderSize63,
+  getBytesDecoder as getBytesDecoder62,
+  getBytesEncoder as getBytesEncoder63,
+  getStructDecoder as getStructDecoder64,
+  getStructEncoder as getStructEncoder64,
   getU64Decoder as getU64Decoder28,
   getU64Encoder as getU64Encoder28,
-  transformEncoder as transformEncoder63
+  transformEncoder as transformEncoder62
 } from "@solana/kit";
 var WITHDRAW_DISCRIMINATOR = new Uint8Array([
   183,
@@ -10174,12 +10032,12 @@ var WITHDRAW_DISCRIMINATOR = new Uint8Array([
   34
 ]);
 function getWithdrawDiscriminatorBytes() {
-  return fixEncoderSize64(getBytesEncoder64(), 8).encode(WITHDRAW_DISCRIMINATOR);
+  return fixEncoderSize63(getBytesEncoder63(), 8).encode(WITHDRAW_DISCRIMINATOR);
 }
 function getWithdrawInstructionDataEncoder() {
-  return transformEncoder63(
-    getStructEncoder65([
-      ["discriminator", fixEncoderSize64(getBytesEncoder64(), 8)],
+  return transformEncoder62(
+    getStructEncoder64([
+      ["discriminator", fixEncoderSize63(getBytesEncoder63(), 8)],
       ["funds", getU64Encoder28()],
       ["shares", getU64Encoder28()]
     ]),
@@ -10187,14 +10045,14 @@ function getWithdrawInstructionDataEncoder() {
   );
 }
 function getWithdrawInstructionDataDecoder() {
-  return getStructDecoder65([
-    ["discriminator", fixDecoderSize63(getBytesDecoder63(), 8)],
+  return getStructDecoder64([
+    ["discriminator", fixDecoderSize62(getBytesDecoder62(), 8)],
     ["funds", getU64Decoder28()],
     ["shares", getU64Decoder28()]
   ]);
 }
 function getWithdrawInstructionDataCodec() {
-  return combineCodec69(
+  return combineCodec68(
     getWithdrawInstructionDataEncoder(),
     getWithdrawInstructionDataDecoder()
   );
@@ -12917,21 +12775,21 @@ import { fetchFusionPool as fetchFusionPool2 } from "@crypticdot/fusionamm-clien
 import {
   assertAccountExists as assertAccountExists7,
   assertAccountsExist as assertAccountsExist8,
-  combineCodec as combineCodec70,
+  combineCodec as combineCodec69,
   decodeAccount as decodeAccount7,
   fetchEncodedAccount as fetchEncodedAccount7,
   fetchEncodedAccounts as fetchEncodedAccounts7,
-  fixDecoderSize as fixDecoderSize64,
-  fixEncoderSize as fixEncoderSize65,
+  fixDecoderSize as fixDecoderSize63,
+  fixEncoderSize as fixEncoderSize64,
   getAddressDecoder as getAddressDecoder16,
   getAddressEncoder as getAddressEncoder20,
-  getBytesDecoder as getBytesDecoder64,
-  getBytesEncoder as getBytesEncoder65,
-  getStructDecoder as getStructDecoder66,
-  getStructEncoder as getStructEncoder66,
+  getBytesDecoder as getBytesDecoder63,
+  getBytesEncoder as getBytesEncoder64,
+  getStructDecoder as getStructDecoder65,
+  getStructEncoder as getStructEncoder65,
   getU64Decoder as getU64Decoder29,
   getU64Encoder as getU64Encoder29,
-  transformEncoder as transformEncoder64
+  transformEncoder as transformEncoder63
 } from "@solana/kit";
 import {
   isProgramError as isProgramError2
@@ -12990,10 +12848,10 @@ import {
 import {
   combineCodec as combineCodec510,
   fixDecoderSize as fixDecoderSize510,
-  fixEncoderSize as fixEncoderSize66,
+  fixEncoderSize as fixEncoderSize65,
   getAddressEncoder as getAddressEncoder32,
   getBytesDecoder as getBytesDecoder510,
-  getBytesEncoder as getBytesEncoder66,
+  getBytesEncoder as getBytesEncoder65,
   getProgramDerivedAddress as getProgramDerivedAddress22,
   getStructDecoder as getStructDecoder510,
   getStructEncoder as getStructEncoder510,
@@ -13001,17 +12859,17 @@ import {
 } from "@solana/kit";
 import {
   combineCodec as combineCodec610,
-  fixDecoderSize as fixDecoderSize65,
+  fixDecoderSize as fixDecoderSize64,
   fixEncoderSize as fixEncoderSize72,
   getAddressEncoder as getAddressEncoder42,
-  getBytesDecoder as getBytesDecoder65,
+  getBytesDecoder as getBytesDecoder64,
   getBytesEncoder as getBytesEncoder72,
   getProgramDerivedAddress as getProgramDerivedAddress3,
-  getStructDecoder as getStructDecoder67,
-  getStructEncoder as getStructEncoder67,
+  getStructDecoder as getStructDecoder66,
+  getStructEncoder as getStructEncoder66,
   getU8Decoder as getU8Decoder42,
   getU8Encoder as getU8Encoder42,
-  transformEncoder as transformEncoder65
+  transformEncoder as transformEncoder64
 } from "@solana/kit";
 import {
   combineCodec as combineCodec72,
@@ -13566,7 +13424,7 @@ async function increaseTunaSpotPositionJupiterInstructions(rpc, authority, poolA
   ]);
   let collateralToken;
   if (openArgs != void 0) {
-    const openIx = market.data.marketMaker == 1 /* Fusion */ ? await openTunaSpotPositionFusionInstruction(authority, mintA, mintB, poolAddress, openArgs) : await openTunaSpotPositionOrcaInstruction(authority, mintA, mintB, poolAddress, openArgs);
+    const openIx = await openTunaSpotPositionInstruction(authority, mintA, mintB, poolAddress, openArgs);
     instructions.push(openIx);
     collateralToken = openArgs.collateralToken;
   } else {
@@ -15685,25 +15543,38 @@ async function openAndIncreaseTunaSpotPositionOrcaInstruction(authority, tunaCon
   return ix;
 }
 
-// src/txbuilder/openTunaSpotPositionFusion.ts
-import { fetchMaybeFusionPool as fetchMaybeFusionPool10 } from "@crypticdot/fusionamm-client";
+// src/txbuilder/openTunaSpotPosition.ts
+import { FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS14, getFusionPoolDecoder } from "@crypticdot/fusionamm-client";
+import { getWhirlpoolDecoder, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS14 } from "@orca-so/whirlpools-client";
+import {
+  decodeAccount as decodeAccount8,
+  fetchEncodedAccount as fetchEncodedAccount8
+} from "@solana/kit";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS7,
   fetchAllMaybeMint as fetchAllMaybeMint26,
   findAssociatedTokenPda as findAssociatedTokenPda33
 } from "@solana-program/token-2022";
 import assert26 from "assert";
-async function openTunaSpotPositionFusionInstructions(rpc, authority, fusionPoolAddress, args) {
-  const fusionPool = await fetchMaybeFusionPool10(rpc, fusionPoolAddress);
-  if (!fusionPool.exists) throw new Error("FusionPool account not found");
-  const [mintA, mintB] = await fetchAllMaybeMint26(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+async function openTunaSpotPositionInstructions(rpc, authority, poolAddress, args) {
+  const poolAccount = await fetchEncodedAccount8(rpc, poolAddress);
+  assert26(poolAccount.exists, "Pool account not found");
+  let pool;
+  if (poolAccount.programAddress == FUSIONAMM_PROGRAM_ADDRESS14) {
+    pool = decodeAccount8(poolAccount, getFusionPoolDecoder());
+  } else if (poolAccount.programAddress == WHIRLPOOL_PROGRAM_ADDRESS14) {
+    pool = decodeAccount8(poolAccount, getWhirlpoolDecoder());
+  } else {
+    throw new Error("Incorrect Fusion or Orca pool account");
+  }
+  const [mintA, mintB] = await fetchAllMaybeMint26(rpc, [pool.data.tokenMintA, pool.data.tokenMintB]);
   assert26(mintA.exists, "Token A account not found");
   assert26(mintB.exists, "Token B account not found");
-  const ix = await openTunaSpotPositionFusionInstruction(authority, mintA, mintB, fusionPoolAddress, args);
+  const ix = await openTunaSpotPositionInstruction(authority, mintA, mintB, poolAddress, args);
   return [ix];
 }
-async function openTunaSpotPositionFusionInstruction(authority, mintA, mintB, fusionPoolAddress, args) {
-  const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, fusionPoolAddress))[0];
+async function openTunaSpotPositionInstruction(authority, mintA, mintB, poolAddress, args) {
+  const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, poolAddress))[0];
   const tunaPositionAtaA = (await findAssociatedTokenPda33({
     owner: tunaPositionAddress,
     mint: mintA.address,
@@ -15714,7 +15585,7 @@ async function openTunaSpotPositionFusionInstruction(authority, mintA, mintB, fu
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  return getOpenTunaSpotPositionFusionInstruction({
+  return getOpenTunaSpotPositionInstruction({
     authority,
     mintA: mintA.address,
     mintB: mintB.address,
@@ -15723,65 +15594,21 @@ async function openTunaSpotPositionFusionInstruction(authority, mintA, mintB, fu
     tunaPosition: tunaPositionAddress,
     tunaPositionAtaA,
     tunaPositionAtaB,
-    fusionPool: fusionPoolAddress,
+    pool: poolAddress,
     associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS7,
     ...args
   });
 }
 
-// src/txbuilder/openTunaSpotPositionOrca.ts
-import { fetchMaybeWhirlpool as fetchMaybeWhirlpool10 } from "@orca-so/whirlpools-client";
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS8,
-  fetchAllMaybeMint as fetchAllMaybeMint27,
-  findAssociatedTokenPda as findAssociatedTokenPda34
-} from "@solana-program/token-2022";
-import assert27 from "assert";
-async function openTunaSpotPositionOrcaInstructions(rpc, authority, whirlpoolAddress, args) {
-  const whirlpool = await fetchMaybeWhirlpool10(rpc, whirlpoolAddress);
-  if (!whirlpool.exists) throw new Error("Whirlpool account not found");
-  const [mintA, mintB] = await fetchAllMaybeMint27(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  assert27(mintA.exists, "Token A account not found");
-  assert27(mintB.exists, "Token B account not found");
-  const ix = await openTunaSpotPositionOrcaInstruction(authority, mintA, mintB, whirlpoolAddress, args);
-  return [ix];
-}
-async function openTunaSpotPositionOrcaInstruction(authority, mintA, mintB, whirlpoolAddress, args) {
-  const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, whirlpoolAddress))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda34({
-    owner: tunaPositionAddress,
-    mint: mintA.address,
-    tokenProgram: mintA.programAddress
-  }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda34({
-    owner: tunaPositionAddress,
-    mint: mintB.address,
-    tokenProgram: mintB.programAddress
-  }))[0];
-  return getOpenTunaSpotPositionOrcaInstruction({
-    authority,
-    mintA: mintA.address,
-    mintB: mintB.address,
-    tokenProgramA: mintA.programAddress,
-    tokenProgramB: mintB.programAddress,
-    tunaPosition: tunaPositionAddress,
-    tunaPositionAtaA,
-    tunaPositionAtaB,
-    whirlpool: whirlpoolAddress,
-    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS8,
-    ...args
-  });
-}
-
 // src/txbuilder/decreaseTunaLpPositionOrca.ts
 import {
   fetchAllTickArray as fetchAllTickArray2,
-  fetchMaybeWhirlpool as fetchMaybeWhirlpool11,
+  fetchMaybeWhirlpool as fetchMaybeWhirlpool10,
   fetchPosition as fetchPosition3,
   getOracleAddress as getOracleAddress10,
   getPositionAddress as getPositionAddress17,
   getTickArrayAddress as getTickArrayAddress8,
-  WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS14
+  WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS15
 } from "@orca-so/whirlpools-client";
 import { collectRewardsQuote as collectRewardsQuote2, getTickArrayStartTickIndex as getTickArrayStartTickIndex8, getTickIndexInArray as getTickIndexInArray2 } from "@orca-so/whirlpools-core";
 import {
@@ -15790,29 +15617,29 @@ import {
 } from "@solana/kit";
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS24 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint28,
-  findAssociatedTokenPda as findAssociatedTokenPda35,
+  fetchAllMaybeMint as fetchAllMaybeMint27,
+  findAssociatedTokenPda as findAssociatedTokenPda34,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS17
 } from "@solana-program/token-2022";
-import assert28 from "assert";
+import assert27 from "assert";
 async function decreaseTunaLpPositionOrcaInstructions(rpc, authority, positionMint, args, createInstructions, cleanupInstructions) {
   const tunaPosition = await fetchMaybeTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
   if (!tunaPosition.exists) throw new Error("Tuna position account not found");
   const orcaPosition = await fetchPosition3(rpc, (await getPositionAddress17(positionMint))[0]);
-  const whirlpool = await fetchMaybeWhirlpool11(rpc, tunaPosition.data.pool);
+  const whirlpool = await fetchMaybeWhirlpool10(rpc, tunaPosition.data.pool);
   if (!whirlpool.exists) throw new Error("Whirlpool account not found");
   const [vaultA, vaultB] = await fetchAllVault(rpc, [
     (await getLendingVaultAddress(whirlpool.data.tokenMintA))[0],
     (await getLendingVaultAddress(whirlpool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB, ...rewardMints] = await fetchAllMaybeMint28(rpc, [
+  const [mintA, mintB, ...rewardMints] = await fetchAllMaybeMint27(rpc, [
     whirlpool.data.tokenMintA,
     whirlpool.data.tokenMintB,
     ...whirlpool.data.rewardInfos.map((x) => x.mint).filter((x) => x !== DEFAULT_ADDRESS)
   ]);
   const allMints = [mintA, mintB, ...rewardMints];
-  assert28(mintA.exists, "Token A account not found");
-  assert28(mintB.exists, "Token B account not found");
+  assert27(mintA.exists, "Token A account not found");
+  assert27(mintB.exists, "Token B account not found");
   assertAccountsExist9(rewardMints);
   const lowerTickArrayStartIndex = getTickArrayStartTickIndex8(
     tunaPosition.data.tickLowerIndex,
@@ -15853,7 +15680,7 @@ async function decreaseTunaLpPositionOrcaInstructions(rpc, authority, positionMi
   }
   for (const mintAddress of requiredMints) {
     const mint = allMints.find((mint2) => mint2.address == mintAddress);
-    assert28(mint && mint.exists);
+    assert27(mint && mint.exists);
     const ixs = await getCreateAtaInstructions(rpc, authority, mint.address, authority.address, mint.programAddress);
     createInstructions.push(...ixs.init);
     internalCleanupInstructions.push(...ixs.cleanup);
@@ -15881,37 +15708,37 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
   const orcaPositionAddress = (await getPositionAddress17(positionMint))[0];
   const orcaOracleAddress = (await getOracleAddress10(whirlpool.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda35({
+  const tunaPositionAta = (await findAssociatedTokenPda34({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS17
   }))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda35({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda34({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda35({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda34({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda35({
+  const tunaPositionAtaA = (await findAssociatedTokenPda34({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda35({
+  const tunaPositionAtaB = (await findAssociatedTokenPda34({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda35({
+  const vaultAAta = (await findAssociatedTokenPda34({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda35({
+  const vaultBAta = (await findAssociatedTokenPda34({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -15940,8 +15767,8 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
   for (const rewardIndex of rewardIndicesToClaim) {
     const rewardInfo = whirlpool.data.rewardInfos[rewardIndex];
     const rewardMint = rewardMints.find((mint) => mint.address == rewardInfo.mint);
-    assert28(rewardMint, "Reward mint not found in the provided reward mint accounts");
-    const ownerAta = await findAssociatedTokenPda35({
+    assert27(rewardMint, "Reward mint not found in the provided reward mint accounts");
+    const ownerAta = await findAssociatedTokenPda34({
       owner: authority.address,
       mint: rewardMint.address,
       tokenProgram: rewardMint.programAddress
@@ -15984,7 +15811,7 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
     orcaPosition: orcaPositionAddress,
     tunaPosition: tunaPosition.address,
     whirlpool: whirlpool.address,
-    whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS14,
+    whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS15,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
     memoProgram: MEMO_PROGRAM_ADDRESS24,
@@ -15997,8 +15824,8 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
 
 // src/txbuilder/decreaseTunaLpPositionFusion.ts
 import {
-  fetchMaybeFusionPool as fetchMaybeFusionPool11,
-  FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS14,
+  fetchMaybeFusionPool as fetchMaybeFusionPool10,
+  FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS15,
   getPositionAddress as getPositionAddress18
 } from "@crypticdot/fusionamm-client";
 import {
@@ -16006,23 +15833,23 @@ import {
 } from "@solana/kit";
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS25 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint29,
-  findAssociatedTokenPda as findAssociatedTokenPda36,
+  fetchAllMaybeMint as fetchAllMaybeMint28,
+  findAssociatedTokenPda as findAssociatedTokenPda35,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS18
 } from "@solana-program/token-2022";
-import assert29 from "assert";
+import assert28 from "assert";
 async function decreaseTunaLpPositionFusionInstructions(rpc, authority, positionMint, args, createInstructions, cleanupInstructions) {
   const tunaPosition = await fetchMaybeTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
   if (!tunaPosition.exists) throw new Error("Tuna position account not found");
-  const fusionPool = await fetchMaybeFusionPool11(rpc, tunaPosition.data.pool);
+  const fusionPool = await fetchMaybeFusionPool10(rpc, tunaPosition.data.pool);
   if (!fusionPool.exists) throw new Error("FusionPool account not found");
   const [vaultA, vaultB] = await fetchAllVault(rpc, [
     (await getLendingVaultAddress(fusionPool.data.tokenMintA))[0],
     (await getLendingVaultAddress(fusionPool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint29(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  assert29(mintA.exists, "Token A account not found");
-  assert29(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint28(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  assert28(mintA.exists, "Token A account not found");
+  assert28(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -16063,37 +15890,37 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
   const tunaConfig = (await getTunaConfigAddress())[0];
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
   const fusionPositionAddress = (await getPositionAddress18(positionMint))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda36({
+  const tunaPositionAta = (await findAssociatedTokenPda35({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS18
   }))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda36({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda35({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda36({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda35({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda36({
+  const tunaPositionAtaA = (await findAssociatedTokenPda35({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda36({
+  const tunaPositionAtaB = (await findAssociatedTokenPda35({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda36({
+  const vaultAAta = (await findAssociatedTokenPda35({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda36({
+  const vaultBAta = (await findAssociatedTokenPda35({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -16147,7 +15974,7 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
     fusionPosition: fusionPositionAddress,
     tunaPosition: tunaPosition.address,
     fusionPool: fusionPool.address,
-    fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS14,
+    fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS15,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
     memoProgram: MEMO_PROGRAM_ADDRESS25,
@@ -16160,18 +15987,18 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
 
 // src/txbuilder/repayBadDebt.ts
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS26 } from "@solana-program/memo";
-import { fetchMaybeMint as fetchMaybeMint2, findAssociatedTokenPda as findAssociatedTokenPda37 } from "@solana-program/token-2022";
+import { fetchMaybeMint as fetchMaybeMint2, findAssociatedTokenPda as findAssociatedTokenPda36 } from "@solana-program/token-2022";
 async function repayBadDebtInstruction(rpc, authority, mintAddress, funds, shares) {
   const mint = await fetchMaybeMint2(rpc, mintAddress);
   if (!mint.exists) throw new Error("Mint account not found");
   const tunaConfig = (await getTunaConfigAddress())[0];
   const vault = (await getLendingVaultAddress(mint.address))[0];
-  const vaultAta = (await findAssociatedTokenPda37({
+  const vaultAta = (await findAssociatedTokenPda36({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
   }))[0];
-  const authorityAta = (await findAssociatedTokenPda37({
+  const authorityAta = (await findAssociatedTokenPda36({
     owner: authority.address,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -16216,20 +16043,20 @@ async function setTunaSpotPositionLimitOrdersInstruction(authority, poolAddress,
 }
 
 // src/txbuilder/resetTunaSpotPosition.ts
-import { fetchAllMaybeMint as fetchAllMaybeMint30, findAssociatedTokenPda as findAssociatedTokenPda38 } from "@solana-program/token-2022";
-import assert30 from "assert";
+import { fetchAllMaybeMint as fetchAllMaybeMint29, findAssociatedTokenPda as findAssociatedTokenPda37 } from "@solana-program/token-2022";
+import assert29 from "assert";
 async function resetTunaSpotPositionInstruction(rpc, authority, poolAddress, args) {
   const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, poolAddress))[0];
   const tunaPosition = await fetchTunaSpotPosition(rpc, tunaPositionAddress);
-  const [mintA, mintB] = await fetchAllMaybeMint30(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  assert30(mintA.exists, "Token A not found");
-  assert30(mintB.exists, "Token B not found");
-  const tunaPositionAtaA = (await findAssociatedTokenPda38({
+  const [mintA, mintB] = await fetchAllMaybeMint29(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  assert29(mintA.exists, "Token A not found");
+  assert29(mintB.exists, "Token B not found");
+  const tunaPositionAtaA = (await findAssociatedTokenPda37({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda38({
+  const tunaPositionAtaB = (await findAssociatedTokenPda37({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -16271,7 +16098,7 @@ async function updateVaultInstruction(authority, mint, args) {
 
 // src/txbuilder/withdraw.ts
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS27 } from "@solana-program/memo";
-import { fetchMaybeMint as fetchMaybeMint3, findAssociatedTokenPda as findAssociatedTokenPda39 } from "@solana-program/token-2022";
+import { fetchMaybeMint as fetchMaybeMint3, findAssociatedTokenPda as findAssociatedTokenPda38 } from "@solana-program/token-2022";
 async function withdrawInstructions(rpc, authority, mintAddress, funds, shares) {
   const instructions = [];
   const mint = await fetchMaybeMint3(rpc, mintAddress);
@@ -16293,12 +16120,12 @@ async function withdrawInstruction(authority, mint, funds, shares) {
   const tunaConfig = (await getTunaConfigAddress())[0];
   const lendingPosition = (await getLendingPositionAddress(authority.address, mint.address))[0];
   const vault = (await getLendingVaultAddress(mint.address))[0];
-  const vaultAta = (await findAssociatedTokenPda39({
+  const vaultAta = (await findAssociatedTokenPda38({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
   }))[0];
-  const authorityAta = (await findAssociatedTokenPda39({
+  const authorityAta = (await findAssociatedTokenPda38({
     owner: authority.address,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -16319,8 +16146,8 @@ async function withdrawInstruction(authority, mint, funds, shares) {
 }
 
 // src/txbuilder/createMarketLookupTable.ts
-import { fetchFusionPool as fetchFusionPool4, FP_NFT_UPDATE_AUTH as FP_NFT_UPDATE_AUTH3, FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS15 } from "@crypticdot/fusionamm-client";
-import { fetchWhirlpool as fetchWhirlpool4, getOracleAddress as getOracleAddress11, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS15 } from "@orca-so/whirlpools-client";
+import { fetchFusionPool as fetchFusionPool4, FP_NFT_UPDATE_AUTH as FP_NFT_UPDATE_AUTH3, FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS16 } from "@crypticdot/fusionamm-client";
+import { fetchWhirlpool as fetchWhirlpool4, getOracleAddress as getOracleAddress11, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS16 } from "@orca-so/whirlpools-client";
 import {
   address as address3
 } from "@solana/kit";
@@ -16329,9 +16156,9 @@ import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS28 } from "@solana-program/
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import { TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS2 } from "@solana-program/token";
 import {
-  ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS9,
+  ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS8,
   fetchMint,
-  findAssociatedTokenPda as findAssociatedTokenPda40,
+  findAssociatedTokenPda as findAssociatedTokenPda39,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS19
 } from "@solana-program/token-2022";
 async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
@@ -16342,12 +16169,12 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
   const pool = marketMaker == 0 /* Orca */ ? await fetchWhirlpool4(rpc, poolAddress) : await fetchFusionPool4(rpc, poolAddress);
   const mintA = await fetchMint(rpc, pool.data.tokenMintA);
   const mintB = await fetchMint(rpc, pool.data.tokenMintB);
-  const feeRecipientAtaA = (await findAssociatedTokenPda40({
+  const feeRecipientAtaA = (await findAssociatedTokenPda39({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda40({
+  const feeRecipientAtaB = (await findAssociatedTokenPda39({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -16356,12 +16183,12 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
     (await getLendingVaultAddress(mintA.address))[0],
     (await getLendingVaultAddress(mintB.address))[0]
   ]);
-  const vaultAAta = (await findAssociatedTokenPda40({
+  const vaultAAta = (await findAssociatedTokenPda39({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda40({
+  const vaultBAta = (await findAssociatedTokenPda39({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -16369,7 +16196,7 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
   const addresses = [
     SYSTEM_PROGRAM_ADDRESS,
     address3("SysvarRent111111111111111111111111111111111"),
-    ASSOCIATED_TOKEN_PROGRAM_ADDRESS9,
+    ASSOCIATED_TOKEN_PROGRAM_ADDRESS8,
     TOKEN_PROGRAM_ADDRESS2,
     TOKEN_2022_PROGRAM_ADDRESS19,
     NATIVE_MINT,
@@ -16392,7 +16219,7 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
   if (vaultA.data.pythOraclePriceUpdate != DEFAULT_ADDRESS) addresses.push(vaultA.data.pythOraclePriceUpdate);
   if (vaultB.data.pythOraclePriceUpdate != DEFAULT_ADDRESS) addresses.push(vaultB.data.pythOraclePriceUpdate);
   if (marketMaker == 0 /* Orca */) {
-    addresses.push(WHIRLPOOL_PROGRAM_ADDRESS15);
+    addresses.push(WHIRLPOOL_PROGRAM_ADDRESS16);
     addresses.push(WP_NFT_UPDATE_AUTH);
     addresses.push(orcaOracleAddress);
     const whirlpool = pool;
@@ -16404,7 +16231,7 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
       }
     }
   } else {
-    addresses.push(FUSIONAMM_PROGRAM_ADDRESS15);
+    addresses.push(FUSIONAMM_PROGRAM_ADDRESS16);
     addresses.push(FP_NFT_UPDATE_AUTH3);
   }
   return addresses;
@@ -16429,16 +16256,16 @@ async function extendAddressLookupTableForMarketInstructions(rpc, poolAddress, m
 
 // src/txbuilder/repayTunaLpPositionDebt.ts
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS29 } from "@solana-program/memo";
-import { fetchAllMaybeMint as fetchAllMaybeMint31, findAssociatedTokenPda as findAssociatedTokenPda41 } from "@solana-program/token-2022";
-import assert31 from "assert";
+import { fetchAllMaybeMint as fetchAllMaybeMint30, findAssociatedTokenPda as findAssociatedTokenPda40 } from "@solana-program/token-2022";
+import assert30 from "assert";
 async function repayTunaLpPositionDebtInstructions(rpc, authority, positionMint, collateralA, collateralB, createInstructions, cleanupInstructions) {
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
   const tunaPosition = await fetchTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
-  const [mintA, mintB] = await fetchAllMaybeMint31(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  assert31(mintA.exists, "Token A not found");
-  assert31(mintB.exists, "Token B not found");
+  const [mintA, mintB] = await fetchAllMaybeMint30(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  assert30(mintA.exists, "Token A not found");
+  assert30(mintB.exists, "Token B not found");
   const marketAddress = (await getMarketAddress(tunaPosition.data.pool))[0];
   const createUserAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -16474,34 +16301,34 @@ async function repayTunaLpPositionDebtInstructions(rpc, authority, positionMint,
 }
 async function repayTunaLpPositionDebtInstruction(authority, positionMint, mintA, mintB, marketAddress, collateralA, collateralB) {
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda41({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda40({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda41({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda40({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda41({
+  const tunaPositionAtaA = (await findAssociatedTokenPda40({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda41({
+  const tunaPositionAtaB = (await findAssociatedTokenPda40({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const vaultAAddress = (await getLendingVaultAddress(mintA.address))[0];
-  const vaultAAta = (await findAssociatedTokenPda41({
+  const vaultAAta = (await findAssociatedTokenPda40({
     owner: vaultAAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
   const vaultBAddress = (await getLendingVaultAddress(mintB.address))[0];
-  const vaultBAta = (await findAssociatedTokenPda41({
+  const vaultBAta = (await findAssociatedTokenPda40({
     owner: vaultBAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -16531,12 +16358,12 @@ async function repayTunaLpPositionDebtInstruction(authority, positionMint, mintA
 // src/txbuilder/rebalanceTunaLpPositionOrca.ts
 import {
   fetchAllMaybeTickArray as fetchAllMaybeTickArray4,
-  fetchMaybeWhirlpool as fetchMaybeWhirlpool12,
+  fetchMaybeWhirlpool as fetchMaybeWhirlpool11,
   getDynamicTickArrayMinSize as getDynamicTickArrayMinSize2,
   getInitializeDynamicTickArrayInstruction as getInitializeDynamicTickArrayInstruction3,
   getOracleAddress as getOracleAddress12,
   getPositionAddress as getPositionAddress19,
-  WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS16
+  WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS17
 } from "@orca-so/whirlpools-client";
 import {
   AccountRole as AccountRole25,
@@ -16545,26 +16372,26 @@ import {
 import { fetchSysvarRent as fetchSysvarRent3 } from "@solana/sysvars";
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS30 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint32,
-  findAssociatedTokenPda as findAssociatedTokenPda42,
+  fetchAllMaybeMint as fetchAllMaybeMint31,
+  findAssociatedTokenPda as findAssociatedTokenPda41,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS20
 } from "@solana-program/token-2022";
-import assert32 from "assert";
+import assert31 from "assert";
 async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await fetchSysvarRent3(rpc);
   let nonRefundableRent = 0n;
   const tunaConfig = await fetchTunaConfig(rpc, (await getTunaConfigAddress())[0]);
   const tunaPosition = await fetchMaybeTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
   if (!tunaPosition.exists) throw new Error("Tuna position account not found");
-  const whirlpool = await fetchMaybeWhirlpool12(rpc, tunaPosition.data.pool);
+  const whirlpool = await fetchMaybeWhirlpool11(rpc, tunaPosition.data.pool);
   if (!whirlpool.exists) throw new Error("Whirlpool account not found");
   const [vaultA, vaultB] = await fetchAllVault(rpc, [
     (await getLendingVaultAddress(whirlpool.data.tokenMintA))[0],
     (await getLendingVaultAddress(whirlpool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint32(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  assert32(mintA.exists, "Token A account not found");
-  assert32(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint31(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  assert31(mintA.exists, "Token A account not found");
+  assert31(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -16636,27 +16463,27 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
   const orcaPositionAddress = (await getPositionAddress19(positionMint))[0];
   const orcaOracleAddress = (await getOracleAddress12(whirlpool.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda42({
+  const tunaPositionAta = (await findAssociatedTokenPda41({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS20
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda42({
+  const tunaPositionAtaA = (await findAssociatedTokenPda41({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda42({
+  const tunaPositionAtaB = (await findAssociatedTokenPda41({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda42({
+  const feeRecipientAtaA = (await findAssociatedTokenPda41({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda42({
+  const feeRecipientAtaB = (await findAssociatedTokenPda41({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -16715,7 +16542,7 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
     feeRecipientAtaA,
     feeRecipientAtaB,
     whirlpool: whirlpool.address,
-    whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS16,
+    whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS17,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
     memoProgram: MEMO_PROGRAM_ADDRESS30,
@@ -16728,8 +16555,8 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
 // src/txbuilder/rebalanceTunaLpPositionFusion.ts
 import {
   fetchAllMaybeTickArray as fetchAllMaybeTickArray5,
-  fetchMaybeFusionPool as fetchMaybeFusionPool12,
-  FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS16,
+  fetchMaybeFusionPool as fetchMaybeFusionPool11,
+  FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS17,
   getInitializeTickArrayInstruction as getInitializeTickArrayInstruction3,
   getPositionAddress as getPositionAddress20,
   getTickArraySize as getTickArraySize2
@@ -16741,26 +16568,26 @@ import {
 import { fetchSysvarRent as fetchSysvarRent4 } from "@solana/sysvars";
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS31 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint33,
-  findAssociatedTokenPda as findAssociatedTokenPda43,
+  fetchAllMaybeMint as fetchAllMaybeMint32,
+  findAssociatedTokenPda as findAssociatedTokenPda42,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS21
 } from "@solana-program/token-2022";
-import assert33 from "assert";
+import assert32 from "assert";
 async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await fetchSysvarRent4(rpc);
   let nonRefundableRent = 0n;
   const tunaConfig = await fetchTunaConfig(rpc, (await getTunaConfigAddress())[0]);
   const tunaPosition = await fetchMaybeTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
   if (!tunaPosition.exists) throw new Error("Tuna position account not found");
-  const fusionPool = await fetchMaybeFusionPool12(rpc, tunaPosition.data.pool);
+  const fusionPool = await fetchMaybeFusionPool11(rpc, tunaPosition.data.pool);
   if (!fusionPool.exists) throw new Error("FusionPool account not found");
   const [vaultA, vaultB] = await fetchAllVault(rpc, [
     (await getLendingVaultAddress(fusionPool.data.tokenMintA))[0],
     (await getLendingVaultAddress(fusionPool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint33(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  assert33(mintA.exists, "Token A account not found");
-  assert33(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint32(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  assert32(mintA.exists, "Token A account not found");
+  assert32(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -16827,27 +16654,27 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
   const positionMint = tunaPosition.data.positionMint;
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
   const fusionPositionAddress = (await getPositionAddress20(positionMint))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda43({
+  const tunaPositionAta = (await findAssociatedTokenPda42({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS21
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda43({
+  const tunaPositionAtaA = (await findAssociatedTokenPda42({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda43({
+  const tunaPositionAtaB = (await findAssociatedTokenPda42({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda43({
+  const feeRecipientAtaA = (await findAssociatedTokenPda42({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda43({
+  const feeRecipientAtaB = (await findAssociatedTokenPda42({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -16904,7 +16731,7 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
     feeRecipientAtaA,
     feeRecipientAtaB,
     fusionPool: fusionPool.address,
-    fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS16,
+    fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS17,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
     memoProgram: MEMO_PROGRAM_ADDRESS31,
@@ -16973,8 +16800,7 @@ export {
   OPEN_LENDING_POSITION_DISCRIMINATOR,
   OPEN_TUNA_LP_POSITION_FUSION_DISCRIMINATOR,
   OPEN_TUNA_LP_POSITION_ORCA_DISCRIMINATOR,
-  OPEN_TUNA_SPOT_POSITION_FUSION_DISCRIMINATOR,
-  OPEN_TUNA_SPOT_POSITION_ORCA_DISCRIMINATOR,
+  OPEN_TUNA_SPOT_POSITION_DISCRIMINATOR,
   OrcaUtils,
   PoolToken,
   REBALANCE_TUNA_LP_POSITION_FUSION_DISCRIMINATOR,
@@ -17008,6 +16834,7 @@ export {
   TUNA_ERROR__INVALID_INSTRUCTION_ARGUMENTS,
   TUNA_ERROR__INVALID_JUPITER_ROUTE,
   TUNA_ERROR__INVALID_MARKET_MAKER,
+  TUNA_ERROR__INVALID_POOL,
   TUNA_ERROR__INVALID_REMAINING_ACCOUNTS_LENGTH,
   TUNA_ERROR__INVALID_SQRT_PRICE_LIMIT_DIRECTION,
   TUNA_ERROR__INVALID_TICK_ARRAY_SEQUENCE,
@@ -17349,16 +17176,11 @@ export {
   getOpenTunaLpPositionOrcaInstructionDataCodec,
   getOpenTunaLpPositionOrcaInstructionDataDecoder,
   getOpenTunaLpPositionOrcaInstructionDataEncoder,
-  getOpenTunaSpotPositionFusionDiscriminatorBytes,
-  getOpenTunaSpotPositionFusionInstruction,
-  getOpenTunaSpotPositionFusionInstructionDataCodec,
-  getOpenTunaSpotPositionFusionInstructionDataDecoder,
-  getOpenTunaSpotPositionFusionInstructionDataEncoder,
-  getOpenTunaSpotPositionOrcaDiscriminatorBytes,
-  getOpenTunaSpotPositionOrcaInstruction,
-  getOpenTunaSpotPositionOrcaInstructionDataCodec,
-  getOpenTunaSpotPositionOrcaInstructionDataDecoder,
-  getOpenTunaSpotPositionOrcaInstructionDataEncoder,
+  getOpenTunaSpotPositionDiscriminatorBytes,
+  getOpenTunaSpotPositionInstruction,
+  getOpenTunaSpotPositionInstructionDataCodec,
+  getOpenTunaSpotPositionInstructionDataDecoder,
+  getOpenTunaSpotPositionInstructionDataEncoder,
   getPoolTokenCodec,
   getPoolTokenDecoder,
   getPoolTokenEncoder,
@@ -17532,10 +17354,8 @@ export {
   openLendingPositionInstruction,
   openTunaLpPositionFusionInstruction,
   openTunaLpPositionOrcaInstruction,
-  openTunaSpotPositionFusionInstruction,
-  openTunaSpotPositionFusionInstructions,
-  openTunaSpotPositionOrcaInstruction,
-  openTunaSpotPositionOrcaInstructions,
+  openTunaSpotPositionInstruction,
+  openTunaSpotPositionInstructions,
   parseCloseActiveTunaSpotPositionFusionInstruction,
   parseCloseActiveTunaSpotPositionOrcaInstruction,
   parseCloseTunaLpPositionFusionInstruction,
@@ -17571,8 +17391,7 @@ export {
   parseOpenLendingPositionInstruction,
   parseOpenTunaLpPositionFusionInstruction,
   parseOpenTunaLpPositionOrcaInstruction,
-  parseOpenTunaSpotPositionFusionInstruction,
-  parseOpenTunaSpotPositionOrcaInstruction,
+  parseOpenTunaSpotPositionInstruction,
   parseRebalanceTunaLpPositionFusionInstruction,
   parseRebalanceTunaLpPositionOrcaInstruction,
   parseRepayBadDebtInstruction,