@crypticdot/defituna-client 3.0.2 → 3.0.4

package/dist/index.mjs

@@ -997,21 +997,22 @@ var TunaInstruction = /* @__PURE__ */ ((TunaInstruction2) => {
   TunaInstruction2[TunaInstruction2["RebalanceTunaLpPositionOrca"] = 36] = "RebalanceTunaLpPositionOrca";
   TunaInstruction2[TunaInstruction2["RepayBadDebt"] = 37] = "RepayBadDebt";
   TunaInstruction2[TunaInstruction2["RepayTunaLpPositionDebt"] = 38] = "RepayTunaLpPositionDebt";
-  TunaInstruction2[TunaInstruction2["SetAdminAuthority"] = 39] = "SetAdminAuthority";
-  TunaInstruction2[TunaInstruction2["SetDefaultMaxPercentageOfLeftovers"] = 40] = "SetDefaultMaxPercentageOfLeftovers";
-  TunaInstruction2[TunaInstruction2["SetDefaultMaxSwapSlippage"] = 41] = "SetDefaultMaxSwapSlippage";
-  TunaInstruction2[TunaInstruction2["SetDefaultOraclePriceDeviationThreshold"] = 42] = "SetDefaultOraclePriceDeviationThreshold";
-  TunaInstruction2[TunaInstruction2["SetFeeRecipient"] = 43] = "SetFeeRecipient";
-  TunaInstruction2[TunaInstruction2["SetLiquidatorAuthority"] = 44] = "SetLiquidatorAuthority";
-  TunaInstruction2[TunaInstruction2["SetOwnerAuthority"] = 45] = "SetOwnerAuthority";
-  TunaInstruction2[TunaInstruction2["SetSuspendedState"] = 46] = "SetSuspendedState";
-  TunaInstruction2[TunaInstruction2["SetTunaLpPositionFlags"] = 47] = "SetTunaLpPositionFlags";
-  TunaInstruction2[TunaInstruction2["SetTunaLpPositionLimitOrders"] = 48] = "SetTunaLpPositionLimitOrders";
-  TunaInstruction2[TunaInstruction2["SetTunaLpPositionRebalanceThreshold"] = 49] = "SetTunaLpPositionRebalanceThreshold";
-  TunaInstruction2[TunaInstruction2["SetTunaSpotPositionLimitOrders"] = 50] = "SetTunaSpotPositionLimitOrders";
-  TunaInstruction2[TunaInstruction2["UpdateMarket"] = 51] = "UpdateMarket";
-  TunaInstruction2[TunaInstruction2["UpdateVault"] = 52] = "UpdateVault";
-  TunaInstruction2[TunaInstruction2["Withdraw"] = 53] = "Withdraw";
+  TunaInstruction2[TunaInstruction2["ResetTunaSpotPosition"] = 39] = "ResetTunaSpotPosition";
+  TunaInstruction2[TunaInstruction2["SetAdminAuthority"] = 40] = "SetAdminAuthority";
+  TunaInstruction2[TunaInstruction2["SetDefaultMaxPercentageOfLeftovers"] = 41] = "SetDefaultMaxPercentageOfLeftovers";
+  TunaInstruction2[TunaInstruction2["SetDefaultMaxSwapSlippage"] = 42] = "SetDefaultMaxSwapSlippage";
+  TunaInstruction2[TunaInstruction2["SetDefaultOraclePriceDeviationThreshold"] = 43] = "SetDefaultOraclePriceDeviationThreshold";
+  TunaInstruction2[TunaInstruction2["SetFeeRecipient"] = 44] = "SetFeeRecipient";
+  TunaInstruction2[TunaInstruction2["SetLiquidatorAuthority"] = 45] = "SetLiquidatorAuthority";
+  TunaInstruction2[TunaInstruction2["SetOwnerAuthority"] = 46] = "SetOwnerAuthority";
+  TunaInstruction2[TunaInstruction2["SetSuspendedState"] = 47] = "SetSuspendedState";
+  TunaInstruction2[TunaInstruction2["SetTunaLpPositionFlags"] = 48] = "SetTunaLpPositionFlags";
+  TunaInstruction2[TunaInstruction2["SetTunaLpPositionLimitOrders"] = 49] = "SetTunaLpPositionLimitOrders";
+  TunaInstruction2[TunaInstruction2["SetTunaLpPositionRebalanceThreshold"] = 50] = "SetTunaLpPositionRebalanceThreshold";
+  TunaInstruction2[TunaInstruction2["SetTunaSpotPositionLimitOrders"] = 51] = "SetTunaSpotPositionLimitOrders";
+  TunaInstruction2[TunaInstruction2["UpdateMarket"] = 52] = "UpdateMarket";
+  TunaInstruction2[TunaInstruction2["UpdateVault"] = 53] = "UpdateVault";
+  TunaInstruction2[TunaInstruction2["Withdraw"] = 54] = "Withdraw";
   return TunaInstruction2;
 })(TunaInstruction || {});
 function identifyTunaInstruction(instruction) {
@@ -1367,6 +1368,15 @@ function identifyTunaInstruction(instruction) {
   )) {
     return 38 /* RepayTunaLpPositionDebt */;
   }
+  if (containsBytes(
+    data,
+    fixEncoderSize7(getBytesEncoder7(), 8).encode(
+      new Uint8Array([194, 68, 113, 71, 103, 77, 29, 127])
+    ),
+    0
+  )) {
+    return 39 /* ResetTunaSpotPosition */;
+  }
   if (containsBytes(
     data,
     fixEncoderSize7(getBytesEncoder7(), 8).encode(
@@ -1374,7 +1384,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 39 /* SetAdminAuthority */;
+    return 40 /* SetAdminAuthority */;
   }
   if (containsBytes(
     data,
@@ -1383,7 +1393,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 40 /* SetDefaultMaxPercentageOfLeftovers */;
+    return 41 /* SetDefaultMaxPercentageOfLeftovers */;
   }
   if (containsBytes(
     data,
@@ -1392,7 +1402,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 41 /* SetDefaultMaxSwapSlippage */;
+    return 42 /* SetDefaultMaxSwapSlippage */;
   }
   if (containsBytes(
     data,
@@ -1401,7 +1411,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 42 /* SetDefaultOraclePriceDeviationThreshold */;
+    return 43 /* SetDefaultOraclePriceDeviationThreshold */;
   }
   if (containsBytes(
     data,
@@ -1410,7 +1420,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 43 /* SetFeeRecipient */;
+    return 44 /* SetFeeRecipient */;
   }
   if (containsBytes(
     data,
@@ -1419,7 +1429,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 44 /* SetLiquidatorAuthority */;
+    return 45 /* SetLiquidatorAuthority */;
   }
   if (containsBytes(
     data,
@@ -1428,7 +1438,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 45 /* SetOwnerAuthority */;
+    return 46 /* SetOwnerAuthority */;
   }
   if (containsBytes(
     data,
@@ -1437,7 +1447,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 46 /* SetSuspendedState */;
+    return 47 /* SetSuspendedState */;
   }
   if (containsBytes(
     data,
@@ -1446,7 +1456,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 47 /* SetTunaLpPositionFlags */;
+    return 48 /* SetTunaLpPositionFlags */;
   }
   if (containsBytes(
     data,
@@ -1455,7 +1465,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 48 /* SetTunaLpPositionLimitOrders */;
+    return 49 /* SetTunaLpPositionLimitOrders */;
   }
   if (containsBytes(
     data,
@@ -1464,7 +1474,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 49 /* SetTunaLpPositionRebalanceThreshold */;
+    return 50 /* SetTunaLpPositionRebalanceThreshold */;
   }
   if (containsBytes(
     data,
@@ -1473,7 +1483,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 50 /* SetTunaSpotPositionLimitOrders */;
+    return 51 /* SetTunaSpotPositionLimitOrders */;
   }
   if (containsBytes(
     data,
@@ -1482,7 +1492,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 51 /* UpdateMarket */;
+    return 52 /* UpdateMarket */;
   }
   if (containsBytes(
     data,
@@ -1491,7 +1501,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 52 /* UpdateVault */;
+    return 53 /* UpdateVault */;
   }
   if (containsBytes(
     data,
@@ -1500,7 +1510,7 @@ function identifyTunaInstruction(instruction) {
     ),
     0
   )) {
-    return 53 /* Withdraw */;
+    return 54 /* Withdraw */;
   }
   throw new Error(
     "The provided instruction could not be identified as a tuna instruction."
@@ -8279,19 +8289,138 @@ function parseRepayTunaLpPositionDebtInstruction(instruction) {
   };
 }
 
-// src/generated/instructions/setAdminAuthority.ts
+// src/generated/instructions/resetTunaSpotPosition.ts
 import {
   combineCodec as combineCodec52,
   fixDecoderSize as fixDecoderSize46,
   fixEncoderSize as fixEncoderSize47,
-  getAddressDecoder as getAddressDecoder10,
-  getAddressEncoder as getAddressEncoder10,
   getBytesDecoder as getBytesDecoder46,
   getBytesEncoder as getBytesEncoder47,
   getStructDecoder as getStructDecoder48,
   getStructEncoder as getStructEncoder48,
+  getU128Decoder as getU128Decoder11,
+  getU128Encoder as getU128Encoder11,
   transformEncoder as transformEncoder46
 } from "@solana/kit";
+var RESET_TUNA_SPOT_POSITION_DISCRIMINATOR = new Uint8Array([
+  194,
+  68,
+  113,
+  71,
+  103,
+  77,
+  29,
+  127
+]);
+function getResetTunaSpotPositionDiscriminatorBytes() {
+  return fixEncoderSize47(getBytesEncoder47(), 8).encode(
+    RESET_TUNA_SPOT_POSITION_DISCRIMINATOR
+  );
+}
+function getResetTunaSpotPositionInstructionDataEncoder() {
+  return transformEncoder46(
+    getStructEncoder48([
+      ["discriminator", fixEncoderSize47(getBytesEncoder47(), 8)],
+      ["positionToken", getPoolTokenEncoder()],
+      ["collateralToken", getPoolTokenEncoder()],
+      ["lowerLimitOrderSqrtPrice", getU128Encoder11()],
+      ["upperLimitOrderSqrtPrice", getU128Encoder11()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: RESET_TUNA_SPOT_POSITION_DISCRIMINATOR
+    })
+  );
+}
+function getResetTunaSpotPositionInstructionDataDecoder() {
+  return getStructDecoder48([
+    ["discriminator", fixDecoderSize46(getBytesDecoder46(), 8)],
+    ["positionToken", getPoolTokenDecoder()],
+    ["collateralToken", getPoolTokenDecoder()],
+    ["lowerLimitOrderSqrtPrice", getU128Decoder11()],
+    ["upperLimitOrderSqrtPrice", getU128Decoder11()]
+  ]);
+}
+function getResetTunaSpotPositionInstructionDataCodec() {
+  return combineCodec52(
+    getResetTunaSpotPositionInstructionDataEncoder(),
+    getResetTunaSpotPositionInstructionDataDecoder()
+  );
+}
+function getResetTunaSpotPositionInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TUNA_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    authority: { value: input.authority ?? null, isWritable: false },
+    mintA: { value: input.mintA ?? null, isWritable: false },
+    mintB: { value: input.mintB ?? null, isWritable: false },
+    tunaPosition: { value: input.tunaPosition ?? null, isWritable: true },
+    tunaPositionAtaA: {
+      value: input.tunaPositionAtaA ?? null,
+      isWritable: true
+    },
+    tunaPositionAtaB: {
+      value: input.tunaPositionAtaB ?? null,
+      isWritable: true
+    }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.mintA),
+      getAccountMeta(accounts.mintB),
+      getAccountMeta(accounts.tunaPosition),
+      getAccountMeta(accounts.tunaPositionAtaA),
+      getAccountMeta(accounts.tunaPositionAtaB)
+    ],
+    programAddress,
+    data: getResetTunaSpotPositionInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseResetTunaSpotPositionInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    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(),
+      tunaPosition: getNextAccount(),
+      tunaPositionAtaA: getNextAccount(),
+      tunaPositionAtaB: getNextAccount()
+    },
+    data: getResetTunaSpotPositionInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/generated/instructions/setAdminAuthority.ts
+import {
+  combineCodec as combineCodec53,
+  fixDecoderSize as fixDecoderSize47,
+  fixEncoderSize as fixEncoderSize48,
+  getAddressDecoder as getAddressDecoder10,
+  getAddressEncoder as getAddressEncoder10,
+  getBytesDecoder as getBytesDecoder47,
+  getBytesEncoder as getBytesEncoder48,
+  getStructDecoder as getStructDecoder49,
+  getStructEncoder as getStructEncoder49,
+  transformEncoder as transformEncoder47
+} from "@solana/kit";
 var SET_ADMIN_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   72,
   49,
@@ -8303,27 +8432,27 @@ var SET_ADMIN_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   174
 ]);
 function getSetAdminAuthorityDiscriminatorBytes() {
-  return fixEncoderSize47(getBytesEncoder47(), 8).encode(
+  return fixEncoderSize48(getBytesEncoder48(), 8).encode(
     SET_ADMIN_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetAdminAuthorityInstructionDataEncoder() {
-  return transformEncoder46(
-    getStructEncoder48([
-      ["discriminator", fixEncoderSize47(getBytesEncoder47(), 8)],
+  return transformEncoder47(
+    getStructEncoder49([
+      ["discriminator", fixEncoderSize48(getBytesEncoder48(), 8)],
       ["adminAuthority", getAddressEncoder10()]
     ]),
     (value) => ({ ...value, discriminator: SET_ADMIN_AUTHORITY_DISCRIMINATOR })
   );
 }
 function getSetAdminAuthorityInstructionDataDecoder() {
-  return getStructDecoder48([
-    ["discriminator", fixDecoderSize46(getBytesDecoder46(), 8)],
+  return getStructDecoder49([
+    ["discriminator", fixDecoderSize47(getBytesDecoder47(), 8)],
     ["adminAuthority", getAddressDecoder10()]
   ]);
 }
 function getSetAdminAuthorityInstructionDataCodec() {
-  return combineCodec52(
+  return combineCodec53(
     getSetAdminAuthorityInstructionDataEncoder(),
     getSetAdminAuthorityInstructionDataDecoder()
   );
@@ -8371,27 +8500,27 @@ function parseSetAdminAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setDefaultMaxPercentageOfLeftovers.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 combineCodec54,
+  fixDecoderSize as fixDecoderSize48,
+  fixEncoderSize as fixEncoderSize49,
+  getBytesDecoder as getBytesDecoder48,
+  getBytesEncoder as getBytesEncoder49,
+  getStructDecoder as getStructDecoder50,
+  getStructEncoder as getStructEncoder50,
   getU32Decoder as getU32Decoder28,
   getU32Encoder as getU32Encoder28,
-  transformEncoder as transformEncoder47
+  transformEncoder as transformEncoder48
 } from "@solana/kit";
 var SET_DEFAULT_MAX_PERCENTAGE_OF_LEFTOVERS_DISCRIMINATOR = new Uint8Array([37, 179, 107, 65, 203, 141, 183, 27]);
 function getSetDefaultMaxPercentageOfLeftoversDiscriminatorBytes() {
-  return fixEncoderSize48(getBytesEncoder48(), 8).encode(
+  return fixEncoderSize49(getBytesEncoder49(), 8).encode(
     SET_DEFAULT_MAX_PERCENTAGE_OF_LEFTOVERS_DISCRIMINATOR
   );
 }
 function getSetDefaultMaxPercentageOfLeftoversInstructionDataEncoder() {
-  return transformEncoder47(
-    getStructEncoder49([
-      ["discriminator", fixEncoderSize48(getBytesEncoder48(), 8)],
+  return transformEncoder48(
+    getStructEncoder50([
+      ["discriminator", fixEncoderSize49(getBytesEncoder49(), 8)],
       ["maxPercentageOfLeftovers", getU32Encoder28()]
     ]),
     (value) => ({
@@ -8401,13 +8530,13 @@ function getSetDefaultMaxPercentageOfLeftoversInstructionDataEncoder() {
   );
 }
 function getSetDefaultMaxPercentageOfLeftoversInstructionDataDecoder() {
-  return getStructDecoder49([
-    ["discriminator", fixDecoderSize47(getBytesDecoder47(), 8)],
+  return getStructDecoder50([
+    ["discriminator", fixDecoderSize48(getBytesDecoder48(), 8)],
     ["maxPercentageOfLeftovers", getU32Decoder28()]
   ]);
 }
 function getSetDefaultMaxPercentageOfLeftoversInstructionDataCodec() {
-  return combineCodec53(
+  return combineCodec54(
     getSetDefaultMaxPercentageOfLeftoversInstructionDataEncoder(),
     getSetDefaultMaxPercentageOfLeftoversInstructionDataDecoder()
   );
@@ -8457,16 +8586,16 @@ function parseSetDefaultMaxPercentageOfLeftoversInstruction(instruction) {
 
 // src/generated/instructions/setDefaultMaxSwapSlippage.ts
 import {
-  combineCodec as combineCodec54,
-  fixDecoderSize as fixDecoderSize48,
-  fixEncoderSize as fixEncoderSize49,
-  getBytesDecoder as getBytesDecoder48,
-  getBytesEncoder as getBytesEncoder49,
-  getStructDecoder as getStructDecoder50,
-  getStructEncoder as getStructEncoder50,
+  combineCodec as combineCodec55,
+  fixDecoderSize as fixDecoderSize49,
+  fixEncoderSize as fixEncoderSize50,
+  getBytesDecoder as getBytesDecoder49,
+  getBytesEncoder as getBytesEncoder50,
+  getStructDecoder as getStructDecoder51,
+  getStructEncoder as getStructEncoder51,
   getU32Decoder as getU32Decoder29,
   getU32Encoder as getU32Encoder29,
-  transformEncoder as transformEncoder48
+  transformEncoder as transformEncoder49
 } from "@solana/kit";
 var SET_DEFAULT_MAX_SWAP_SLIPPAGE_DISCRIMINATOR = new Uint8Array([
   122,
@@ -8479,14 +8608,14 @@ var SET_DEFAULT_MAX_SWAP_SLIPPAGE_DISCRIMINATOR = new Uint8Array([
   181
 ]);
 function getSetDefaultMaxSwapSlippageDiscriminatorBytes() {
-  return fixEncoderSize49(getBytesEncoder49(), 8).encode(
+  return fixEncoderSize50(getBytesEncoder50(), 8).encode(
     SET_DEFAULT_MAX_SWAP_SLIPPAGE_DISCRIMINATOR
   );
 }
 function getSetDefaultMaxSwapSlippageInstructionDataEncoder() {
-  return transformEncoder48(
-    getStructEncoder50([
-      ["discriminator", fixEncoderSize49(getBytesEncoder49(), 8)],
+  return transformEncoder49(
+    getStructEncoder51([
+      ["discriminator", fixEncoderSize50(getBytesEncoder50(), 8)],
       ["maxSwapSlippage", getU32Encoder29()]
     ]),
     (value) => ({
@@ -8496,13 +8625,13 @@ function getSetDefaultMaxSwapSlippageInstructionDataEncoder() {
   );
 }
 function getSetDefaultMaxSwapSlippageInstructionDataDecoder() {
-  return getStructDecoder50([
-    ["discriminator", fixDecoderSize48(getBytesDecoder48(), 8)],
+  return getStructDecoder51([
+    ["discriminator", fixDecoderSize49(getBytesDecoder49(), 8)],
     ["maxSwapSlippage", getU32Decoder29()]
   ]);
 }
 function getSetDefaultMaxSwapSlippageInstructionDataCodec() {
-  return combineCodec54(
+  return combineCodec55(
     getSetDefaultMaxSwapSlippageInstructionDataEncoder(),
     getSetDefaultMaxSwapSlippageInstructionDataDecoder()
   );
@@ -8552,27 +8681,27 @@ function parseSetDefaultMaxSwapSlippageInstruction(instruction) {
 
 // src/generated/instructions/setDefaultOraclePriceDeviationThreshold.ts
 import {
-  combineCodec as combineCodec55,
-  fixDecoderSize as fixDecoderSize49,
-  fixEncoderSize as fixEncoderSize50,
-  getBytesDecoder as getBytesDecoder49,
-  getBytesEncoder as getBytesEncoder50,
-  getStructDecoder as getStructDecoder51,
-  getStructEncoder as getStructEncoder51,
+  combineCodec as combineCodec56,
+  fixDecoderSize as fixDecoderSize50,
+  fixEncoderSize as fixEncoderSize51,
+  getBytesDecoder as getBytesDecoder50,
+  getBytesEncoder as getBytesEncoder51,
+  getStructDecoder as getStructDecoder52,
+  getStructEncoder as getStructEncoder52,
   getU32Decoder as getU32Decoder30,
   getU32Encoder as getU32Encoder30,
-  transformEncoder as transformEncoder49
+  transformEncoder as transformEncoder50
 } from "@solana/kit";
 var SET_DEFAULT_ORACLE_PRICE_DEVIATION_THRESHOLD_DISCRIMINATOR = new Uint8Array([142, 158, 143, 67, 206, 91, 139, 120]);
 function getSetDefaultOraclePriceDeviationThresholdDiscriminatorBytes() {
-  return fixEncoderSize50(getBytesEncoder50(), 8).encode(
+  return fixEncoderSize51(getBytesEncoder51(), 8).encode(
     SET_DEFAULT_ORACLE_PRICE_DEVIATION_THRESHOLD_DISCRIMINATOR
   );
 }
 function getSetDefaultOraclePriceDeviationThresholdInstructionDataEncoder() {
-  return transformEncoder49(
-    getStructEncoder51([
-      ["discriminator", fixEncoderSize50(getBytesEncoder50(), 8)],
+  return transformEncoder50(
+    getStructEncoder52([
+      ["discriminator", fixEncoderSize51(getBytesEncoder51(), 8)],
       ["oraclePriceDeviationThreshold", getU32Encoder30()]
     ]),
     (value) => ({
@@ -8582,13 +8711,13 @@ function getSetDefaultOraclePriceDeviationThresholdInstructionDataEncoder() {
   );
 }
 function getSetDefaultOraclePriceDeviationThresholdInstructionDataDecoder() {
-  return getStructDecoder51([
-    ["discriminator", fixDecoderSize49(getBytesDecoder49(), 8)],
+  return getStructDecoder52([
+    ["discriminator", fixDecoderSize50(getBytesDecoder50(), 8)],
     ["oraclePriceDeviationThreshold", getU32Decoder30()]
   ]);
 }
 function getSetDefaultOraclePriceDeviationThresholdInstructionDataCodec() {
-  return combineCodec55(
+  return combineCodec56(
     getSetDefaultOraclePriceDeviationThresholdInstructionDataEncoder(),
     getSetDefaultOraclePriceDeviationThresholdInstructionDataDecoder()
   );
@@ -8638,16 +8767,16 @@ function parseSetDefaultOraclePriceDeviationThresholdInstruction(instruction) {
 
 // src/generated/instructions/setFeeRecipient.ts
 import {
-  combineCodec as combineCodec56,
-  fixDecoderSize as fixDecoderSize50,
-  fixEncoderSize as fixEncoderSize51,
+  combineCodec as combineCodec57,
+  fixDecoderSize as fixDecoderSize51,
+  fixEncoderSize as fixEncoderSize52,
   getAddressDecoder as getAddressDecoder11,
   getAddressEncoder as getAddressEncoder11,
-  getBytesDecoder as getBytesDecoder50,
-  getBytesEncoder as getBytesEncoder51,
-  getStructDecoder as getStructDecoder52,
-  getStructEncoder as getStructEncoder52,
-  transformEncoder as transformEncoder50
+  getBytesDecoder as getBytesDecoder51,
+  getBytesEncoder as getBytesEncoder52,
+  getStructDecoder as getStructDecoder53,
+  getStructEncoder as getStructEncoder53,
+  transformEncoder as transformEncoder51
 } from "@solana/kit";
 var SET_FEE_RECIPIENT_DISCRIMINATOR = new Uint8Array([
   227,
@@ -8660,27 +8789,27 @@ var SET_FEE_RECIPIENT_DISCRIMINATOR = new Uint8Array([
   66
 ]);
 function getSetFeeRecipientDiscriminatorBytes() {
-  return fixEncoderSize51(getBytesEncoder51(), 8).encode(
+  return fixEncoderSize52(getBytesEncoder52(), 8).encode(
     SET_FEE_RECIPIENT_DISCRIMINATOR
   );
 }
 function getSetFeeRecipientInstructionDataEncoder() {
-  return transformEncoder50(
-    getStructEncoder52([
-      ["discriminator", fixEncoderSize51(getBytesEncoder51(), 8)],
+  return transformEncoder51(
+    getStructEncoder53([
+      ["discriminator", fixEncoderSize52(getBytesEncoder52(), 8)],
       ["feeRecipient", getAddressEncoder11()]
     ]),
     (value) => ({ ...value, discriminator: SET_FEE_RECIPIENT_DISCRIMINATOR })
   );
 }
 function getSetFeeRecipientInstructionDataDecoder() {
-  return getStructDecoder52([
-    ["discriminator", fixDecoderSize50(getBytesDecoder50(), 8)],
+  return getStructDecoder53([
+    ["discriminator", fixDecoderSize51(getBytesDecoder51(), 8)],
     ["feeRecipient", getAddressDecoder11()]
   ]);
 }
 function getSetFeeRecipientInstructionDataCodec() {
-  return combineCodec56(
+  return combineCodec57(
     getSetFeeRecipientInstructionDataEncoder(),
     getSetFeeRecipientInstructionDataDecoder()
   );
@@ -8728,16 +8857,16 @@ function parseSetFeeRecipientInstruction(instruction) {
 
 // src/generated/instructions/setLiquidatorAuthority.ts
 import {
-  combineCodec as combineCodec57,
-  fixDecoderSize as fixDecoderSize51,
-  fixEncoderSize as fixEncoderSize52,
+  combineCodec as combineCodec58,
+  fixDecoderSize as fixDecoderSize52,
+  fixEncoderSize as fixEncoderSize53,
   getAddressDecoder as getAddressDecoder12,
   getAddressEncoder as getAddressEncoder12,
-  getBytesDecoder as getBytesDecoder51,
-  getBytesEncoder as getBytesEncoder52,
-  getStructDecoder as getStructDecoder53,
-  getStructEncoder as getStructEncoder53,
-  transformEncoder as transformEncoder51
+  getBytesDecoder as getBytesDecoder52,
+  getBytesEncoder as getBytesEncoder53,
+  getStructDecoder as getStructDecoder54,
+  getStructEncoder as getStructEncoder54,
+  transformEncoder as transformEncoder52
 } from "@solana/kit";
 var SET_LIQUIDATOR_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   246,
@@ -8750,14 +8879,14 @@ var SET_LIQUIDATOR_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   143
 ]);
 function getSetLiquidatorAuthorityDiscriminatorBytes() {
-  return fixEncoderSize52(getBytesEncoder52(), 8).encode(
+  return fixEncoderSize53(getBytesEncoder53(), 8).encode(
     SET_LIQUIDATOR_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetLiquidatorAuthorityInstructionDataEncoder() {
-  return transformEncoder51(
-    getStructEncoder53([
-      ["discriminator", fixEncoderSize52(getBytesEncoder52(), 8)],
+  return transformEncoder52(
+    getStructEncoder54([
+      ["discriminator", fixEncoderSize53(getBytesEncoder53(), 8)],
       ["liquidatorAuthority", getAddressEncoder12()]
     ]),
     (value) => ({
@@ -8767,13 +8896,13 @@ function getSetLiquidatorAuthorityInstructionDataEncoder() {
   );
 }
 function getSetLiquidatorAuthorityInstructionDataDecoder() {
-  return getStructDecoder53([
-    ["discriminator", fixDecoderSize51(getBytesDecoder51(), 8)],
+  return getStructDecoder54([
+    ["discriminator", fixDecoderSize52(getBytesDecoder52(), 8)],
     ["liquidatorAuthority", getAddressDecoder12()]
   ]);
 }
 function getSetLiquidatorAuthorityInstructionDataCodec() {
-  return combineCodec57(
+  return combineCodec58(
     getSetLiquidatorAuthorityInstructionDataEncoder(),
     getSetLiquidatorAuthorityInstructionDataDecoder()
   );
@@ -8823,16 +8952,16 @@ function parseSetLiquidatorAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setOwnerAuthority.ts
 import {
-  combineCodec as combineCodec58,
-  fixDecoderSize as fixDecoderSize52,
-  fixEncoderSize as fixEncoderSize53,
+  combineCodec as combineCodec59,
+  fixDecoderSize as fixDecoderSize53,
+  fixEncoderSize as fixEncoderSize54,
   getAddressDecoder as getAddressDecoder13,
   getAddressEncoder as getAddressEncoder13,
-  getBytesDecoder as getBytesDecoder52,
-  getBytesEncoder as getBytesEncoder53,
-  getStructDecoder as getStructDecoder54,
-  getStructEncoder as getStructEncoder54,
-  transformEncoder as transformEncoder52
+  getBytesDecoder as getBytesDecoder53,
+  getBytesEncoder as getBytesEncoder54,
+  getStructDecoder as getStructDecoder55,
+  getStructEncoder as getStructEncoder55,
+  transformEncoder as transformEncoder53
 } from "@solana/kit";
 var SET_OWNER_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   128,
@@ -8845,27 +8974,27 @@ var SET_OWNER_AUTHORITY_DISCRIMINATOR = new Uint8Array([
   117
 ]);
 function getSetOwnerAuthorityDiscriminatorBytes() {
-  return fixEncoderSize53(getBytesEncoder53(), 8).encode(
+  return fixEncoderSize54(getBytesEncoder54(), 8).encode(
     SET_OWNER_AUTHORITY_DISCRIMINATOR
   );
 }
 function getSetOwnerAuthorityInstructionDataEncoder() {
-  return transformEncoder52(
-    getStructEncoder54([
-      ["discriminator", fixEncoderSize53(getBytesEncoder53(), 8)],
+  return transformEncoder53(
+    getStructEncoder55([
+      ["discriminator", fixEncoderSize54(getBytesEncoder54(), 8)],
       ["ownerAuthority", getAddressEncoder13()]
     ]),
     (value) => ({ ...value, discriminator: SET_OWNER_AUTHORITY_DISCRIMINATOR })
   );
 }
 function getSetOwnerAuthorityInstructionDataDecoder() {
-  return getStructDecoder54([
-    ["discriminator", fixDecoderSize52(getBytesDecoder52(), 8)],
+  return getStructDecoder55([
+    ["discriminator", fixDecoderSize53(getBytesDecoder53(), 8)],
     ["ownerAuthority", getAddressDecoder13()]
   ]);
 }
 function getSetOwnerAuthorityInstructionDataCodec() {
-  return combineCodec58(
+  return combineCodec59(
     getSetOwnerAuthorityInstructionDataEncoder(),
     getSetOwnerAuthorityInstructionDataDecoder()
   );
@@ -8913,16 +9042,16 @@ function parseSetOwnerAuthorityInstruction(instruction) {
 
 // src/generated/instructions/setSuspendedState.ts
 import {
-  combineCodec as combineCodec59,
-  fixDecoderSize as fixDecoderSize53,
-  fixEncoderSize as fixEncoderSize54,
+  combineCodec as combineCodec60,
+  fixDecoderSize as fixDecoderSize54,
+  fixEncoderSize as fixEncoderSize55,
   getBooleanDecoder as getBooleanDecoder7,
   getBooleanEncoder as getBooleanEncoder7,
-  getBytesDecoder as getBytesDecoder53,
-  getBytesEncoder as getBytesEncoder54,
-  getStructDecoder as getStructDecoder55,
-  getStructEncoder as getStructEncoder55,
-  transformEncoder as transformEncoder53
+  getBytesDecoder as getBytesDecoder54,
+  getBytesEncoder as getBytesEncoder55,
+  getStructDecoder as getStructDecoder56,
+  getStructEncoder as getStructEncoder56,
+  transformEncoder as transformEncoder54
 } from "@solana/kit";
 var SET_SUSPENDED_STATE_DISCRIMINATOR = new Uint8Array([
   145,
@@ -8935,14 +9064,14 @@ var SET_SUSPENDED_STATE_DISCRIMINATOR = new Uint8Array([
   32
 ]);
 function getSetSuspendedStateDiscriminatorBytes() {
-  return fixEncoderSize54(getBytesEncoder54(), 8).encode(
+  return fixEncoderSize55(getBytesEncoder55(), 8).encode(
     SET_SUSPENDED_STATE_DISCRIMINATOR
   );
 }
 function getSetSuspendedStateInstructionDataEncoder() {
-  return transformEncoder53(
-    getStructEncoder55([
-      ["discriminator", fixEncoderSize54(getBytesEncoder54(), 8)],
+  return transformEncoder54(
+    getStructEncoder56([
+      ["discriminator", fixEncoderSize55(getBytesEncoder55(), 8)],
       ["suspendLendingDeposits", getBooleanEncoder7()],
       ["suspendLendingWithdrawals", getBooleanEncoder7()],
       ["suspendAddLiquidity", getBooleanEncoder7()],
@@ -8952,8 +9081,8 @@ function getSetSuspendedStateInstructionDataEncoder() {
   );
 }
 function getSetSuspendedStateInstructionDataDecoder() {
-  return getStructDecoder55([
-    ["discriminator", fixDecoderSize53(getBytesDecoder53(), 8)],
+  return getStructDecoder56([
+    ["discriminator", fixDecoderSize54(getBytesDecoder54(), 8)],
     ["suspendLendingDeposits", getBooleanDecoder7()],
     ["suspendLendingWithdrawals", getBooleanDecoder7()],
     ["suspendAddLiquidity", getBooleanDecoder7()],
@@ -8961,7 +9090,7 @@ function getSetSuspendedStateInstructionDataDecoder() {
   ]);
 }
 function getSetSuspendedStateInstructionDataCodec() {
-  return combineCodec59(
+  return combineCodec60(
     getSetSuspendedStateInstructionDataEncoder(),
     getSetSuspendedStateInstructionDataDecoder()
   );
@@ -9009,16 +9138,16 @@ function parseSetSuspendedStateInstruction(instruction) {
 
 // src/generated/instructions/setTunaLpPositionFlags.ts
 import {
-  combineCodec as combineCodec60,
-  fixDecoderSize as fixDecoderSize54,
-  fixEncoderSize as fixEncoderSize55,
-  getBytesDecoder as getBytesDecoder54,
-  getBytesEncoder as getBytesEncoder55,
-  getStructDecoder as getStructDecoder56,
-  getStructEncoder as getStructEncoder56,
+  combineCodec as combineCodec61,
+  fixDecoderSize as fixDecoderSize55,
+  fixEncoderSize as fixEncoderSize56,
+  getBytesDecoder as getBytesDecoder55,
+  getBytesEncoder as getBytesEncoder56,
+  getStructDecoder as getStructDecoder57,
+  getStructEncoder as getStructEncoder57,
   getU32Decoder as getU32Decoder31,
   getU32Encoder as getU32Encoder31,
-  transformEncoder as transformEncoder54
+  transformEncoder as transformEncoder55
 } from "@solana/kit";
 var SET_TUNA_LP_POSITION_FLAGS_DISCRIMINATOR = new Uint8Array([
   110,
@@ -9031,14 +9160,14 @@ var SET_TUNA_LP_POSITION_FLAGS_DISCRIMINATOR = new Uint8Array([
   57
 ]);
 function getSetTunaLpPositionFlagsDiscriminatorBytes() {
-  return fixEncoderSize55(getBytesEncoder55(), 8).encode(
+  return fixEncoderSize56(getBytesEncoder56(), 8).encode(
     SET_TUNA_LP_POSITION_FLAGS_DISCRIMINATOR
   );
 }
 function getSetTunaLpPositionFlagsInstructionDataEncoder() {
-  return transformEncoder54(
-    getStructEncoder56([
-      ["discriminator", fixEncoderSize55(getBytesEncoder55(), 8)],
+  return transformEncoder55(
+    getStructEncoder57([
+      ["discriminator", fixEncoderSize56(getBytesEncoder56(), 8)],
       ["flags", getU32Encoder31()]
     ]),
     (value) => ({
@@ -9048,13 +9177,13 @@ function getSetTunaLpPositionFlagsInstructionDataEncoder() {
   );
 }
 function getSetTunaLpPositionFlagsInstructionDataDecoder() {
-  return getStructDecoder56([
-    ["discriminator", fixDecoderSize54(getBytesDecoder54(), 8)],
+  return getStructDecoder57([
+    ["discriminator", fixDecoderSize55(getBytesDecoder55(), 8)],
     ["flags", getU32Decoder31()]
   ]);
 }
 function getSetTunaLpPositionFlagsInstructionDataCodec() {
-  return combineCodec60(
+  return combineCodec61(
     getSetTunaLpPositionFlagsInstructionDataEncoder(),
     getSetTunaLpPositionFlagsInstructionDataDecoder()
   );
@@ -9104,18 +9233,18 @@ function parseSetTunaLpPositionFlagsInstruction(instruction) {
 
 // src/generated/instructions/setTunaLpPositionLimitOrders.ts
 import {
-  combineCodec as combineCodec61,
-  fixDecoderSize as fixDecoderSize55,
-  fixEncoderSize as fixEncoderSize56,
-  getBytesDecoder as getBytesDecoder55,
-  getBytesEncoder as getBytesEncoder56,
-  getStructDecoder as getStructDecoder57,
-  getStructEncoder as getStructEncoder57,
-  getU128Decoder as getU128Decoder11,
-  getU128Encoder as getU128Encoder11,
+  combineCodec as combineCodec62,
+  fixDecoderSize as fixDecoderSize56,
+  fixEncoderSize as fixEncoderSize57,
+  getBytesDecoder as getBytesDecoder56,
+  getBytesEncoder as getBytesEncoder57,
+  getStructDecoder as getStructDecoder58,
+  getStructEncoder as getStructEncoder58,
+  getU128Decoder as getU128Decoder12,
+  getU128Encoder as getU128Encoder12,
   getU8Decoder as getU8Decoder5,
   getU8Encoder as getU8Encoder5,
-  transformEncoder as transformEncoder55
+  transformEncoder as transformEncoder56
 } from "@solana/kit";
 var SET_TUNA_LP_POSITION_LIMIT_ORDERS_DISCRIMINATOR = new Uint8Array([
   65,
@@ -9128,16 +9257,16 @@ var SET_TUNA_LP_POSITION_LIMIT_ORDERS_DISCRIMINATOR = new Uint8Array([
   255
 ]);
 function getSetTunaLpPositionLimitOrdersDiscriminatorBytes() {
-  return fixEncoderSize56(getBytesEncoder56(), 8).encode(
+  return fixEncoderSize57(getBytesEncoder57(), 8).encode(
     SET_TUNA_LP_POSITION_LIMIT_ORDERS_DISCRIMINATOR
   );
 }
 function getSetTunaLpPositionLimitOrdersInstructionDataEncoder() {
-  return transformEncoder55(
-    getStructEncoder57([
-      ["discriminator", fixEncoderSize56(getBytesEncoder56(), 8)],
-      ["lowerLimitOrderSqrtPrice", getU128Encoder11()],
-      ["upperLimitOrderSqrtPrice", getU128Encoder11()],
+  return transformEncoder56(
+    getStructEncoder58([
+      ["discriminator", fixEncoderSize57(getBytesEncoder57(), 8)],
+      ["lowerLimitOrderSqrtPrice", getU128Encoder12()],
+      ["upperLimitOrderSqrtPrice", getU128Encoder12()],
       ["swapToTokenOnLimitOrder", getU8Encoder5()]
     ]),
     (value) => ({
@@ -9147,15 +9276,15 @@ function getSetTunaLpPositionLimitOrdersInstructionDataEncoder() {
   );
 }
 function getSetTunaLpPositionLimitOrdersInstructionDataDecoder() {
-  return getStructDecoder57([
-    ["discriminator", fixDecoderSize55(getBytesDecoder55(), 8)],
-    ["lowerLimitOrderSqrtPrice", getU128Decoder11()],
-    ["upperLimitOrderSqrtPrice", getU128Decoder11()],
+  return getStructDecoder58([
+    ["discriminator", fixDecoderSize56(getBytesDecoder56(), 8)],
+    ["lowerLimitOrderSqrtPrice", getU128Decoder12()],
+    ["upperLimitOrderSqrtPrice", getU128Decoder12()],
     ["swapToTokenOnLimitOrder", getU8Decoder5()]
   ]);
 }
 function getSetTunaLpPositionLimitOrdersInstructionDataCodec() {
-  return combineCodec61(
+  return combineCodec62(
     getSetTunaLpPositionLimitOrdersInstructionDataEncoder(),
     getSetTunaLpPositionLimitOrdersInstructionDataDecoder()
   );
@@ -9205,27 +9334,27 @@ function parseSetTunaLpPositionLimitOrdersInstruction(instruction) {
 
 // src/generated/instructions/setTunaLpPositionRebalanceThreshold.ts
 import {
-  combineCodec as combineCodec62,
-  fixDecoderSize as fixDecoderSize56,
-  fixEncoderSize as fixEncoderSize57,
-  getBytesDecoder as getBytesDecoder56,
-  getBytesEncoder as getBytesEncoder57,
-  getStructDecoder as getStructDecoder58,
-  getStructEncoder as getStructEncoder58,
+  combineCodec as combineCodec63,
+  fixDecoderSize as fixDecoderSize57,
+  fixEncoderSize as fixEncoderSize58,
+  getBytesDecoder as getBytesDecoder57,
+  getBytesEncoder as getBytesEncoder58,
+  getStructDecoder as getStructDecoder59,
+  getStructEncoder as getStructEncoder59,
   getU32Decoder as getU32Decoder32,
   getU32Encoder as getU32Encoder32,
-  transformEncoder as transformEncoder56
+  transformEncoder as transformEncoder57
 } from "@solana/kit";
 var SET_TUNA_LP_POSITION_REBALANCE_THRESHOLD_DISCRIMINATOR = new Uint8Array([244, 174, 185, 58, 90, 150, 162, 51]);
 function getSetTunaLpPositionRebalanceThresholdDiscriminatorBytes() {
-  return fixEncoderSize57(getBytesEncoder57(), 8).encode(
+  return fixEncoderSize58(getBytesEncoder58(), 8).encode(
     SET_TUNA_LP_POSITION_REBALANCE_THRESHOLD_DISCRIMINATOR
   );
 }
 function getSetTunaLpPositionRebalanceThresholdInstructionDataEncoder() {
-  return transformEncoder56(
-    getStructEncoder58([
-      ["discriminator", fixEncoderSize57(getBytesEncoder57(), 8)],
+  return transformEncoder57(
+    getStructEncoder59([
+      ["discriminator", fixEncoderSize58(getBytesEncoder58(), 8)],
       ["rebalanceThresholdTicks", getU32Encoder32()]
     ]),
     (value) => ({
@@ -9235,13 +9364,13 @@ function getSetTunaLpPositionRebalanceThresholdInstructionDataEncoder() {
   );
 }
 function getSetTunaLpPositionRebalanceThresholdInstructionDataDecoder() {
-  return getStructDecoder58([
-    ["discriminator", fixDecoderSize56(getBytesDecoder56(), 8)],
+  return getStructDecoder59([
+    ["discriminator", fixDecoderSize57(getBytesDecoder57(), 8)],
     ["rebalanceThresholdTicks", getU32Decoder32()]
   ]);
 }
 function getSetTunaLpPositionRebalanceThresholdInstructionDataCodec() {
-  return combineCodec62(
+  return combineCodec63(
     getSetTunaLpPositionRebalanceThresholdInstructionDataEncoder(),
     getSetTunaLpPositionRebalanceThresholdInstructionDataDecoder()
   );
@@ -9291,31 +9420,31 @@ function parseSetTunaLpPositionRebalanceThresholdInstruction(instruction) {
 
 // src/generated/instructions/setTunaSpotPositionLimitOrders.ts
 import {
-  combineCodec as combineCodec63,
-  fixDecoderSize as fixDecoderSize57,
-  fixEncoderSize as fixEncoderSize58,
-  getBytesDecoder as getBytesDecoder57,
-  getBytesEncoder as getBytesEncoder58,
-  getStructDecoder as getStructDecoder59,
-  getStructEncoder as getStructEncoder59,
-  getU128Decoder as getU128Decoder12,
-  getU128Encoder as getU128Encoder12,
-  transformEncoder as transformEncoder57
+  combineCodec as combineCodec64,
+  fixDecoderSize as fixDecoderSize58,
+  fixEncoderSize as fixEncoderSize59,
+  getBytesDecoder as getBytesDecoder58,
+  getBytesEncoder as getBytesEncoder59,
+  getStructDecoder as getStructDecoder60,
+  getStructEncoder as getStructEncoder60,
+  getU128Decoder as getU128Decoder13,
+  getU128Encoder as getU128Encoder13,
+  transformEncoder as transformEncoder58
 } from "@solana/kit";
 var SET_TUNA_SPOT_POSITION_LIMIT_ORDERS_DISCRIMINATOR = new Uint8Array(
   [10, 180, 19, 205, 169, 133, 52, 118]
 );
 function getSetTunaSpotPositionLimitOrdersDiscriminatorBytes() {
-  return fixEncoderSize58(getBytesEncoder58(), 8).encode(
+  return fixEncoderSize59(getBytesEncoder59(), 8).encode(
     SET_TUNA_SPOT_POSITION_LIMIT_ORDERS_DISCRIMINATOR
   );
 }
 function getSetTunaSpotPositionLimitOrdersInstructionDataEncoder() {
-  return transformEncoder57(
-    getStructEncoder59([
-      ["discriminator", fixEncoderSize58(getBytesEncoder58(), 8)],
-      ["lowerLimitOrderSqrtPrice", getU128Encoder12()],
-      ["upperLimitOrderSqrtPrice", getU128Encoder12()]
+  return transformEncoder58(
+    getStructEncoder60([
+      ["discriminator", fixEncoderSize59(getBytesEncoder59(), 8)],
+      ["lowerLimitOrderSqrtPrice", getU128Encoder13()],
+      ["upperLimitOrderSqrtPrice", getU128Encoder13()]
     ]),
     (value) => ({
       ...value,
@@ -9324,14 +9453,14 @@ function getSetTunaSpotPositionLimitOrdersInstructionDataEncoder() {
   );
 }
 function getSetTunaSpotPositionLimitOrdersInstructionDataDecoder() {
-  return getStructDecoder59([
-    ["discriminator", fixDecoderSize57(getBytesDecoder57(), 8)],
-    ["lowerLimitOrderSqrtPrice", getU128Decoder12()],
-    ["upperLimitOrderSqrtPrice", getU128Decoder12()]
+  return getStructDecoder60([
+    ["discriminator", fixDecoderSize58(getBytesDecoder58(), 8)],
+    ["lowerLimitOrderSqrtPrice", getU128Decoder13()],
+    ["upperLimitOrderSqrtPrice", getU128Decoder13()]
   ]);
 }
 function getSetTunaSpotPositionLimitOrdersInstructionDataCodec() {
-  return combineCodec63(
+  return combineCodec64(
     getSetTunaSpotPositionLimitOrdersInstructionDataEncoder(),
     getSetTunaSpotPositionLimitOrdersInstructionDataDecoder()
   );
@@ -9381,24 +9510,24 @@ function parseSetTunaSpotPositionLimitOrdersInstruction(instruction) {
 
 // src/generated/instructions/updateMarket.ts
 import {
-  combineCodec as combineCodec64,
-  fixDecoderSize as fixDecoderSize58,
-  fixEncoderSize as fixEncoderSize59,
+  combineCodec as combineCodec65,
+  fixDecoderSize as fixDecoderSize59,
+  fixEncoderSize as fixEncoderSize60,
   getAddressDecoder as getAddressDecoder14,
   getAddressEncoder as getAddressEncoder14,
   getBooleanDecoder as getBooleanDecoder8,
   getBooleanEncoder as getBooleanEncoder8,
-  getBytesDecoder as getBytesDecoder58,
-  getBytesEncoder as getBytesEncoder59,
-  getStructDecoder as getStructDecoder60,
-  getStructEncoder as getStructEncoder60,
+  getBytesDecoder as getBytesDecoder59,
+  getBytesEncoder as getBytesEncoder60,
+  getStructDecoder as getStructDecoder61,
+  getStructEncoder as getStructEncoder61,
   getU16Decoder as getU16Decoder8,
   getU16Encoder as getU16Encoder8,
   getU32Decoder as getU32Decoder33,
   getU32Encoder as getU32Encoder33,
   getU64Decoder as getU64Decoder21,
   getU64Encoder as getU64Encoder21,
-  transformEncoder as transformEncoder58
+  transformEncoder as transformEncoder59
 } from "@solana/kit";
 var UPDATE_MARKET_DISCRIMINATOR = new Uint8Array([
   153,
@@ -9411,14 +9540,14 @@ var UPDATE_MARKET_DISCRIMINATOR = new Uint8Array([
   217
 ]);
 function getUpdateMarketDiscriminatorBytes() {
-  return fixEncoderSize59(getBytesEncoder59(), 8).encode(
+  return fixEncoderSize60(getBytesEncoder60(), 8).encode(
     UPDATE_MARKET_DISCRIMINATOR
   );
 }
 function getUpdateMarketInstructionDataEncoder() {
-  return transformEncoder58(
-    getStructEncoder60([
-      ["discriminator", fixEncoderSize59(getBytesEncoder59(), 8)],
+  return transformEncoder59(
+    getStructEncoder61([
+      ["discriminator", fixEncoderSize60(getBytesEncoder60(), 8)],
       ["addressLookupTable", getAddressEncoder14()],
       ["maxLeverage", getU32Encoder33()],
       ["protocolFee", getU16Encoder8()],
@@ -9437,8 +9566,8 @@ function getUpdateMarketInstructionDataEncoder() {
   );
 }
 function getUpdateMarketInstructionDataDecoder() {
-  return getStructDecoder60([
-    ["discriminator", fixDecoderSize58(getBytesDecoder58(), 8)],
+  return getStructDecoder61([
+    ["discriminator", fixDecoderSize59(getBytesDecoder59(), 8)],
     ["addressLookupTable", getAddressDecoder14()],
     ["maxLeverage", getU32Decoder33()],
     ["protocolFee", getU16Decoder8()],
@@ -9455,7 +9584,7 @@ function getUpdateMarketInstructionDataDecoder() {
   ]);
 }
 function getUpdateMarketInstructionDataCodec() {
-  return combineCodec64(
+  return combineCodec65(
     getUpdateMarketInstructionDataEncoder(),
     getUpdateMarketInstructionDataDecoder()
   );
@@ -9506,18 +9635,18 @@ function parseUpdateMarketInstruction(instruction) {
 
 // src/generated/instructions/updateVault.ts
 import {
-  combineCodec as combineCodec65,
-  fixDecoderSize as fixDecoderSize59,
-  fixEncoderSize as fixEncoderSize60,
+  combineCodec as combineCodec66,
+  fixDecoderSize as fixDecoderSize60,
+  fixEncoderSize as fixEncoderSize61,
   getAddressDecoder as getAddressDecoder15,
   getAddressEncoder as getAddressEncoder15,
-  getBytesDecoder as getBytesDecoder59,
-  getBytesEncoder as getBytesEncoder60,
-  getStructDecoder as getStructDecoder61,
-  getStructEncoder as getStructEncoder61,
+  getBytesDecoder as getBytesDecoder60,
+  getBytesEncoder as getBytesEncoder61,
+  getStructDecoder as getStructDecoder62,
+  getStructEncoder as getStructEncoder62,
   getU64Decoder as getU64Decoder22,
   getU64Encoder as getU64Encoder22,
-  transformEncoder as transformEncoder59
+  transformEncoder as transformEncoder60
 } from "@solana/kit";
 var UPDATE_VAULT_DISCRIMINATOR = new Uint8Array([
   67,
@@ -9530,14 +9659,14 @@ var UPDATE_VAULT_DISCRIMINATOR = new Uint8Array([
   60
 ]);
 function getUpdateVaultDiscriminatorBytes() {
-  return fixEncoderSize60(getBytesEncoder60(), 8).encode(
+  return fixEncoderSize61(getBytesEncoder61(), 8).encode(
     UPDATE_VAULT_DISCRIMINATOR
   );
 }
 function getUpdateVaultInstructionDataEncoder() {
-  return transformEncoder59(
-    getStructEncoder61([
-      ["discriminator", fixEncoderSize60(getBytesEncoder60(), 8)],
+  return transformEncoder60(
+    getStructEncoder62([
+      ["discriminator", fixEncoderSize61(getBytesEncoder61(), 8)],
       ["interestRate", getU64Encoder22()],
       ["supplyLimit", getU64Encoder22()],
       ["pythOraclePriceUpdate", getAddressEncoder15()],
@@ -9547,8 +9676,8 @@ function getUpdateVaultInstructionDataEncoder() {
   );
 }
 function getUpdateVaultInstructionDataDecoder() {
-  return getStructDecoder61([
-    ["discriminator", fixDecoderSize59(getBytesDecoder59(), 8)],
+  return getStructDecoder62([
+    ["discriminator", fixDecoderSize60(getBytesDecoder60(), 8)],
     ["interestRate", getU64Decoder22()],
     ["supplyLimit", getU64Decoder22()],
     ["pythOraclePriceUpdate", getAddressDecoder15()],
@@ -9556,7 +9685,7 @@ function getUpdateVaultInstructionDataDecoder() {
   ]);
 }
 function getUpdateVaultInstructionDataCodec() {
-  return combineCodec65(
+  return combineCodec66(
     getUpdateVaultInstructionDataEncoder(),
     getUpdateVaultInstructionDataDecoder()
   );
@@ -9607,16 +9736,16 @@ function parseUpdateVaultInstruction(instruction) {
 
 // src/generated/instructions/withdraw.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 combineCodec67,
+  fixDecoderSize as fixDecoderSize61,
+  fixEncoderSize as fixEncoderSize62,
+  getBytesDecoder as getBytesDecoder61,
+  getBytesEncoder as getBytesEncoder62,
+  getStructDecoder as getStructDecoder63,
+  getStructEncoder as getStructEncoder63,
   getU64Decoder as getU64Decoder23,
   getU64Encoder as getU64Encoder23,
-  transformEncoder as transformEncoder60
+  transformEncoder as transformEncoder61
 } from "@solana/kit";
 var WITHDRAW_DISCRIMINATOR = new Uint8Array([
   183,
@@ -9629,12 +9758,12 @@ var WITHDRAW_DISCRIMINATOR = new Uint8Array([
   34
 ]);
 function getWithdrawDiscriminatorBytes() {
-  return fixEncoderSize61(getBytesEncoder61(), 8).encode(WITHDRAW_DISCRIMINATOR);
+  return fixEncoderSize62(getBytesEncoder62(), 8).encode(WITHDRAW_DISCRIMINATOR);
 }
 function getWithdrawInstructionDataEncoder() {
-  return transformEncoder60(
-    getStructEncoder62([
-      ["discriminator", fixEncoderSize61(getBytesEncoder61(), 8)],
+  return transformEncoder61(
+    getStructEncoder63([
+      ["discriminator", fixEncoderSize62(getBytesEncoder62(), 8)],
       ["funds", getU64Encoder23()],
       ["shares", getU64Encoder23()]
     ]),
@@ -9642,14 +9771,14 @@ function getWithdrawInstructionDataEncoder() {
   );
 }
 function getWithdrawInstructionDataDecoder() {
-  return getStructDecoder62([
-    ["discriminator", fixDecoderSize60(getBytesDecoder60(), 8)],
+  return getStructDecoder63([
+    ["discriminator", fixDecoderSize61(getBytesDecoder61(), 8)],
     ["funds", getU64Decoder23()],
     ["shares", getU64Decoder23()]
   ]);
 }
 function getWithdrawInstructionDataCodec() {
-  return combineCodec66(
+  return combineCodec67(
     getWithdrawInstructionDataEncoder(),
     getWithdrawInstructionDataDecoder()
   );
@@ -9721,6 +9850,35 @@ function parseWithdrawInstruction(instruction) {
 
 // src/pda.ts
 import { getAddressEncoder as getAddressEncoder16, getProgramDerivedAddress } from "@solana/kit";
+
+// src/consts.ts
+import { address } from "@solana/kit";
+var DEFAULT_ADDRESS = address("11111111111111111111111111111111");
+var HUNDRED_PERCENT = 1e6;
+var LEVERAGE_ONE = HUNDRED_PERCENT;
+var MAX_LEVERAGE = 11 * LEVERAGE_ONE;
+var MAX_PROTOCOL_FEE = HUNDRED_PERCENT / 100;
+var MAX_LIQUIDATION_FEE = HUNDRED_PERCENT / 5;
+var MAX_LIMIT_ORDER_EXECUTION_FEE = HUNDRED_PERCENT / 100;
+var DEFAULT_MAX_SWAP_SLIPPAGE = HUNDRED_PERCENT / 50;
+var MAX_LIQUIDATION_THRESHOLD = HUNDRED_PERCENT * 95 / 100;
+var NO_LOWER_LIMIT_ORDER = -2147483648;
+var NO_UPPER_LIMIT_ORDER = 2147483647;
+var COMPUTED_AMOUNT = 18446744073709551615n;
+var UNLIMITED_SUPPLY_LIMIT = 18446744073709551615n;
+var TUNA_POSITION_FLAGS_LOWER_LIMIT_ORDER_SWAP_TO_TOKEN_A = 1;
+var TUNA_POSITION_FLAGS_LOWER_LIMIT_ORDER_SWAP_TO_TOKEN_B = 1 << 1;
+var TUNA_POSITION_FLAGS_UPPER_LIMIT_ORDER_SWAP_TO_TOKEN_A = 1 << 2;
+var TUNA_POSITION_FLAGS_UPPER_LIMIT_ORDER_SWAP_TO_TOKEN_B = 1 << 3;
+var TUNA_POSITION_FLAGS_AUTO_COMPOUND_YIELD = 1 << 4;
+var TUNA_POSITION_FLAGS_AUTO_COMPOUND_YIELD_WITH_LEVERAGE = 1 << 5;
+var TUNA_POSITION_FLAGS_ALLOW_REBALANCING = 1 << 6;
+var WP_NFT_UPDATE_AUTH = address("3axbTs2z5GBy6usVbNVoqEgZMng3vZvMnAoX29BFfwhr");
+var DEFAULT_PUSH_ORACLE_PROGRAM_ID = address("pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT");
+var MIN_SQRT_PRICE = 4295048016n;
+var MAX_SQRT_PRICE = 79226673515401279992447579055n;
+
+// src/pda.ts
 async function getTunaConfigAddress() {
   return await getProgramDerivedAddress({
     programAddress: TUNA_PROGRAM_ADDRESS,
@@ -9757,6 +9915,24 @@ async function getTunaSpotPositionAddress(positionMint) {
     seeds: ["tuna_spot_position", getAddressEncoder16().encode(positionMint)]
   });
 }
+async function getPythPriceUpdateAccountAddress(shardId, priceFeedId) {
+  if (typeof priceFeedId == "string") {
+    if (priceFeedId.startsWith("0x")) {
+      priceFeedId = Buffer.from(priceFeedId.slice(2), "hex");
+    } else {
+      priceFeedId = Buffer.from(priceFeedId, "hex");
+    }
+  }
+  if (priceFeedId.length != 32) {
+    throw new Error("Feed ID should be 32 bytes long");
+  }
+  const shardBuffer = Buffer.alloc(2);
+  shardBuffer.writeUint16LE(shardId, 0);
+  return await getProgramDerivedAddress({
+    programAddress: DEFAULT_PUSH_ORACLE_PROGRAM_ID,
+    seeds: [shardBuffer, priceFeedId]
+  });
+}
 
 // src/gpa/tunaLpPosition.ts
 import {
@@ -10069,7 +10245,7 @@ var FusionUtils = class {
 };
 
 // src/utils/token.ts
-import { address } from "@solana/kit";
+import { address as address2 } from "@solana/kit";
 import { getTransferSolInstruction } from "@solana-program/system";
 import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
 import {
@@ -10078,7 +10254,7 @@ import {
   getCreateAssociatedTokenIdempotentInstruction,
   getSyncNativeInstruction
 } from "@solana-program/token-2022";
-var NATIVE_MINT = address("So11111111111111111111111111111111111111112");
+var NATIVE_MINT = address2("So11111111111111111111111111111111111111112");
 async function getCreateAtaInstruction(mint, owner, payer, tokenProgram = TOKEN_PROGRAM_ADDRESS) {
   const ata = (await findAssociatedTokenPda({
     mint,
@@ -10155,34 +10331,6 @@ import {
   tryGetTokenAFromLiquidity,
   tryGetTokenBFromLiquidity
 } from "@crypticdot/fusionamm-core";
-
-// src/consts.ts
-import { address as address2 } from "@solana/kit";
-var DEFAULT_ADDRESS = address2("11111111111111111111111111111111");
-var HUNDRED_PERCENT = 1e6;
-var LEVERAGE_ONE = HUNDRED_PERCENT;
-var MAX_LEVERAGE = 11 * LEVERAGE_ONE;
-var MAX_PROTOCOL_FEE = HUNDRED_PERCENT / 100;
-var MAX_LIQUIDATION_FEE = HUNDRED_PERCENT / 5;
-var MAX_LIMIT_ORDER_EXECUTION_FEE = HUNDRED_PERCENT / 100;
-var DEFAULT_MAX_SWAP_SLIPPAGE = HUNDRED_PERCENT / 50;
-var MAX_LIQUIDATION_THRESHOLD = HUNDRED_PERCENT * 95 / 100;
-var NO_LOWER_LIMIT_ORDER = -2147483648;
-var NO_UPPER_LIMIT_ORDER = 2147483647;
-var COMPUTED_AMOUNT = 18446744073709551615n;
-var UNLIMITED_SUPPLY_LIMIT = 18446744073709551615n;
-var TUNA_POSITION_FLAGS_LOWER_LIMIT_ORDER_SWAP_TO_TOKEN_A = 1;
-var TUNA_POSITION_FLAGS_LOWER_LIMIT_ORDER_SWAP_TO_TOKEN_B = 1 << 1;
-var TUNA_POSITION_FLAGS_UPPER_LIMIT_ORDER_SWAP_TO_TOKEN_A = 1 << 2;
-var TUNA_POSITION_FLAGS_UPPER_LIMIT_ORDER_SWAP_TO_TOKEN_B = 1 << 3;
-var TUNA_POSITION_FLAGS_AUTO_COMPOUND_YIELD = 1 << 4;
-var TUNA_POSITION_FLAGS_AUTO_COMPOUND_YIELD_WITH_LEVERAGE = 1 << 5;
-var TUNA_POSITION_FLAGS_ALLOW_REBALANCING = 1 << 6;
-var WP_NFT_UPDATE_AUTH = address2("3axbTs2z5GBy6usVbNVoqEgZMng3vZvMnAoX29BFfwhr");
-var MIN_SQRT_PRICE = 4295048016n;
-var MAX_SQRT_PRICE = 79226673515401279992447579055n;
-
-// src/utils/positionMath.ts
 var DEFAULT_MAX_AMOUNT_SLIPPAGE = HUNDRED_PERCENT / 2;
 function getLiquidityIncreaseQuote(args) {
   const { protocolFeeRate, protocolFeeRateOnCollateral, swapFeeRate, sqrtPrice, tickLowerIndex, tickUpperIndex } = args;
@@ -14688,6 +14836,56 @@ async function setTunaLpPositionLimitOrdersInstruction(authority, args, position
   });
 }
 
+// src/txbuilder/setTunaSpotPositionLimitOrders.ts
+async function setTunaSpotPositionLimitOrdersInstruction(authority, args, positionMint, tunaPositionAddress) {
+  if (tunaPositionAddress === void 0) {
+    if (positionMint === void 0) {
+      throw new Error("At least one of 'positionMint' or 'tunaPositionAddress' must be provided.");
+    }
+    tunaPositionAddress = (await getTunaSpotPositionAddress(positionMint))[0];
+  }
+  return getSetTunaSpotPositionLimitOrdersInstruction({
+    ...args,
+    authority,
+    tunaPosition: tunaPositionAddress
+  });
+}
+
+// src/txbuilder/resetTunaSpotPosition.ts
+import { fetchAllMaybeMint as fetchAllMaybeMint28, findAssociatedTokenPda as findAssociatedTokenPda36 } from "@solana-program/token-2022";
+import assert28 from "assert";
+async function resetTunaSpotPositionInstruction(rpc, authority, args, positionMint, tunaPositionAddress) {
+  if (tunaPositionAddress === void 0) {
+    if (positionMint === void 0) {
+      throw new Error("At least one of 'positionMint' or 'tunaPositionAddress' must be provided.");
+    }
+    tunaPositionAddress = (await getTunaSpotPositionAddress(positionMint))[0];
+  }
+  const tunaPosition = await fetchTunaSpotPosition(rpc, tunaPositionAddress);
+  const [mintA, mintB] = await fetchAllMaybeMint28(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  assert28(mintA.exists, "Token A not found");
+  assert28(mintB.exists, "Token B not found");
+  const tunaPositionAtaA = (await findAssociatedTokenPda36({
+    owner: tunaPositionAddress,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const tunaPositionAtaB = (await findAssociatedTokenPda36({
+    owner: tunaPositionAddress,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  return getResetTunaSpotPositionInstruction({
+    ...args,
+    authority,
+    mintA: tunaPosition.data.mintA,
+    mintB: tunaPosition.data.mintB,
+    tunaPositionAtaA,
+    tunaPositionAtaB,
+    tunaPosition: tunaPositionAddress
+  });
+}
+
 // src/txbuilder/updateMarket.ts
 async function updateMarketInstruction(authority, pool, args) {
   const tunaConfig = (await getTunaConfigAddress())[0];
@@ -14714,7 +14912,7 @@ async function updateVaultInstruction(authority, mint, args) {
 
 // src/txbuilder/withdraw.ts
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS25 } from "@solana-program/memo";
-import { fetchMaybeMint as fetchMaybeMint3, findAssociatedTokenPda as findAssociatedTokenPda36 } from "@solana-program/token-2022";
+import { fetchMaybeMint as fetchMaybeMint3, findAssociatedTokenPda as findAssociatedTokenPda37 } from "@solana-program/token-2022";
 async function withdrawInstructions(rpc, authority, mintAddress, funds, shares) {
   const instructions = [];
   const mint = await fetchMaybeMint3(rpc, mintAddress);
@@ -14736,12 +14934,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 findAssociatedTokenPda36({
+  const vaultAta = (await findAssociatedTokenPda37({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
   }))[0];
-  const authorityAta = (await findAssociatedTokenPda36({
+  const authorityAta = (await findAssociatedTokenPda37({
     owner: authority.address,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -14773,7 +14971,7 @@ import { TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS2 } from "@solana-program
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS9,
   fetchMint,
-  findAssociatedTokenPda as findAssociatedTokenPda37,
+  findAssociatedTokenPda as findAssociatedTokenPda38,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS19
 } from "@solana-program/token-2022";
 async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
@@ -14784,12 +14982,12 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
   const pool = marketMaker == 0 /* Orca */ ? await fetchWhirlpool3(rpc, poolAddress) : await fetchFusionPool3(rpc, poolAddress);
   const mintA = await fetchMint(rpc, pool.data.tokenMintA);
   const mintB = await fetchMint(rpc, pool.data.tokenMintB);
-  const feeRecipientAtaA = (await findAssociatedTokenPda37({
+  const feeRecipientAtaA = (await findAssociatedTokenPda38({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda37({
+  const feeRecipientAtaB = (await findAssociatedTokenPda38({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -14798,12 +14996,12 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
     (await getLendingVaultAddress(mintA.address))[0],
     (await getLendingVaultAddress(mintB.address))[0]
   ]);
-  const vaultAAta = (await findAssociatedTokenPda37({
+  const vaultAAta = (await findAssociatedTokenPda38({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda37({
+  const vaultBAta = (await findAssociatedTokenPda38({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -14858,16 +15056,16 @@ async function createAddressLookupTableForMarketInstructions(rpc, poolAddress, m
 
 // src/txbuilder/repayTunaLpPositionDebt.ts
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS27 } from "@solana-program/memo";
-import { fetchAllMaybeMint as fetchAllMaybeMint28, findAssociatedTokenPda as findAssociatedTokenPda38 } from "@solana-program/token-2022";
-import assert28 from "assert";
+import { fetchAllMaybeMint as fetchAllMaybeMint29, findAssociatedTokenPda as findAssociatedTokenPda39 } from "@solana-program/token-2022";
+import assert29 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 fetchAllMaybeMint28(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  assert28(mintA.exists, "Token A not found");
-  assert28(mintB.exists, "Token B not found");
+  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 marketAddress = (await getMarketAddress(tunaPosition.data.pool))[0];
   const createUserAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -14903,34 +15101,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 findAssociatedTokenPda38({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda39({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda38({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda39({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda38({
+  const tunaPositionAtaA = (await findAssociatedTokenPda39({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda38({
+  const tunaPositionAtaB = (await findAssociatedTokenPda39({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const vaultAAddress = (await getLendingVaultAddress(mintA.address))[0];
-  const vaultAAta = (await findAssociatedTokenPda38({
+  const vaultAAta = (await findAssociatedTokenPda39({
     owner: vaultAAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
   const vaultBAddress = (await getLendingVaultAddress(mintB.address))[0];
-  const vaultBAta = (await findAssociatedTokenPda38({
+  const vaultBAta = (await findAssociatedTokenPda39({
     owner: vaultBAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -14974,11 +15172,11 @@ import {
 import { fetchSysvarRent as fetchSysvarRent3 } from "@solana/sysvars";
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS28 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint29,
-  findAssociatedTokenPda as findAssociatedTokenPda39,
+  fetchAllMaybeMint as fetchAllMaybeMint30,
+  findAssociatedTokenPda as findAssociatedTokenPda40,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS20
 } from "@solana-program/token-2022";
-import assert29 from "assert";
+import assert30 from "assert";
 async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await fetchSysvarRent3(rpc);
   let nonRefundableRent = 0n;
@@ -14991,9 +15189,9 @@ async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionM
     (await getLendingVaultAddress(whirlpool.data.tokenMintA))[0],
     (await getLendingVaultAddress(whirlpool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint29(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  assert29(mintA.exists, "Token A account not found");
-  assert29(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint30(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  assert30(mintA.exists, "Token A account not found");
+  assert30(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -15065,27 +15263,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 findAssociatedTokenPda39({
+  const tunaPositionAta = (await findAssociatedTokenPda40({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS20
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda39({
+  const tunaPositionAtaA = (await findAssociatedTokenPda40({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda39({
+  const tunaPositionAtaB = (await findAssociatedTokenPda40({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda39({
+  const feeRecipientAtaA = (await findAssociatedTokenPda40({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda39({
+  const feeRecipientAtaB = (await findAssociatedTokenPda40({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -15170,11 +15368,11 @@ import {
 import { fetchSysvarRent as fetchSysvarRent4 } from "@solana/sysvars";
 import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS29 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint30,
-  findAssociatedTokenPda as findAssociatedTokenPda40,
+  fetchAllMaybeMint as fetchAllMaybeMint31,
+  findAssociatedTokenPda as findAssociatedTokenPda41,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS21
 } from "@solana-program/token-2022";
-import assert30 from "assert";
+import assert31 from "assert";
 async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await fetchSysvarRent4(rpc);
   let nonRefundableRent = 0n;
@@ -15187,9 +15385,9 @@ async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positio
     (await getLendingVaultAddress(fusionPool.data.tokenMintA))[0],
     (await getLendingVaultAddress(fusionPool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint30(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  assert30(mintA.exists, "Token A account not found");
-  assert30(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint31(rpc, [fusionPool.data.tokenMintA, fusionPool.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;
@@ -15256,27 +15454,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 findAssociatedTokenPda40({
+  const tunaPositionAta = (await findAssociatedTokenPda41({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS21
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda40({
+  const tunaPositionAtaA = (await findAssociatedTokenPda41({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda40({
+  const tunaPositionAtaB = (await findAssociatedTokenPda41({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda40({
+  const feeRecipientAtaA = (await findAssociatedTokenPda41({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda40({
+  const feeRecipientAtaB = (await findAssociatedTokenPda41({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -15365,6 +15563,7 @@ export {
   DEFAULT_ADDRESS,
   DEFAULT_MAX_AMOUNT_SLIPPAGE,
   DEFAULT_MAX_SWAP_SLIPPAGE,
+  DEFAULT_PUSH_ORACLE_PROGRAM_ID,
   DEPOSIT_DISCRIMINATOR,
   FusionUtils,
   HUNDRED_PERCENT,
@@ -15405,6 +15604,7 @@ export {
   REBALANCE_TUNA_LP_POSITION_ORCA_DISCRIMINATOR,
   REPAY_BAD_DEBT_DISCRIMINATOR,
   REPAY_TUNA_LP_POSITION_DEBT_DISCRIMINATOR,
+  RESET_TUNA_SPOT_POSITION_DISCRIMINATOR,
   SET_ADMIN_AUTHORITY_DISCRIMINATOR,
   SET_DEFAULT_MAX_PERCENTAGE_OF_LEFTOVERS_DISCRIMINATOR,
   SET_DEFAULT_MAX_SWAP_SLIPPAGE_DISCRIMINATOR,
@@ -15766,6 +15966,7 @@ export {
   getPoolTokenCodec,
   getPoolTokenDecoder,
   getPoolTokenEncoder,
+  getPythPriceUpdateAccountAddress,
   getRebalanceTunaLpPositionFusionDiscriminatorBytes,
   getRebalanceTunaLpPositionFusionInstruction,
   getRebalanceTunaLpPositionFusionInstructionDataCodec,
@@ -15792,6 +15993,11 @@ export {
   getRepayTunaLpPositionDebtInstructionDataCodec,
   getRepayTunaLpPositionDebtInstructionDataDecoder,
   getRepayTunaLpPositionDebtInstructionDataEncoder,
+  getResetTunaSpotPositionDiscriminatorBytes,
+  getResetTunaSpotPositionInstruction,
+  getResetTunaSpotPositionInstructionDataCodec,
+  getResetTunaSpotPositionInstructionDataDecoder,
+  getResetTunaSpotPositionInstructionDataEncoder,
   getSetAdminAuthorityDiscriminatorBytes,
   getSetAdminAuthorityInstruction,
   getSetAdminAuthorityInstructionDataCodec,
@@ -15970,6 +16176,7 @@ export {
   parseRebalanceTunaLpPositionOrcaInstruction,
   parseRepayBadDebtInstruction,
   parseRepayTunaLpPositionDebtInstruction,
+  parseResetTunaSpotPositionInstruction,
   parseSetAdminAuthorityInstruction,
   parseSetDefaultMaxPercentageOfLeftoversInstruction,
   parseSetDefaultMaxSwapSlippageInstruction,
@@ -15992,7 +16199,9 @@ export {
   repayBadDebtInstruction,
   repayTunaLpPositionDebtInstruction,
   repayTunaLpPositionDebtInstructions,
+  resetTunaSpotPositionInstruction,
   setTunaLpPositionLimitOrdersInstruction,
+  setTunaSpotPositionLimitOrdersInstruction,
   tunaLpPositionAuthorityFilter,
   tunaLpPositionMarketMakerFilter,
   tunaLpPositionMintAFilter,