@crypticdot/defituna-client 3.3.0 → 3.3.2

package/dist/index.js

@@ -573,6 +573,8 @@ __export(index_exports, {
   liquidateTunaSpotPositionOrcaInstructions: () => liquidateTunaSpotPositionOrcaInstructions,
   modifyTunaSpotPositionFusionInstruction: () => modifyTunaSpotPositionFusionInstruction,
   modifyTunaSpotPositionFusionInstructions: () => modifyTunaSpotPositionFusionInstructions,
+  modifyTunaSpotPositionJupiterInstruction: () => modifyTunaSpotPositionJupiterInstruction,
+  modifyTunaSpotPositionJupiterInstructions: () => modifyTunaSpotPositionJupiterInstructions,
   modifyTunaSpotPositionOrcaInstruction: () => modifyTunaSpotPositionOrcaInstruction,
   modifyTunaSpotPositionOrcaInstructions: () => modifyTunaSpotPositionOrcaInstructions,
   mulDiv: () => mulDiv,
@@ -5154,10 +5156,9 @@ function getModifyTunaSpotPositionFusionInstructionDataEncoder() {
     (0, import_kit36.getStructEncoder)([
       ["discriminator", (0, import_kit36.fixEncoderSize)((0, import_kit36.getBytesEncoder)(), 8)],
       ["decreasePercent", (0, import_kit36.getU32Encoder)()],
-      ["decreaseAcceptableSwapAmount", (0, import_kit36.getU64Encoder)()],
       ["collateralAmount", (0, import_kit36.getU64Encoder)()],
       ["borrowAmount", (0, import_kit36.getU64Encoder)()],
-      ["increaseMinSwapAmountOut", (0, import_kit36.getU64Encoder)()],
+      ["requiredSwapAmount", (0, import_kit36.getU64Encoder)()],
       ["remainingAccountsInfo", getRemainingAccountsInfoEncoder()]
     ]),
     (value) => ({
@@ -5170,10 +5171,9 @@ function getModifyTunaSpotPositionFusionInstructionDataDecoder() {
   return (0, import_kit36.getStructDecoder)([
     ["discriminator", (0, import_kit36.fixDecoderSize)((0, import_kit36.getBytesDecoder)(), 8)],
     ["decreasePercent", (0, import_kit36.getU32Decoder)()],
-    ["decreaseAcceptableSwapAmount", (0, import_kit36.getU64Decoder)()],
     ["collateralAmount", (0, import_kit36.getU64Decoder)()],
     ["borrowAmount", (0, import_kit36.getU64Decoder)()],
-    ["increaseMinSwapAmountOut", (0, import_kit36.getU64Decoder)()],
+    ["requiredSwapAmount", (0, import_kit36.getU64Decoder)()],
     ["remainingAccountsInfo", getRemainingAccountsInfoDecoder()]
   ]);
 }
@@ -5549,10 +5549,9 @@ function getModifyTunaSpotPositionOrcaInstructionDataEncoder() {
     (0, import_kit38.getStructEncoder)([
       ["discriminator", (0, import_kit38.fixEncoderSize)((0, import_kit38.getBytesEncoder)(), 8)],
       ["decreasePercent", (0, import_kit38.getU32Encoder)()],
-      ["decreaseAcceptableSwapAmount", (0, import_kit38.getU64Encoder)()],
       ["collateralAmount", (0, import_kit38.getU64Encoder)()],
       ["borrowAmount", (0, import_kit38.getU64Encoder)()],
-      ["increaseMinSwapAmountOut", (0, import_kit38.getU64Encoder)()],
+      ["requiredSwapAmount", (0, import_kit38.getU64Encoder)()],
       ["remainingAccountsInfo", getRemainingAccountsInfoEncoder()]
     ]),
     (value) => ({
@@ -5565,10 +5564,9 @@ function getModifyTunaSpotPositionOrcaInstructionDataDecoder() {
   return (0, import_kit38.getStructDecoder)([
     ["discriminator", (0, import_kit38.fixDecoderSize)((0, import_kit38.getBytesDecoder)(), 8)],
     ["decreasePercent", (0, import_kit38.getU32Decoder)()],
-    ["decreaseAcceptableSwapAmount", (0, import_kit38.getU64Decoder)()],
     ["collateralAmount", (0, import_kit38.getU64Decoder)()],
     ["borrowAmount", (0, import_kit38.getU64Decoder)()],
-    ["increaseMinSwapAmountOut", (0, import_kit38.getU64Decoder)()],
+    ["requiredSwapAmount", (0, import_kit38.getU64Decoder)()],
     ["remainingAccountsInfo", getRemainingAccountsInfoDecoder()]
   ]);
 }
@@ -10616,23 +10614,29 @@ async function modifyTunaSpotPositionOrcaInstructions(rpc, authority, poolAddres
     (await getLendingVaultAddress(pool.data.tokenMintA))[0],
     (await getLendingVaultAddress(pool.data.tokenMintB))[0]
   ]);
-  const tunaPositionAtaAAddress = (await (0, import_token_202213.findAssociatedTokenPda)({
-    owner: tunaPositionAddress,
-    mint: mintA.address,
-    tokenProgram: mintA.programAddress
-  }))[0];
-  const tunaPositionAtaBAddress = (await (0, import_token_202213.findAssociatedTokenPda)({
-    owner: tunaPositionAddress,
-    mint: mintB.address,
-    tokenProgram: mintB.programAddress
-  }))[0];
-  const [tunaPositionAtaA, tunaPositionAtaB] = await (0, import_token_202213.fetchAllToken)(rpc, [
-    tunaPositionAtaAAddress,
-    tunaPositionAtaBAddress
-  ]);
-  const createUserAtaAInstructions = collateralToken == 0 /* A */ || tunaPosition.exists && tunaPositionAtaA.data.amount > (tunaPosition.data.positionToken == 0 /* A */ ? tunaPosition.data.amount : 0n) ? await getCreateAtaInstructions(rpc, authority, mintA.address, authority.address, mintA.programAddress) : void 0;
+  let hasDirectlyTransferredTokensA = false;
+  let hasDirectlyTransferredTokensB = false;
+  if (tunaPosition.exists) {
+    const tunaPositionAtaAAddress = (await (0, import_token_202213.findAssociatedTokenPda)({
+      owner: tunaPositionAddress,
+      mint: mintA.address,
+      tokenProgram: mintA.programAddress
+    }))[0];
+    const tunaPositionAtaBAddress = (await (0, import_token_202213.findAssociatedTokenPda)({
+      owner: tunaPositionAddress,
+      mint: mintB.address,
+      tokenProgram: mintB.programAddress
+    }))[0];
+    const [tunaPositionAtaA, tunaPositionAtaB] = await (0, import_token_202213.fetchAllToken)(rpc, [
+      tunaPositionAtaAAddress,
+      tunaPositionAtaBAddress
+    ]);
+    hasDirectlyTransferredTokensA = tunaPositionAtaA.data.amount > (tunaPosition.data.positionToken == 0 /* A */ ? tunaPosition.data.amount : 0n);
+    hasDirectlyTransferredTokensB = tunaPositionAtaB.data.amount > (tunaPosition.data.positionToken == 1 /* B */ ? tunaPosition.data.amount : 0n);
+  }
+  const createUserAtaAInstructions = collateralToken == 0 /* A */ || hasDirectlyTransferredTokensA ? await getCreateAtaInstructions(rpc, authority, mintA.address, authority.address, mintA.programAddress) : void 0;
   if (createUserAtaAInstructions) createInstructions.push(...createUserAtaAInstructions.init);
-  const createUserAtaBInstructions = collateralToken == 1 /* B */ || tunaPosition.exists && tunaPositionAtaB.data.amount > (tunaPosition.data.positionToken == 1 /* B */ ? tunaPosition.data.amount : 0n) ? await getCreateAtaInstructions(rpc, authority, mintB.address, authority.address, mintB.programAddress) : void 0;
+  const createUserAtaBInstructions = collateralToken == 1 /* B */ || hasDirectlyTransferredTokensB ? await getCreateAtaInstructions(rpc, authority, mintB.address, authority.address, mintB.programAddress) : void 0;
   if (createUserAtaBInstructions) createInstructions.push(...createUserAtaBInstructions.init);
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -10787,23 +10791,29 @@ async function modifyTunaSpotPositionFusionInstructions(rpc, authority, poolAddr
     (await getLendingVaultAddress(pool.data.tokenMintA))[0],
     (await getLendingVaultAddress(pool.data.tokenMintB))[0]
   ]);
-  const tunaPositionAtaAAddress = (await (0, import_token_202214.findAssociatedTokenPda)({
-    owner: tunaPosition.address,
-    mint: mintA.address,
-    tokenProgram: mintA.programAddress
-  }))[0];
-  const tunaPositionAtaBAddress = (await (0, import_token_202214.findAssociatedTokenPda)({
-    owner: tunaPosition.address,
-    mint: mintB.address,
-    tokenProgram: mintB.programAddress
-  }))[0];
-  const [tunaPositionAtaA, tunaPositionAtaB] = await (0, import_token_202214.fetchAllToken)(rpc, [
-    tunaPositionAtaAAddress,
-    tunaPositionAtaBAddress
-  ]);
-  const createUserAtaAInstructions = collateralToken == 0 /* A */ || tunaPosition.exists && tunaPositionAtaA.data.amount > (tunaPosition.data.positionToken == 0 /* A */ ? tunaPosition.data.amount : 0n) ? await getCreateAtaInstructions(rpc, authority, mintA.address, authority.address, mintA.programAddress) : void 0;
+  let hasDirectlyTransferredTokensA = false;
+  let hasDirectlyTransferredTokensB = false;
+  if (tunaPosition.exists) {
+    const tunaPositionAtaAAddress = (await (0, import_token_202214.findAssociatedTokenPda)({
+      owner: tunaPositionAddress,
+      mint: mintA.address,
+      tokenProgram: mintA.programAddress
+    }))[0];
+    const tunaPositionAtaBAddress = (await (0, import_token_202214.findAssociatedTokenPda)({
+      owner: tunaPositionAddress,
+      mint: mintB.address,
+      tokenProgram: mintB.programAddress
+    }))[0];
+    const [tunaPositionAtaA, tunaPositionAtaB] = await (0, import_token_202214.fetchAllToken)(rpc, [
+      tunaPositionAtaAAddress,
+      tunaPositionAtaBAddress
+    ]);
+    hasDirectlyTransferredTokensA = tunaPositionAtaA.data.amount > (tunaPosition.data.positionToken == 0 /* A */ ? tunaPosition.data.amount : 0n);
+    hasDirectlyTransferredTokensB = tunaPositionAtaB.data.amount > (tunaPosition.data.positionToken == 1 /* B */ ? tunaPosition.data.amount : 0n);
+  }
+  const createUserAtaAInstructions = collateralToken == 0 /* A */ || hasDirectlyTransferredTokensA ? await getCreateAtaInstructions(rpc, authority, mintA.address, authority.address, mintA.programAddress) : void 0;
   if (createUserAtaAInstructions) createInstructions.push(...createUserAtaAInstructions.init);
-  const createUserAtaBInstructions = collateralToken == 1 /* B */ || tunaPosition.exists && tunaPositionAtaB.data.amount > (tunaPosition.data.positionToken == 1 /* B */ ? tunaPosition.data.amount : 0n) ? await getCreateAtaInstructions(rpc, authority, mintB.address, authority.address, mintB.programAddress) : void 0;
+  const createUserAtaBInstructions = collateralToken == 1 /* B */ || hasDirectlyTransferredTokensB ? await getCreateAtaInstructions(rpc, authority, mintB.address, authority.address, mintB.programAddress) : void 0;
   if (createUserAtaBInstructions) createInstructions.push(...createUserAtaBInstructions.init);
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -10929,27 +10939,434 @@ async function modifyTunaSpotPositionFusionInstruction(authority, tunaConfig, mi
   return ix;
 }
 
-// src/txbuilder/closeTunaSpotPosition.ts
+// src/txbuilder/modifyTunaSpotPositionJupiter.ts
+var import_fusionamm_client8 = require("@crypticdot/fusionamm-client");
+
+// ../../node_modules/.pnpm/@crypticdot+jupiter-solana-client@1.0.0_fastestsmallesttextencoderdecoder@1.0.22_typesc_c15ee540b6a974c893a6f86bc9defff2/node_modules/@crypticdot/jupiter-solana-client/dist/index.mjs
+var import_kit82 = require("@solana/kit");
+var import_kit83 = require("@solana/kit");
+var import_kit84 = require("@solana/kit");
+var import_kit85 = require("@solana/kit");
+var import_kit86 = require("@solana/kit");
+var import_kit87 = require("@solana/kit");
+var import_kit88 = require("@solana/kit");
+var import_kit89 = require("@solana/kit");
+var import_kit90 = require("@solana/kit");
+var import_kit91 = require("@solana/kit");
+var import_kit92 = require("@solana/kit");
+var import_kit93 = require("@solana/kit");
+var import_kit94 = require("@solana/kit");
+var import_kit95 = require("@solana/kit");
+var import_kit96 = require("@solana/kit");
+var import_kit97 = require("@solana/kit");
+var import_kit98 = require("@solana/kit");
+var import_kit99 = require("@solana/kit");
+var import_kit100 = require("@solana/kit");
+var import_kit101 = require("@solana/kit");
+var import_kit102 = require("@solana/kit");
+var import_kit103 = require("@solana/kit");
+var import_kit104 = require("@solana/kit");
+var import_kit105 = require("@solana/kit");
+var import_kit106 = require("@solana/kit");
+var import_kit107 = require("@solana/kit");
+var import_kit108 = require("@solana/kit");
+var import_kit109 = require("@solana/kit");
+var import_kit110 = require("@solana/kit");
+var import_kit111 = require("@solana/kit");
+var import_kit112 = require("@solana/kit");
+var import_kit113 = require("@solana/kit");
+var import_kit114 = require("@solana/kit");
+var import_kit115 = require("@solana/kit");
+var TOKEN_LEDGER_DISCRIMINATOR = new Uint8Array([
+  156,
+  247,
+  9,
+  188,
+  54,
+  108,
+  85,
+  77
+]);
+var JUPITER_PROGRAM_ADDRESS = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+var JUPITER_ERROR__EMPTY_ROUTE = 6e3;
+var JUPITER_ERROR__SLIPPAGE_TOLERANCE_EXCEEDED = 6001;
+var JUPITER_ERROR__INVALID_CALCULATION = 6002;
+var JUPITER_ERROR__MISSING_PLATFORM_FEE_ACCOUNT = 6003;
+var JUPITER_ERROR__INVALID_SLIPPAGE = 6004;
+var JUPITER_ERROR__NOT_ENOUGH_PERCENT = 6005;
+var JUPITER_ERROR__INVALID_INPUT_INDEX = 6006;
+var JUPITER_ERROR__INVALID_OUTPUT_INDEX = 6007;
+var JUPITER_ERROR__NOT_ENOUGH_ACCOUNT_KEYS = 6008;
+var JUPITER_ERROR__NON_ZERO_MINIMUM_OUT_AMOUNT_NOT_SUPPORTED = 6009;
+var JUPITER_ERROR__INVALID_ROUTE_PLAN = 6010;
+var JUPITER_ERROR__INVALID_REFERRAL_AUTHORITY = 6011;
+var JUPITER_ERROR__LEDGER_TOKEN_ACCOUNT_DOES_NOT_MATCH = 6012;
+var JUPITER_ERROR__INVALID_TOKEN_LEDGER = 6013;
+var JUPITER_ERROR__INCORRECT_TOKEN_PROGRAM_I_D = 6014;
+var JUPITER_ERROR__TOKEN_PROGRAM_NOT_PROVIDED = 6015;
+var JUPITER_ERROR__SWAP_NOT_SUPPORTED = 6016;
+var JUPITER_ERROR__EXACT_OUT_AMOUNT_NOT_MATCHED = 6017;
+var JUPITER_ERROR__SOURCE_AND_DESTINATION_MINT_CANNOT_BE_THE_SAME = 6018;
+var jupiterErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  jupiterErrorMessages = {
+    [JUPITER_ERROR__EMPTY_ROUTE]: `Empty route`,
+    [JUPITER_ERROR__EXACT_OUT_AMOUNT_NOT_MATCHED]: `Exact out amount doesn't match`,
+    [JUPITER_ERROR__INCORRECT_TOKEN_PROGRAM_I_D]: `Token program ID is invalid`,
+    [JUPITER_ERROR__INVALID_CALCULATION]: `Invalid calculation`,
+    [JUPITER_ERROR__INVALID_INPUT_INDEX]: `Token input index is invalid`,
+    [JUPITER_ERROR__INVALID_OUTPUT_INDEX]: `Token output index is invalid`,
+    [JUPITER_ERROR__INVALID_REFERRAL_AUTHORITY]: `Invalid referral authority`,
+    [JUPITER_ERROR__INVALID_ROUTE_PLAN]: `Invalid route plan`,
+    [JUPITER_ERROR__INVALID_SLIPPAGE]: `Invalid slippage`,
+    [JUPITER_ERROR__INVALID_TOKEN_LEDGER]: `Invalid token ledger`,
+    [JUPITER_ERROR__LEDGER_TOKEN_ACCOUNT_DOES_NOT_MATCH]: `Token account doesn't match the ledger`,
+    [JUPITER_ERROR__MISSING_PLATFORM_FEE_ACCOUNT]: `Missing platform fee account`,
+    [JUPITER_ERROR__NON_ZERO_MINIMUM_OUT_AMOUNT_NOT_SUPPORTED]: `Non zero minimum out amount not supported`,
+    [JUPITER_ERROR__NOT_ENOUGH_ACCOUNT_KEYS]: `Not Enough Account keys`,
+    [JUPITER_ERROR__NOT_ENOUGH_PERCENT]: `Not enough percent to 100`,
+    [JUPITER_ERROR__SLIPPAGE_TOLERANCE_EXCEEDED]: `Slippage tolerance exceeded`,
+    [JUPITER_ERROR__SOURCE_AND_DESTINATION_MINT_CANNOT_BE_THE_SAME]: `Source mint and destination mint cannot the same`,
+    [JUPITER_ERROR__SWAP_NOT_SUPPORTED]: `Swap not supported`,
+    [JUPITER_ERROR__TOKEN_PROGRAM_NOT_PROVIDED]: `Token program not provided`
+  };
+}
+var CLAIM_DISCRIMINATOR = new Uint8Array([
+  62,
+  198,
+  214,
+  193,
+  213,
+  159,
+  108,
+  210
+]);
+var CLAIM_TOKEN_DISCRIMINATOR = new Uint8Array([
+  116,
+  206,
+  27,
+  191,
+  166,
+  19,
+  0,
+  73
+]);
+var CLOSE_TOKEN_DISCRIMINATOR = new Uint8Array([
+  26,
+  74,
+  236,
+  151,
+  104,
+  64,
+  183,
+  249
+]);
+var CREATE_OPEN_ORDERS_DISCRIMINATOR = new Uint8Array([
+  229,
+  194,
+  212,
+  172,
+  8,
+  10,
+  134,
+  147
+]);
+var CREATE_PROGRAM_OPEN_ORDERS_DISCRIMINATOR = new Uint8Array([
+  28,
+  226,
+  32,
+  148,
+  188,
+  136,
+  113,
+  171
+]);
+var CREATE_TOKEN_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  147,
+  241,
+  123,
+  100,
+  244,
+  132,
+  174,
+  118
+]);
+var CREATE_TOKEN_LEDGER_DISCRIMINATOR = new Uint8Array([
+  232,
+  242,
+  197,
+  253,
+  240,
+  143,
+  129,
+  52
+]);
+var EXACT_OUT_ROUTE_DISCRIMINATOR = new Uint8Array([
+  208,
+  51,
+  239,
+  151,
+  123,
+  43,
+  237,
+  92
+]);
+var EXACT_OUT_ROUTE_V2_DISCRIMINATOR = new Uint8Array([
+  157,
+  138,
+  184,
+  82,
+  21,
+  244,
+  243,
+  36
+]);
+var ROUTE_DISCRIMINATOR = new Uint8Array([
+  229,
+  23,
+  203,
+  151,
+  122,
+  227,
+  173,
+  42
+]);
+var ROUTE_V2_DISCRIMINATOR = new Uint8Array([
+  187,
+  100,
+  250,
+  204,
+  49,
+  196,
+  175,
+  20
+]);
+var ROUTE_WITH_TOKEN_LEDGER_DISCRIMINATOR = new Uint8Array([
+  150,
+  86,
+  71,
+  116,
+  167,
+  93,
+  14,
+  104
+]);
+var SET_TOKEN_LEDGER_DISCRIMINATOR = new Uint8Array([
+  228,
+  85,
+  185,
+  112,
+  78,
+  79,
+  77,
+  2
+]);
+var SHARED_ACCOUNTS_EXACT_OUT_ROUTE_DISCRIMINATOR = new Uint8Array([
+  176,
+  209,
+  105,
+  168,
+  154,
+  125,
+  69,
+  62
+]);
+var SHARED_ACCOUNTS_EXACT_OUT_ROUTE_V2_DISCRIMINATOR = new Uint8Array([
+  53,
+  96,
+  229,
+  202,
+  216,
+  187,
+  250,
+  24
+]);
+var SHARED_ACCOUNTS_ROUTE_DISCRIMINATOR = new Uint8Array([
+  193,
+  32,
+  155,
+  51,
+  65,
+  214,
+  156,
+  129
+]);
+var SHARED_ACCOUNTS_ROUTE_V2_DISCRIMINATOR = new Uint8Array([
+  209,
+  152,
+  83,
+  147,
+  124,
+  254,
+  216,
+  233
+]);
+var SHARED_ACCOUNTS_ROUTE_WITH_TOKEN_LEDGER_DISCRIMINATOR = new Uint8Array([230, 121, 143, 80, 119, 159, 106, 170]);
+
+// src/txbuilder/modifyTunaSpotPositionJupiter.ts
+var import_whirlpools_client8 = require("@orca-so/whirlpools-client");
+var import_memo10 = require("@solana-program/memo");
 var import_token_202215 = require("@solana-program/token-2022");
 var import_assert13 = __toESM(require("assert"));
+async function modifyTunaSpotPositionJupiterInstructions(rpc, authority, poolAddress, remainingAccounts, args, createInstructions, cleanupInstructions) {
+  const instructions = [];
+  if (!createInstructions) createInstructions = instructions;
+  if (!cleanupInstructions) cleanupInstructions = instructions;
+  const tunaConfig = await fetchTunaConfig(rpc, (await getTunaConfigAddress())[0]);
+  const marketAddress = (await getMarketAddress(poolAddress))[0];
+  const market = await fetchMarket(rpc, marketAddress);
+  const pool = market.data.marketMaker == 1 /* Fusion */ ? await (0, import_fusionamm_client8.fetchFusionPool)(rpc, poolAddress) : await (0, import_whirlpools_client8.fetchWhirlpool)(rpc, poolAddress);
+  const [mintA, mintB] = await (0, import_token_202215.fetchAllMaybeMint)(rpc, [pool.data.tokenMintA, pool.data.tokenMintB]);
+  (0, import_assert13.default)(mintA.exists, "Token A account not found");
+  (0, import_assert13.default)(mintB.exists, "Token B account not found");
+  const [vaultA, vaultB] = await fetchAllVault(rpc, [
+    (await getLendingVaultAddress(mintA.address))[0],
+    (await getLendingVaultAddress(mintB.address))[0]
+  ]);
+  const createUserAtaAInstructions = await getCreateAtaInstructions(
+    rpc,
+    authority,
+    mintA.address,
+    authority.address,
+    mintA.programAddress
+  );
+  createInstructions.push(...createUserAtaAInstructions.init);
+  const createUserAtaBInstructions = await getCreateAtaInstructions(
+    rpc,
+    authority,
+    mintB.address,
+    authority.address,
+    mintB.programAddress
+  );
+  createInstructions.push(...createUserAtaBInstructions.init);
+  const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
+    rpc,
+    authority,
+    mintA.address,
+    tunaConfig.data.feeRecipient,
+    mintA.programAddress
+  );
+  createInstructions.push(...createFeeRecipientAtaAInstructions.init);
+  const createFeeRecipientAtaBInstructions = await getCreateAtaInstructions(
+    rpc,
+    authority,
+    mintB.address,
+    tunaConfig.data.feeRecipient,
+    mintB.programAddress
+  );
+  createInstructions.push(...createFeeRecipientAtaBInstructions.init);
+  const ix = await modifyTunaSpotPositionJupiterInstruction(
+    authority,
+    tunaConfig,
+    mintA,
+    mintB,
+    vaultA,
+    vaultB,
+    poolAddress,
+    remainingAccounts,
+    { ...args }
+  );
+  instructions.push(ix);
+  if (createUserAtaAInstructions) cleanupInstructions.push(...createUserAtaAInstructions.cleanup);
+  if (createUserAtaBInstructions) cleanupInstructions.push(...createUserAtaBInstructions.cleanup);
+  return instructions;
+}
+async function modifyTunaSpotPositionJupiterInstruction(authority, tunaConfig, mintA, mintB, vaultA, vaultB, poolAddress, remainingAccounts, args) {
+  const marketAddress = (await getMarketAddress(poolAddress))[0];
+  const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, poolAddress))[0];
+  const tunaPositionOwnerAtaA = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: authority.address,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const tunaPositionOwnerAtaB = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: authority.address,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  const feeRecipientAtaA = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: tunaConfig.data.feeRecipient,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const feeRecipientAtaB = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: tunaConfig.data.feeRecipient,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  const tunaPositionAtaA = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: tunaPositionAddress,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const tunaPositionAtaB = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: tunaPositionAddress,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  const vaultAAta = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: vaultA.address,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const vaultBAta = (await (0, import_token_202215.findAssociatedTokenPda)({
+    owner: vaultB.address,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  const ix = getModifyTunaSpotPositionJupiterInstruction({
+    authority,
+    tunaConfig: tunaConfig.address,
+    mintA: mintA.address,
+    mintB: mintB.address,
+    tokenProgramA: mintA.programAddress,
+    tokenProgramB: mintB.programAddress,
+    market: marketAddress,
+    pythOraclePriceFeedA: vaultA.data.pythOraclePriceUpdate,
+    pythOraclePriceFeedB: vaultB.data.pythOraclePriceUpdate,
+    vaultA: vaultA.address,
+    vaultAAta,
+    vaultB: vaultB.address,
+    vaultBAta,
+    tunaPosition: tunaPositionAddress,
+    tunaPositionAtaA,
+    tunaPositionAtaB,
+    tunaPositionOwnerAtaA,
+    tunaPositionOwnerAtaB,
+    feeRecipientAtaA,
+    feeRecipientAtaB,
+    pool: poolAddress,
+    jupiterProgram: JUPITER_PROGRAM_ADDRESS,
+    jupiterEventAuthority: JUPITER_EVENT_AUTHORITY,
+    jupiterProgramAuthority: JUPITER_PROGRAM_AUTHORITY,
+    memoProgram: import_memo10.MEMO_PROGRAM_ADDRESS,
+    ...args
+  });
+  ix.accounts.push(...remainingAccounts);
+  return ix;
+}
+
+// src/txbuilder/closeTunaSpotPosition.ts
+var import_token_202216 = require("@solana-program/token-2022");
+var import_assert14 = __toESM(require("assert"));
 async function closeTunaSpotPositionInstructions(rpc, authority, poolAddress) {
   const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, poolAddress))[0];
   const tunaPosition = await fetchMaybeTunaSpotPosition(rpc, tunaPositionAddress);
   if (!tunaPosition.exists) throw new Error("Tuna position account not found");
-  const [mintA, mintB] = await (0, import_token_202215.fetchAllMaybeMint)(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  (0, import_assert13.default)(mintA.exists, "Token A account not found");
-  (0, import_assert13.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202216.fetchAllMaybeMint)(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  (0, import_assert14.default)(mintA.exists, "Token A account not found");
+  (0, import_assert14.default)(mintB.exists, "Token B account not found");
   const ix = await closeTunaSpotPositionInstruction(authority, poolAddress, mintA, mintB);
   return [ix];
 }
 async function closeTunaSpotPositionInstruction(authority, poolAddress, mintA, mintB) {
   const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, poolAddress))[0];
-  const tunaPositionAtaA = (await (0, import_token_202215.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202216.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202215.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202216.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -10993,11 +11410,11 @@ async function createTunaConfigInstruction(authority, ownerAuthority, adminAutho
 }
 
 // src/txbuilder/createVault.ts
-var import_token_202216 = require("@solana-program/token-2022");
+var import_token_202217 = require("@solana-program/token-2022");
 async function createVaultInstructions(authority, mint, args) {
   const tunaConfig = (await getTunaConfigAddress())[0];
   const vault = (await getLendingVaultAddress(mint.address))[0];
-  const vaultAta = (await (0, import_token_202216.findAssociatedTokenPda)({
+  const vaultAta = (await (0, import_token_202217.findAssociatedTokenPda)({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -11017,10 +11434,10 @@ async function createVaultInstructions(authority, mint, args) {
 }
 
 // src/txbuilder/liquidateTunaLpPositionOrca.ts
-var import_whirlpools_client8 = require("@orca-so/whirlpools-client");
-var import_kit82 = require("@solana/kit");
-var import_memo10 = require("@solana-program/memo");
-var import_token_202217 = require("@solana-program/token-2022");
+var import_whirlpools_client9 = require("@orca-so/whirlpools-client");
+var import_kit116 = require("@solana/kit");
+var import_memo11 = require("@solana-program/memo");
+var import_token_202218 = require("@solana-program/token-2022");
 async function liquidateTunaLpPositionOrcaInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, decreasePercent) {
   const instructions = [];
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
@@ -11058,39 +11475,39 @@ async function liquidateTunaLpPositionOrcaInstructions(authority, tunaPosition,
 async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, decreasePercent) {
   const positionMint = tunaPosition.data.positionMint;
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
-  const orcaPositionAddress = (await (0, import_whirlpools_client8.getPositionAddress)(positionMint))[0];
-  const orcaOracleAddress = (await (0, import_whirlpools_client8.getOracleAddress)(whirlpool.address))[0];
-  const tunaPositionAta = (await (0, import_token_202217.findAssociatedTokenPda)({
+  const orcaPositionAddress = (await (0, import_whirlpools_client9.getPositionAddress)(positionMint))[0];
+  const orcaOracleAddress = (await (0, import_whirlpools_client9.getOracleAddress)(whirlpool.address))[0];
+  const tunaPositionAta = (await (0, import_token_202218.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: positionMint,
-    tokenProgram: import_token_202217.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202218.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202217.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202218.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202217.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202218.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202217.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202218.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202217.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202218.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202217.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202218.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202217.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202218.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11105,16 +11522,16 @@ async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, t
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit82.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit82.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit82.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit82.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit82.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit82.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit82.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit82.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit82.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit82.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit116.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit116.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit116.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit116.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit116.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit116.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit116.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit116.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit116.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit116.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11146,10 +11563,10 @@ async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, t
     feeRecipientAtaA,
     feeRecipientAtaB,
     whirlpool: whirlpool.address,
-    whirlpoolProgram: import_whirlpools_client8.WHIRLPOOL_PROGRAM_ADDRESS,
+    whirlpoolProgram: import_whirlpools_client9.WHIRLPOOL_PROGRAM_ADDRESS,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo10.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo11.MEMO_PROGRAM_ADDRESS,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11158,10 +11575,10 @@ async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, t
 }
 
 // src/txbuilder/liquidateTunaLpPositionFusion.ts
-var import_fusionamm_client8 = require("@crypticdot/fusionamm-client");
-var import_kit83 = require("@solana/kit");
-var import_memo11 = require("@solana-program/memo");
-var import_token_202218 = require("@solana-program/token-2022");
+var import_fusionamm_client9 = require("@crypticdot/fusionamm-client");
+var import_kit117 = require("@solana/kit");
+var import_memo12 = require("@solana-program/memo");
+var import_token_202219 = require("@solana-program/token-2022");
 async function liquidateTunaLpPositionFusionInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, decreasePercent) {
   const instructions = [];
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
@@ -11199,38 +11616,38 @@ async function liquidateTunaLpPositionFusionInstructions(authority, tunaPosition
 async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool, decreasePercent) {
   const positionMint = tunaPosition.data.positionMint;
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
-  const fusionPositionAddress = (await (0, import_fusionamm_client8.getPositionAddress)(positionMint))[0];
-  const tunaPositionAta = (await (0, import_token_202218.findAssociatedTokenPda)({
+  const fusionPositionAddress = (await (0, import_fusionamm_client9.getPositionAddress)(positionMint))[0];
+  const tunaPositionAta = (await (0, import_token_202219.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: positionMint,
-    tokenProgram: import_token_202218.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202219.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202218.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202219.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202218.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202219.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202218.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202219.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202218.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202219.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202218.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202219.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202218.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202219.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11245,15 +11662,15 @@ async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition,
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit83.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit83.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit83.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit83.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit83.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit83.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit83.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit83.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit83.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit117.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit117.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit117.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit117.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit117.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit117.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit117.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit117.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit117.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11284,10 +11701,10 @@ async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition,
     feeRecipientAtaA,
     feeRecipientAtaB,
     fusionPool: fusionPool.address,
-    fusionammProgram: import_fusionamm_client8.FUSIONAMM_PROGRAM_ADDRESS,
+    fusionammProgram: import_fusionamm_client9.FUSIONAMM_PROGRAM_ADDRESS,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo11.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo12.MEMO_PROGRAM_ADDRESS,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11296,10 +11713,10 @@ async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition,
 }
 
 // src/txbuilder/liquidateTunaSpotPositionFusion.ts
-var import_fusionamm_client9 = require("@crypticdot/fusionamm-client");
-var import_kit84 = require("@solana/kit");
-var import_memo12 = require("@solana-program/memo");
-var import_token_202219 = require("@solana-program/token-2022");
+var import_fusionamm_client10 = require("@crypticdot/fusionamm-client");
+var import_kit118 = require("@solana/kit");
+var import_memo13 = require("@solana-program/memo");
+var import_token_202220 = require("@solana-program/token-2022");
 async function liquidateTunaSpotPositionFusionInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool, createTunaPositionOwnerAta, decreasePercent) {
   const instructions = [];
   if (createTunaPositionOwnerAta) {
@@ -11347,55 +11764,55 @@ async function liquidateTunaSpotPositionFusionInstructions(authority, tunaPositi
 }
 async function liquidateTunaSpotPositionFusionInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool, decreasePercent) {
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
-  const tunaPositionOwnerAtaA = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaA = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: tunaPosition.data.authority,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaB = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: tunaPosition.data.authority,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202219.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202220.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const swapTickArrays = await FusionUtils.getSwapTickArrayAddresses(fusionPool);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit84.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit84.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit84.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit84.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit84.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit84.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit84.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit118.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit118.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit118.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit118.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit118.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit118.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit118.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11427,8 +11844,8 @@ async function liquidateTunaSpotPositionFusionInstruction(authority, tunaPositio
     feeRecipientAtaA,
     feeRecipientAtaB,
     fusionPool: fusionPool.address,
-    fusionammProgram: import_fusionamm_client9.FUSIONAMM_PROGRAM_ADDRESS,
-    memoProgram: import_memo12.MEMO_PROGRAM_ADDRESS,
+    fusionammProgram: import_fusionamm_client10.FUSIONAMM_PROGRAM_ADDRESS,
+    memoProgram: import_memo13.MEMO_PROGRAM_ADDRESS,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11437,10 +11854,10 @@ async function liquidateTunaSpotPositionFusionInstruction(authority, tunaPositio
 }
 
 // src/txbuilder/liquidateTunaSpotPositionOrca.ts
-var import_whirlpools_client9 = require("@orca-so/whirlpools-client");
-var import_kit85 = require("@solana/kit");
-var import_memo13 = require("@solana-program/memo");
-var import_token_202220 = require("@solana-program/token-2022");
+var import_whirlpools_client10 = require("@orca-so/whirlpools-client");
+var import_kit119 = require("@solana/kit");
+var import_memo14 = require("@solana-program/memo");
+var import_token_202221 = require("@solana-program/token-2022");
 async function liquidateTunaSpotPositionOrcaInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, createTunaPositionOwnerAta, decreasePercent) {
   const instructions = [];
   if (createTunaPositionOwnerAta) {
@@ -11488,57 +11905,57 @@ async function liquidateTunaSpotPositionOrcaInstructions(authority, tunaPosition
 }
 async function liquidateTunaSpotPositionOrcaInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, decreasePercent) {
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
-  const orcaOracleAddress = (await (0, import_whirlpools_client9.getOracleAddress)(whirlpool.address))[0];
-  const tunaPositionOwnerAtaA = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const orcaOracleAddress = (await (0, import_whirlpools_client10.getOracleAddress)(whirlpool.address))[0];
+  const tunaPositionOwnerAtaA = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: tunaPosition.data.authority,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaB = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: tunaPosition.data.authority,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202220.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202221.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const swapTickArrays = await OrcaUtils.getSwapTickArrayAddresses(whirlpool);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit85.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit85.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit85.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit85.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit85.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit85.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit85.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit85.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit119.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit119.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit119.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit119.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit119.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit119.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit119.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit119.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11571,8 +11988,8 @@ async function liquidateTunaSpotPositionOrcaInstruction(authority, tunaPosition,
     feeRecipientAtaA,
     feeRecipientAtaB,
     whirlpool: whirlpool.address,
-    whirlpoolProgram: import_whirlpools_client9.WHIRLPOOL_PROGRAM_ADDRESS,
-    memoProgram: import_memo13.MEMO_PROGRAM_ADDRESS,
+    whirlpoolProgram: import_whirlpools_client10.WHIRLPOOL_PROGRAM_ADDRESS,
+    memoProgram: import_memo14.MEMO_PROGRAM_ADDRESS,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11581,29 +11998,29 @@ async function liquidateTunaSpotPositionOrcaInstruction(authority, tunaPosition,
 }
 
 // src/txbuilder/openTunaLpPositionOrca.ts
-var import_whirlpools_client10 = require("@orca-so/whirlpools-client");
-var import_token_202221 = require("@solana-program/token-2022");
-var import_assert14 = __toESM(require("assert"));
+var import_whirlpools_client11 = require("@orca-so/whirlpools-client");
+var import_token_202222 = require("@solana-program/token-2022");
+var import_assert15 = __toESM(require("assert"));
 async function openTunaLpPositionOrcaInstruction(rpc, authority, positionMint, whirlpoolAddress, args) {
-  const whirlpool = await (0, import_whirlpools_client10.fetchMaybeWhirlpool)(rpc, whirlpoolAddress);
+  const whirlpool = await (0, import_whirlpools_client11.fetchMaybeWhirlpool)(rpc, whirlpoolAddress);
   if (!whirlpool.exists) throw new Error("Whirlpool account not found");
-  const [mintA, mintB] = await (0, import_token_202221.fetchAllMaybeMint)(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  (0, import_assert14.default)(mintA.exists, "Token A account not found");
-  (0, import_assert14.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202222.fetchAllMaybeMint)(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  (0, import_assert15.default)(mintA.exists, "Token A account not found");
+  (0, import_assert15.default)(mintB.exists, "Token B account not found");
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
-  const orcaPositionAddress = (await (0, import_whirlpools_client10.getPositionAddress)(positionMint.address))[0];
+  const orcaPositionAddress = (await (0, import_whirlpools_client11.getPositionAddress)(positionMint.address))[0];
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint.address))[0];
-  const tunaPositionAta = (await (0, import_token_202221.findAssociatedTokenPda)({
+  const tunaPositionAta = (await (0, import_token_202222.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: positionMint.address,
-    tokenProgram: import_token_202221.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202222.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202221.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202222.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202221.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202222.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11619,42 +12036,42 @@ async function openTunaLpPositionOrcaInstruction(rpc, authority, positionMint, w
     tunaPositionAta,
     tunaPositionAtaA,
     tunaPositionAtaB,
-    whirlpoolProgram: import_whirlpools_client10.WHIRLPOOL_PROGRAM_ADDRESS,
+    whirlpoolProgram: import_whirlpools_client11.WHIRLPOOL_PROGRAM_ADDRESS,
     whirlpool: whirlpool.address,
     metadataUpdateAuth: WP_NFT_UPDATE_AUTH,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    associatedTokenProgram: import_token_202221.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-    token2022Program: import_token_202221.TOKEN_2022_PROGRAM_ADDRESS,
+    associatedTokenProgram: import_token_202222.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    token2022Program: import_token_202222.TOKEN_2022_PROGRAM_ADDRESS,
     ...args
   });
 }
 
 // src/txbuilder/openTunaLpPositionFusion.ts
-var import_fusionamm_client10 = require("@crypticdot/fusionamm-client");
 var import_fusionamm_client11 = require("@crypticdot/fusionamm-client");
-var import_token_202222 = require("@solana-program/token-2022");
-var import_assert15 = __toESM(require("assert"));
+var import_fusionamm_client12 = require("@crypticdot/fusionamm-client");
+var import_token_202223 = require("@solana-program/token-2022");
+var import_assert16 = __toESM(require("assert"));
 async function openTunaLpPositionFusionInstruction(rpc, authority, positionMint, fusionPoolAddress, args) {
-  const fusionPool = await (0, import_fusionamm_client10.fetchMaybeFusionPool)(rpc, fusionPoolAddress);
+  const fusionPool = await (0, import_fusionamm_client11.fetchMaybeFusionPool)(rpc, fusionPoolAddress);
   if (!fusionPool.exists) throw new Error("Whirlpool account not found");
-  const [mintA, mintB] = await (0, import_token_202222.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  (0, import_assert15.default)(mintA.exists, "Token A account not found");
-  (0, import_assert15.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202223.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  (0, import_assert16.default)(mintA.exists, "Token A account not found");
+  (0, import_assert16.default)(mintB.exists, "Token B account not found");
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
-  const fusionPositionAddress = (await (0, import_fusionamm_client10.getPositionAddress)(positionMint.address))[0];
+  const fusionPositionAddress = (await (0, import_fusionamm_client11.getPositionAddress)(positionMint.address))[0];
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint.address))[0];
-  const tunaPositionAta = (await (0, import_token_202222.findAssociatedTokenPda)({
+  const tunaPositionAta = (await (0, import_token_202223.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: positionMint.address,
-    tokenProgram: import_token_202222.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202223.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202222.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202223.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202222.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202223.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11670,25 +12087,25 @@ async function openTunaLpPositionFusionInstruction(rpc, authority, positionMint,
     tunaPositionAta,
     tunaPositionAtaA,
     tunaPositionAtaB,
-    fusionammProgram: import_fusionamm_client10.FUSIONAMM_PROGRAM_ADDRESS,
+    fusionammProgram: import_fusionamm_client11.FUSIONAMM_PROGRAM_ADDRESS,
     fusionPool: fusionPool.address,
-    metadataUpdateAuth: import_fusionamm_client11.FP_NFT_UPDATE_AUTH,
+    metadataUpdateAuth: import_fusionamm_client12.FP_NFT_UPDATE_AUTH,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    associatedTokenProgram: import_token_202222.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-    token2022Program: import_token_202222.TOKEN_2022_PROGRAM_ADDRESS,
+    associatedTokenProgram: import_token_202223.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    token2022Program: import_token_202223.TOKEN_2022_PROGRAM_ADDRESS,
     ...args
   });
 }
 
 // src/txbuilder/openAndIncreaseTunaLpPositionOrca.ts
-var import_whirlpools_client11 = require("@orca-so/whirlpools-client");
+var import_whirlpools_client12 = require("@orca-so/whirlpools-client");
 var import_whirlpools_core4 = require("@orca-so/whirlpools-core");
-var import_kit86 = require("@solana/kit");
+var import_kit120 = require("@solana/kit");
 var import_sysvars = require("@solana/sysvars");
-var import_memo14 = require("@solana-program/memo");
-var import_token_202223 = require("@solana-program/token-2022");
-var import_assert16 = __toESM(require("assert"));
+var import_memo15 = require("@solana-program/memo");
+var import_token_202224 = require("@solana-program/token-2022");
+var import_assert17 = __toESM(require("assert"));
 
 // src/utils/sysvar.ts
 var ACCOUNT_STORAGE_OVERHEAD = 128;
@@ -11706,15 +12123,15 @@ async function openAndIncreaseTunaLpPositionOrcaInstructions(rpc, authority, whi
   if (!cleanupInstructions) cleanupInstructions = instructions;
   const rent = await (0, import_sysvars.fetchSysvarRent)(rpc);
   let nonRefundableRent = 0n;
-  const positionMint = await (0, import_kit86.generateKeyPairSigner)();
+  const positionMint = await (0, import_kit120.generateKeyPairSigner)();
   const tunaConfig = await fetchTunaConfig(rpc, (await getTunaConfigAddress())[0]);
-  const whirlpool = await (0, import_whirlpools_client11.fetchMaybeWhirlpool)(rpc, whirlpoolAddress);
+  const whirlpool = await (0, import_whirlpools_client12.fetchMaybeWhirlpool)(rpc, whirlpoolAddress);
   if (!whirlpool.exists) throw new Error("Whirlpool account not found");
   const marketAddress = (await getMarketAddress(whirlpoolAddress))[0];
   const market = await fetchMarket(rpc, marketAddress);
-  const [mintA, mintB] = await (0, import_token_202223.fetchAllMaybeMint)(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  (0, import_assert16.default)(mintA.exists, "Token A account not found");
-  (0, import_assert16.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202224.fetchAllMaybeMint)(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  (0, import_assert17.default)(mintA.exists, "Token A account not found");
+  (0, import_assert17.default)(mintB.exists, "Token B account not found");
   const [vaultA, vaultB] = await fetchAllVault(rpc, [
     (await getLendingVaultAddress(whirlpool.data.tokenMintA))[0],
     (await getLendingVaultAddress(whirlpool.data.tokenMintB))[0]
@@ -11767,16 +12184,16 @@ async function openAndIncreaseTunaLpPositionOrcaInstructions(rpc, authority, whi
   );
   createInstructions.push(...createFeeRecipientAtaBInstructions.init);
   const lowerTickArrayIndex = (0, import_whirlpools_core4.getTickArrayStartTickIndex)(args.tickLowerIndex, whirlpool.data.tickSpacing);
-  const [lowerTickArrayAddress] = await (0, import_whirlpools_client11.getTickArrayAddress)(whirlpool.address, lowerTickArrayIndex);
+  const [lowerTickArrayAddress] = await (0, import_whirlpools_client12.getTickArrayAddress)(whirlpool.address, lowerTickArrayIndex);
   const upperTickArrayIndex = (0, import_whirlpools_core4.getTickArrayStartTickIndex)(args.tickUpperIndex, whirlpool.data.tickSpacing);
-  const [upperTickArrayAddress] = await (0, import_whirlpools_client11.getTickArrayAddress)(whirlpool.address, upperTickArrayIndex);
-  const [lowerTickArray, upperTickArray] = await (0, import_whirlpools_client11.fetchAllMaybeTickArray)(rpc, [
+  const [upperTickArrayAddress] = await (0, import_whirlpools_client12.getTickArrayAddress)(whirlpool.address, upperTickArrayIndex);
+  const [lowerTickArray, upperTickArray] = await (0, import_whirlpools_client12.fetchAllMaybeTickArray)(rpc, [
     lowerTickArrayAddress,
     upperTickArrayAddress
   ]);
   if (!lowerTickArray.exists) {
     instructions.push(
-      (0, import_whirlpools_client11.getInitializeDynamicTickArrayInstruction)({
+      (0, import_whirlpools_client12.getInitializeDynamicTickArrayInstruction)({
         whirlpool: whirlpool.address,
         funder: authority,
         tickArray: lowerTickArrayAddress,
@@ -11784,11 +12201,11 @@ async function openAndIncreaseTunaLpPositionOrcaInstructions(rpc, authority, whi
         idempotent: false
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client11.getDynamicTickArrayMinSize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client12.getDynamicTickArrayMinSize)());
   }
   if (!upperTickArray.exists && lowerTickArrayIndex !== upperTickArrayIndex) {
     instructions.push(
-      (0, import_whirlpools_client11.getInitializeDynamicTickArrayInstruction)({
+      (0, import_whirlpools_client12.getInitializeDynamicTickArrayInstruction)({
         whirlpool: whirlpool.address,
         funder: authority,
         tickArray: upperTickArrayAddress,
@@ -11796,7 +12213,7 @@ async function openAndIncreaseTunaLpPositionOrcaInstructions(rpc, authority, whi
         idempotent: false
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client11.getDynamicTickArrayMinSize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client12.getDynamicTickArrayMinSize)());
   }
   const ix = await openAndIncreaseTunaLpPositionOrcaInstruction(
     authority,
@@ -11815,55 +12232,55 @@ async function openAndIncreaseTunaLpPositionOrcaInstructions(rpc, authority, whi
   return {
     instructions,
     positionMint: positionMint.address,
-    initializationCost: (0, import_kit86.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit120.lamports)(nonRefundableRent)
   };
 }
 async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionMint, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, args) {
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint.address))[0];
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
-  const orcaPositionAddress = (await (0, import_whirlpools_client11.getPositionAddress)(positionMint.address))[0];
-  const orcaOracleAddress = (await (0, import_whirlpools_client11.getOracleAddress)(whirlpool.address))[0];
-  const tunaPositionAta = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const orcaPositionAddress = (await (0, import_whirlpools_client12.getPositionAddress)(positionMint.address))[0];
+  const orcaOracleAddress = (await (0, import_whirlpools_client12.getOracleAddress)(whirlpool.address))[0];
+  const tunaPositionAta = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: positionMint.address,
-    tokenProgram: import_token_202223.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202224.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionOwnerAtaA = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaA = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaB = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202223.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202224.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11872,16 +12289,16 @@ async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionM
   const lowerTickArrayAddress = await OrcaUtils.getTickArrayAddressFromTickIndex(whirlpool, args.tickLowerIndex);
   const upperTickArrayAddress = await OrcaUtils.getTickArrayAddressFromTickIndex(whirlpool, args.tickUpperIndex);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit86.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit86.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit86.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit86.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit86.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit86.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit86.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit86.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit86.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit86.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit120.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit120.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit120.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit120.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit120.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit120.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit120.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit120.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit120.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit120.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11915,14 +12332,14 @@ async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionM
     feeRecipientAtaA,
     feeRecipientAtaB,
     whirlpool: whirlpool.address,
-    whirlpoolProgram: import_whirlpools_client11.WHIRLPOOL_PROGRAM_ADDRESS,
+    whirlpoolProgram: import_whirlpools_client12.WHIRLPOOL_PROGRAM_ADDRESS,
     orcaPosition: orcaPositionAddress,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo14.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo15.MEMO_PROGRAM_ADDRESS,
     metadataUpdateAuth: WP_NFT_UPDATE_AUTH,
-    associatedTokenProgram: import_token_202223.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-    token2022Program: import_token_202223.TOKEN_2022_PROGRAM_ADDRESS,
+    associatedTokenProgram: import_token_202224.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    token2022Program: import_token_202224.TOKEN_2022_PROGRAM_ADDRESS,
     ...args,
     remainingAccountsInfo
   });
@@ -11931,28 +12348,28 @@ async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionM
 }
 
 // src/txbuilder/openAndIncreaseTunaLpPositionFusion.ts
-var import_fusionamm_client12 = require("@crypticdot/fusionamm-client");
+var import_fusionamm_client13 = require("@crypticdot/fusionamm-client");
 var import_fusionamm_core5 = require("@crypticdot/fusionamm-core");
-var import_kit87 = require("@solana/kit");
+var import_kit121 = require("@solana/kit");
 var import_sysvars2 = require("@solana/sysvars");
-var import_memo15 = require("@solana-program/memo");
-var import_token_202224 = require("@solana-program/token-2022");
-var import_assert17 = __toESM(require("assert"));
+var import_memo16 = require("@solana-program/memo");
+var import_token_202225 = require("@solana-program/token-2022");
+var import_assert18 = __toESM(require("assert"));
 async function openAndIncreaseTunaLpPositionFusionInstructions(rpc, authority, fusionPoolAddress, args, createInstructions, cleanupInstructions) {
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
   const rent = await (0, import_sysvars2.fetchSysvarRent)(rpc);
   let nonRefundableRent = 0n;
-  const positionMint = await (0, import_kit87.generateKeyPairSigner)();
+  const positionMint = await (0, import_kit121.generateKeyPairSigner)();
   const tunaConfig = await fetchTunaConfig(rpc, (await getTunaConfigAddress())[0]);
-  const fusionPool = await (0, import_fusionamm_client12.fetchMaybeFusionPool)(rpc, fusionPoolAddress);
+  const fusionPool = await (0, import_fusionamm_client13.fetchMaybeFusionPool)(rpc, fusionPoolAddress);
   if (!fusionPool.exists) throw new Error("FusionPool account not found");
   const marketAddress = (await getMarketAddress(fusionPoolAddress))[0];
   const market = await fetchMarket(rpc, marketAddress);
-  const [mintA, mintB] = await (0, import_token_202224.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  (0, import_assert17.default)(mintA.exists, "Token A account not found");
-  (0, import_assert17.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202225.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  (0, import_assert18.default)(mintA.exists, "Token A account not found");
+  (0, import_assert18.default)(mintB.exists, "Token B account not found");
   const [vaultA, vaultB] = await fetchAllVault(rpc, [
     (await getLendingVaultAddress(fusionPool.data.tokenMintA))[0],
     (await getLendingVaultAddress(fusionPool.data.tokenMintB))[0]
@@ -12005,34 +12422,34 @@ async function openAndIncreaseTunaLpPositionFusionInstructions(rpc, authority, f
   );
   createInstructions.push(...createFeeRecipientAtaBInstructions.init);
   const lowerTickArrayIndex = (0, import_fusionamm_core5.getTickArrayStartTickIndex)(args.tickLowerIndex, fusionPool.data.tickSpacing);
-  const [lowerTickArrayAddress] = await (0, import_fusionamm_client12.getTickArrayAddress)(fusionPool.address, lowerTickArrayIndex);
+  const [lowerTickArrayAddress] = await (0, import_fusionamm_client13.getTickArrayAddress)(fusionPool.address, lowerTickArrayIndex);
   const upperTickArrayIndex = (0, import_fusionamm_core5.getTickArrayStartTickIndex)(args.tickUpperIndex, fusionPool.data.tickSpacing);
-  const [upperTickArrayAddress] = await (0, import_fusionamm_client12.getTickArrayAddress)(fusionPool.address, upperTickArrayIndex);
-  const [lowerTickArray, upperTickArray] = await (0, import_fusionamm_client12.fetchAllMaybeTickArray)(rpc, [
+  const [upperTickArrayAddress] = await (0, import_fusionamm_client13.getTickArrayAddress)(fusionPool.address, upperTickArrayIndex);
+  const [lowerTickArray, upperTickArray] = await (0, import_fusionamm_client13.fetchAllMaybeTickArray)(rpc, [
     lowerTickArrayAddress,
     upperTickArrayAddress
   ]);
   if (!lowerTickArray.exists) {
     instructions.push(
-      (0, import_fusionamm_client12.getInitializeTickArrayInstruction)({
+      (0, import_fusionamm_client13.getInitializeTickArrayInstruction)({
         fusionPool: fusionPool.address,
         funder: authority,
         tickArray: lowerTickArrayAddress,
         startTickIndex: lowerTickArrayIndex
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client12.getTickArraySize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client13.getTickArraySize)());
   }
   if (!upperTickArray.exists && lowerTickArrayIndex !== upperTickArrayIndex) {
     instructions.push(
-      (0, import_fusionamm_client12.getInitializeTickArrayInstruction)({
+      (0, import_fusionamm_client13.getInitializeTickArrayInstruction)({
         fusionPool: fusionPool.address,
         funder: authority,
         tickArray: upperTickArrayAddress,
         startTickIndex: upperTickArrayIndex
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client12.getTickArraySize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client13.getTickArraySize)());
   }
   const ix = await openAndIncreaseTunaLpPositionFusionInstruction(
     authority,
@@ -12051,54 +12468,54 @@ async function openAndIncreaseTunaLpPositionFusionInstructions(rpc, authority, f
   return {
     instructions,
     positionMint: positionMint.address,
-    initializationCost: (0, import_kit87.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit121.lamports)(nonRefundableRent)
   };
 }
 async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positionMint, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool, args) {
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint.address))[0];
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
-  const fusionPositionAddress = (await (0, import_fusionamm_client12.getPositionAddress)(positionMint.address))[0];
-  const tunaPositionAta = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const fusionPositionAddress = (await (0, import_fusionamm_client13.getPositionAddress)(positionMint.address))[0];
+  const tunaPositionAta = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: positionMint.address,
-    tokenProgram: import_token_202224.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202225.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionOwnerAtaA = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaA = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaB = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202224.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202225.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12107,15 +12524,15 @@ async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positio
   const lowerTickArrayAddress = await FusionUtils.getTickArrayAddressFromTickIndex(fusionPool, args.tickLowerIndex);
   const upperTickArrayAddress = await FusionUtils.getTickArrayAddressFromTickIndex(fusionPool, args.tickUpperIndex);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit87.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit87.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit87.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit87.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit87.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit87.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit87.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit87.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit87.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit121.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit121.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit121.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit121.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit121.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit121.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit121.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit121.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit121.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -12148,14 +12565,14 @@ async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positio
     feeRecipientAtaA,
     feeRecipientAtaB,
     fusionPool: fusionPool.address,
-    fusionammProgram: import_fusionamm_client12.FUSIONAMM_PROGRAM_ADDRESS,
+    fusionammProgram: import_fusionamm_client13.FUSIONAMM_PROGRAM_ADDRESS,
     fusionPosition: fusionPositionAddress,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo15.MEMO_PROGRAM_ADDRESS,
-    metadataUpdateAuth: import_fusionamm_client12.FP_NFT_UPDATE_AUTH,
-    associatedTokenProgram: import_token_202224.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-    token2022Program: import_token_202224.TOKEN_2022_PROGRAM_ADDRESS,
+    memoProgram: import_memo16.MEMO_PROGRAM_ADDRESS,
+    metadataUpdateAuth: import_fusionamm_client13.FP_NFT_UPDATE_AUTH,
+    associatedTokenProgram: import_token_202225.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    token2022Program: import_token_202225.TOKEN_2022_PROGRAM_ADDRESS,
     ...args,
     remainingAccountsInfo
   });
@@ -12164,36 +12581,36 @@ async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positio
 }
 
 // src/txbuilder/openTunaSpotPosition.ts
-var import_fusionamm_client13 = require("@crypticdot/fusionamm-client");
-var import_whirlpools_client12 = require("@orca-so/whirlpools-client");
-var import_kit88 = require("@solana/kit");
-var import_token_202225 = require("@solana-program/token-2022");
-var import_assert18 = __toESM(require("assert"));
+var import_fusionamm_client14 = require("@crypticdot/fusionamm-client");
+var import_whirlpools_client13 = require("@orca-so/whirlpools-client");
+var import_kit122 = require("@solana/kit");
+var import_token_202226 = require("@solana-program/token-2022");
+var import_assert19 = __toESM(require("assert"));
 async function openTunaSpotPositionInstructions(rpc, authority, poolAddress, args) {
-  const poolAccount = await (0, import_kit88.fetchEncodedAccount)(rpc, poolAddress);
-  (0, import_assert18.default)(poolAccount.exists, "Pool account not found");
+  const poolAccount = await (0, import_kit122.fetchEncodedAccount)(rpc, poolAddress);
+  (0, import_assert19.default)(poolAccount.exists, "Pool account not found");
   let pool;
-  if (poolAccount.programAddress == import_fusionamm_client13.FUSIONAMM_PROGRAM_ADDRESS) {
-    pool = (0, import_kit88.decodeAccount)(poolAccount, (0, import_fusionamm_client13.getFusionPoolDecoder)());
-  } else if (poolAccount.programAddress == import_whirlpools_client12.WHIRLPOOL_PROGRAM_ADDRESS) {
-    pool = (0, import_kit88.decodeAccount)(poolAccount, (0, import_whirlpools_client12.getWhirlpoolDecoder)());
+  if (poolAccount.programAddress == import_fusionamm_client14.FUSIONAMM_PROGRAM_ADDRESS) {
+    pool = (0, import_kit122.decodeAccount)(poolAccount, (0, import_fusionamm_client14.getFusionPoolDecoder)());
+  } else if (poolAccount.programAddress == import_whirlpools_client13.WHIRLPOOL_PROGRAM_ADDRESS) {
+    pool = (0, import_kit122.decodeAccount)(poolAccount, (0, import_whirlpools_client13.getWhirlpoolDecoder)());
   } else {
     throw new Error("Incorrect Fusion or Orca pool account");
   }
-  const [mintA, mintB] = await (0, import_token_202225.fetchAllMaybeMint)(rpc, [pool.data.tokenMintA, pool.data.tokenMintB]);
-  (0, import_assert18.default)(mintA.exists, "Token A account not found");
-  (0, import_assert18.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202226.fetchAllMaybeMint)(rpc, [pool.data.tokenMintA, pool.data.tokenMintB]);
+  (0, import_assert19.default)(mintA.exists, "Token A account not found");
+  (0, import_assert19.default)(mintB.exists, "Token B account not found");
   const ix = await openTunaSpotPositionInstruction(authority, mintA, mintB, poolAddress, args);
   return [ix];
 }
 async function openTunaSpotPositionInstruction(authority, mintA, mintB, poolAddress, args) {
   const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, poolAddress))[0];
-  const tunaPositionAtaA = (await (0, import_token_202225.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202226.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202225.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202226.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12208,48 +12625,48 @@ async function openTunaSpotPositionInstruction(authority, mintA, mintB, poolAddr
     tunaPositionAtaA,
     tunaPositionAtaB,
     pool: poolAddress,
-    associatedTokenProgram: import_token_202225.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    associatedTokenProgram: import_token_202226.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     ...args
   });
 }
 
 // src/txbuilder/decreaseTunaLpPositionOrca.ts
-var import_whirlpools_client13 = require("@orca-so/whirlpools-client");
+var import_whirlpools_client14 = require("@orca-so/whirlpools-client");
 var import_whirlpools_core5 = require("@orca-so/whirlpools-core");
-var import_kit89 = require("@solana/kit");
-var import_memo16 = require("@solana-program/memo");
-var import_token_202226 = require("@solana-program/token-2022");
-var import_assert19 = __toESM(require("assert"));
+var import_kit123 = require("@solana/kit");
+var import_memo17 = require("@solana-program/memo");
+var import_token_202227 = require("@solana-program/token-2022");
+var import_assert20 = __toESM(require("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 (0, import_whirlpools_client13.fetchPosition)(rpc, (await (0, import_whirlpools_client13.getPositionAddress)(positionMint))[0]);
-  const whirlpool = await (0, import_whirlpools_client13.fetchMaybeWhirlpool)(rpc, tunaPosition.data.pool);
+  const orcaPosition = await (0, import_whirlpools_client14.fetchPosition)(rpc, (await (0, import_whirlpools_client14.getPositionAddress)(positionMint))[0]);
+  const whirlpool = await (0, import_whirlpools_client14.fetchMaybeWhirlpool)(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 (0, import_token_202226.fetchAllMaybeMint)(rpc, [
+  const [mintA, mintB, ...rewardMints] = await (0, import_token_202227.fetchAllMaybeMint)(rpc, [
     whirlpool.data.tokenMintA,
     whirlpool.data.tokenMintB,
     ...whirlpool.data.rewardInfos.map((x) => x.mint).filter((x) => x !== DEFAULT_ADDRESS)
   ]);
   const allMints = [mintA, mintB, ...rewardMints];
-  (0, import_assert19.default)(mintA.exists, "Token A account not found");
-  (0, import_assert19.default)(mintB.exists, "Token B account not found");
-  (0, import_kit89.assertAccountsExist)(rewardMints);
+  (0, import_assert20.default)(mintA.exists, "Token A account not found");
+  (0, import_assert20.default)(mintB.exists, "Token B account not found");
+  (0, import_kit123.assertAccountsExist)(rewardMints);
   const lowerTickArrayStartIndex = (0, import_whirlpools_core5.getTickArrayStartTickIndex)(
     tunaPosition.data.tickLowerIndex,
     whirlpool.data.tickSpacing
   );
-  const [lowerTickArrayAddress] = await (0, import_whirlpools_client13.getTickArrayAddress)(whirlpool.address, lowerTickArrayStartIndex);
+  const [lowerTickArrayAddress] = await (0, import_whirlpools_client14.getTickArrayAddress)(whirlpool.address, lowerTickArrayStartIndex);
   const upperTickArrayStartIndex = (0, import_whirlpools_core5.getTickArrayStartTickIndex)(
     tunaPosition.data.tickUpperIndex,
     whirlpool.data.tickSpacing
   );
-  const [upperTickArrayAddress] = await (0, import_whirlpools_client13.getTickArrayAddress)(whirlpool.address, upperTickArrayStartIndex);
-  const [lowerTickArray, upperTickArray] = await (0, import_whirlpools_client13.fetchAllTickArray)(rpc, [lowerTickArrayAddress, upperTickArrayAddress]);
+  const [upperTickArrayAddress] = await (0, import_whirlpools_client14.getTickArrayAddress)(whirlpool.address, upperTickArrayStartIndex);
+  const [lowerTickArray, upperTickArray] = await (0, import_whirlpools_client14.fetchAllTickArray)(rpc, [lowerTickArrayAddress, upperTickArrayAddress]);
   const lowerTick = lowerTickArray.data.ticks[(0, import_whirlpools_core5.getTickIndexInArray)(tunaPosition.data.tickLowerIndex, lowerTickArrayStartIndex, whirlpool.data.tickSpacing)];
   const upperTick = upperTickArray.data.ticks[(0, import_whirlpools_core5.getTickIndexInArray)(tunaPosition.data.tickUpperIndex, upperTickArrayStartIndex, whirlpool.data.tickSpacing)];
   const instructions = [];
@@ -12278,7 +12695,7 @@ async function decreaseTunaLpPositionOrcaInstructions(rpc, authority, positionMi
   }
   for (const mintAddress of requiredMints) {
     const mint = allMints.find((mint2) => mint2.address == mintAddress);
-    (0, import_assert19.default)(mint && mint.exists);
+    (0, import_assert20.default)(mint && mint.exists);
     const ixs = await getCreateAtaInstructions(rpc, authority, mint.address, authority.address, mint.programAddress);
     createInstructions.push(...ixs.init);
     internalCleanupInstructions.push(...ixs.cleanup);
@@ -12304,39 +12721,39 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
   const positionMint = tunaPosition.data.positionMint;
   const tunaConfig = (await getTunaConfigAddress())[0];
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
-  const orcaPositionAddress = (await (0, import_whirlpools_client13.getPositionAddress)(positionMint))[0];
-  const orcaOracleAddress = (await (0, import_whirlpools_client13.getOracleAddress)(whirlpool.address))[0];
-  const tunaPositionAta = (await (0, import_token_202226.findAssociatedTokenPda)({
+  const orcaPositionAddress = (await (0, import_whirlpools_client14.getPositionAddress)(positionMint))[0];
+  const orcaOracleAddress = (await (0, import_whirlpools_client14.getOracleAddress)(whirlpool.address))[0];
+  const tunaPositionAta = (await (0, import_token_202227.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: positionMint,
-    tokenProgram: import_token_202226.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202227.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionOwnerAtaA = (await (0, import_token_202226.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaA = (await (0, import_token_202227.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await (0, import_token_202226.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaB = (await (0, import_token_202227.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202226.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202227.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202226.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202227.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202226.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202227.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202226.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202227.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12351,30 +12768,30 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit89.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit89.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit89.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit89.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit89.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit89.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit89.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit89.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit89.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit89.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit123.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit123.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit123.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit123.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit123.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit123.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit123.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit123.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit123.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit123.AccountRole.WRITABLE }
   ];
   for (const rewardIndex of rewardIndicesToClaim) {
     const rewardInfo = whirlpool.data.rewardInfos[rewardIndex];
     const rewardMint = rewardMints.find((mint) => mint.address == rewardInfo.mint);
-    (0, import_assert19.default)(rewardMint, "Reward mint not found in the provided reward mint accounts");
-    const ownerAta = await (0, import_token_202226.findAssociatedTokenPda)({
+    (0, import_assert20.default)(rewardMint, "Reward mint not found in the provided reward mint accounts");
+    const ownerAta = await (0, import_token_202227.findAssociatedTokenPda)({
       owner: authority.address,
       mint: rewardMint.address,
       tokenProgram: rewardMint.programAddress
     });
-    remainingAccounts.push({ address: rewardMint.address, role: import_kit89.AccountRole.READONLY });
-    remainingAccounts.push({ address: rewardMint.programAddress, role: import_kit89.AccountRole.READONLY });
-    remainingAccounts.push({ address: ownerAta[0], role: import_kit89.AccountRole.WRITABLE });
-    remainingAccounts.push({ address: rewardInfo.vault, role: import_kit89.AccountRole.WRITABLE });
+    remainingAccounts.push({ address: rewardMint.address, role: import_kit123.AccountRole.READONLY });
+    remainingAccounts.push({ address: rewardMint.programAddress, role: import_kit123.AccountRole.READONLY });
+    remainingAccounts.push({ address: ownerAta[0], role: import_kit123.AccountRole.WRITABLE });
+    remainingAccounts.push({ address: rewardInfo.vault, role: import_kit123.AccountRole.WRITABLE });
   }
   const remainingAccountsInfo = {
     slices: [
@@ -12409,10 +12826,10 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
     orcaPosition: orcaPositionAddress,
     tunaPosition: tunaPosition.address,
     whirlpool: whirlpool.address,
-    whirlpoolProgram: import_whirlpools_client13.WHIRLPOOL_PROGRAM_ADDRESS,
+    whirlpoolProgram: import_whirlpools_client14.WHIRLPOOL_PROGRAM_ADDRESS,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo16.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo17.MEMO_PROGRAM_ADDRESS,
     ...args,
     remainingAccountsInfo
   });
@@ -12421,23 +12838,23 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
 }
 
 // src/txbuilder/decreaseTunaLpPositionFusion.ts
-var import_fusionamm_client14 = require("@crypticdot/fusionamm-client");
-var import_kit90 = require("@solana/kit");
-var import_memo17 = require("@solana-program/memo");
-var import_token_202227 = require("@solana-program/token-2022");
-var import_assert20 = __toESM(require("assert"));
+var import_fusionamm_client15 = require("@crypticdot/fusionamm-client");
+var import_kit124 = require("@solana/kit");
+var import_memo18 = require("@solana-program/memo");
+var import_token_202228 = require("@solana-program/token-2022");
+var import_assert21 = __toESM(require("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 (0, import_fusionamm_client14.fetchMaybeFusionPool)(rpc, tunaPosition.data.pool);
+  const fusionPool = await (0, import_fusionamm_client15.fetchMaybeFusionPool)(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 (0, import_token_202227.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  (0, import_assert20.default)(mintA.exists, "Token A account not found");
-  (0, import_assert20.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202228.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  (0, import_assert21.default)(mintA.exists, "Token A account not found");
+  (0, import_assert21.default)(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -12477,38 +12894,38 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
   const positionMint = tunaPosition.data.positionMint;
   const tunaConfig = (await getTunaConfigAddress())[0];
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
-  const fusionPositionAddress = (await (0, import_fusionamm_client14.getPositionAddress)(positionMint))[0];
-  const tunaPositionAta = (await (0, import_token_202227.findAssociatedTokenPda)({
+  const fusionPositionAddress = (await (0, import_fusionamm_client15.getPositionAddress)(positionMint))[0];
+  const tunaPositionAta = (await (0, import_token_202228.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: positionMint,
-    tokenProgram: import_token_202227.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202228.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionOwnerAtaA = (await (0, import_token_202227.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaA = (await (0, import_token_202228.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await (0, import_token_202227.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaB = (await (0, import_token_202228.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202227.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202228.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202227.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202228.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await (0, import_token_202227.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202228.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202227.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202228.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12523,15 +12940,15 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit90.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit90.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit90.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit90.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit90.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit90.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit90.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit90.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit90.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit124.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit124.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit124.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit124.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit124.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit124.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit124.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit124.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit124.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -12562,10 +12979,10 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
     fusionPosition: fusionPositionAddress,
     tunaPosition: tunaPosition.address,
     fusionPool: fusionPool.address,
-    fusionammProgram: import_fusionamm_client14.FUSIONAMM_PROGRAM_ADDRESS,
+    fusionammProgram: import_fusionamm_client15.FUSIONAMM_PROGRAM_ADDRESS,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo17.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo18.MEMO_PROGRAM_ADDRESS,
     ...args,
     remainingAccountsInfo
   });
@@ -12574,19 +12991,19 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
 }
 
 // src/txbuilder/repayBadDebt.ts
-var import_memo18 = require("@solana-program/memo");
-var import_token_202228 = require("@solana-program/token-2022");
+var import_memo19 = require("@solana-program/memo");
+var import_token_202229 = require("@solana-program/token-2022");
 async function repayBadDebtInstruction(rpc, authority, mintAddress, funds, shares) {
-  const mint = await (0, import_token_202228.fetchMaybeMint)(rpc, mintAddress);
+  const mint = await (0, import_token_202229.fetchMaybeMint)(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 (0, import_token_202228.findAssociatedTokenPda)({
+  const vaultAta = (await (0, import_token_202229.findAssociatedTokenPda)({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
   }))[0];
-  const authorityAta = (await (0, import_token_202228.findAssociatedTokenPda)({
+  const authorityAta = (await (0, import_token_202229.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -12599,7 +13016,7 @@ async function repayBadDebtInstruction(rpc, authority, mintAddress, funds, share
     tunaConfig,
     vault,
     tokenProgram: mint.programAddress,
-    memoProgram: import_memo18.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo19.MEMO_PROGRAM_ADDRESS,
     funds,
     shares
   });
@@ -12631,20 +13048,20 @@ async function setTunaSpotPositionLimitOrdersInstruction(authority, poolAddress,
 }
 
 // src/txbuilder/resetTunaSpotPosition.ts
-var import_token_202229 = require("@solana-program/token-2022");
-var import_assert21 = __toESM(require("assert"));
+var import_token_202230 = require("@solana-program/token-2022");
+var import_assert22 = __toESM(require("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 (0, import_token_202229.fetchAllMaybeMint)(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  (0, import_assert21.default)(mintA.exists, "Token A not found");
-  (0, import_assert21.default)(mintB.exists, "Token B not found");
-  const tunaPositionAtaA = (await (0, import_token_202229.findAssociatedTokenPda)({
+  const [mintA, mintB] = await (0, import_token_202230.fetchAllMaybeMint)(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  (0, import_assert22.default)(mintA.exists, "Token A not found");
+  (0, import_assert22.default)(mintB.exists, "Token B not found");
+  const tunaPositionAtaA = (await (0, import_token_202230.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202229.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202230.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12685,11 +13102,11 @@ async function updateVaultInstruction(authority, mint, args) {
 }
 
 // src/txbuilder/withdraw.ts
-var import_memo19 = require("@solana-program/memo");
-var import_token_202230 = require("@solana-program/token-2022");
+var import_memo20 = require("@solana-program/memo");
+var import_token_202231 = require("@solana-program/token-2022");
 async function withdrawInstructions(rpc, authority, mintAddress, funds, shares) {
   const instructions = [];
-  const mint = await (0, import_token_202230.fetchMaybeMint)(rpc, mintAddress);
+  const mint = await (0, import_token_202231.fetchMaybeMint)(rpc, mintAddress);
   if (!mint.exists) throw new Error("Mint account not found");
   const createUserAtaInstructions = await getCreateAtaInstructions(
     rpc,
@@ -12708,12 +13125,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 (0, import_token_202230.findAssociatedTokenPda)({
+  const vaultAta = (await (0, import_token_202231.findAssociatedTokenPda)({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
   }))[0];
-  const authorityAta = (await (0, import_token_202230.findAssociatedTokenPda)({
+  const authorityAta = (await (0, import_token_202231.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -12727,35 +13144,35 @@ async function withdrawInstruction(authority, mint, funds, shares) {
     vault,
     vaultAta,
     tokenProgram: mint.programAddress,
-    memoProgram: import_memo19.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo20.MEMO_PROGRAM_ADDRESS,
     funds,
     shares
   });
 }
 
 // src/txbuilder/createMarketLookupTable.ts
-var import_fusionamm_client15 = require("@crypticdot/fusionamm-client");
-var import_whirlpools_client14 = require("@orca-so/whirlpools-client");
-var import_kit91 = require("@solana/kit");
+var import_fusionamm_client16 = require("@crypticdot/fusionamm-client");
+var import_whirlpools_client15 = require("@orca-so/whirlpools-client");
+var import_kit125 = require("@solana/kit");
 var import_address_lookup_table2 = require("@solana-program/address-lookup-table");
-var import_memo20 = require("@solana-program/memo");
+var import_memo21 = require("@solana-program/memo");
 var import_system2 = require("@solana-program/system");
 var import_token2 = require("@solana-program/token");
-var import_token_202231 = require("@solana-program/token-2022");
+var import_token_202232 = require("@solana-program/token-2022");
 async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
   const tunaConfigAddress = (await getTunaConfigAddress())[0];
   const marketAddress = (await getMarketAddress(poolAddress))[0];
-  const orcaOracleAddress = (await (0, import_whirlpools_client14.getOracleAddress)(poolAddress))[0];
+  const orcaOracleAddress = (await (0, import_whirlpools_client15.getOracleAddress)(poolAddress))[0];
   const tunaConfig = await fetchTunaConfig(rpc, tunaConfigAddress);
-  const pool = marketMaker == 0 /* Orca */ ? await (0, import_whirlpools_client14.fetchWhirlpool)(rpc, poolAddress) : await (0, import_fusionamm_client15.fetchFusionPool)(rpc, poolAddress);
-  const mintA = await (0, import_token_202231.fetchMint)(rpc, pool.data.tokenMintA);
-  const mintB = await (0, import_token_202231.fetchMint)(rpc, pool.data.tokenMintB);
-  const feeRecipientAtaA = (await (0, import_token_202231.findAssociatedTokenPda)({
+  const pool = marketMaker == 0 /* Orca */ ? await (0, import_whirlpools_client15.fetchWhirlpool)(rpc, poolAddress) : await (0, import_fusionamm_client16.fetchFusionPool)(rpc, poolAddress);
+  const mintA = await (0, import_token_202232.fetchMint)(rpc, pool.data.tokenMintA);
+  const mintB = await (0, import_token_202232.fetchMint)(rpc, pool.data.tokenMintB);
+  const feeRecipientAtaA = (await (0, import_token_202232.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202231.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202232.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12764,24 +13181,24 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
     (await getLendingVaultAddress(mintA.address))[0],
     (await getLendingVaultAddress(mintB.address))[0]
   ]);
-  const vaultAAta = (await (0, import_token_202231.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202232.findAssociatedTokenPda)({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await (0, import_token_202231.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202232.findAssociatedTokenPda)({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const addresses = [
     import_system2.SYSTEM_PROGRAM_ADDRESS,
-    (0, import_kit91.address)("SysvarRent111111111111111111111111111111111"),
-    import_token_202231.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    (0, import_kit125.address)("SysvarRent111111111111111111111111111111111"),
+    import_token_202232.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     import_token2.TOKEN_PROGRAM_ADDRESS,
-    import_token_202231.TOKEN_2022_PROGRAM_ADDRESS,
+    import_token_202232.TOKEN_2022_PROGRAM_ADDRESS,
     NATIVE_MINT,
-    import_memo20.MEMO_PROGRAM_ADDRESS,
+    import_memo21.MEMO_PROGRAM_ADDRESS,
     tunaConfigAddress,
     marketAddress,
     mintA.address,
@@ -12800,7 +13217,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(import_whirlpools_client14.WHIRLPOOL_PROGRAM_ADDRESS);
+    addresses.push(import_whirlpools_client15.WHIRLPOOL_PROGRAM_ADDRESS);
     addresses.push(WP_NFT_UPDATE_AUTH);
     addresses.push(orcaOracleAddress);
     const whirlpool = pool;
@@ -12812,8 +13229,8 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
       }
     }
   } else {
-    addresses.push(import_fusionamm_client15.FUSIONAMM_PROGRAM_ADDRESS);
-    addresses.push(import_fusionamm_client15.FP_NFT_UPDATE_AUTH);
+    addresses.push(import_fusionamm_client16.FUSIONAMM_PROGRAM_ADDRESS);
+    addresses.push(import_fusionamm_client16.FP_NFT_UPDATE_AUTH);
   }
   return addresses;
 }
@@ -12836,17 +13253,17 @@ async function extendAddressLookupTableForMarketInstructions(rpc, poolAddress, m
 }
 
 // src/txbuilder/repayTunaLpPositionDebt.ts
-var import_memo21 = require("@solana-program/memo");
-var import_token_202232 = require("@solana-program/token-2022");
-var import_assert22 = __toESM(require("assert"));
+var import_memo22 = require("@solana-program/memo");
+var import_token_202233 = require("@solana-program/token-2022");
+var import_assert23 = __toESM(require("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 (0, import_token_202232.fetchAllMaybeMint)(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  (0, import_assert22.default)(mintA.exists, "Token A not found");
-  (0, import_assert22.default)(mintB.exists, "Token B not found");
+  const [mintA, mintB] = await (0, import_token_202233.fetchAllMaybeMint)(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  (0, import_assert23.default)(mintA.exists, "Token A not found");
+  (0, import_assert23.default)(mintB.exists, "Token B not found");
   const marketAddress = (await getMarketAddress(tunaPosition.data.pool))[0];
   const createUserAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -12882,34 +13299,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 (0, import_token_202232.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaA = (await (0, import_token_202233.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await (0, import_token_202232.findAssociatedTokenPda)({
+  const tunaPositionOwnerAtaB = (await (0, import_token_202233.findAssociatedTokenPda)({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202232.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202233.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202232.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202233.findAssociatedTokenPda)({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const vaultAAddress = (await getLendingVaultAddress(mintA.address))[0];
-  const vaultAAta = (await (0, import_token_202232.findAssociatedTokenPda)({
+  const vaultAAta = (await (0, import_token_202233.findAssociatedTokenPda)({
     owner: vaultAAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
   const vaultBAddress = (await getLendingVaultAddress(mintB.address))[0];
-  const vaultBAta = (await (0, import_token_202232.findAssociatedTokenPda)({
+  const vaultBAta = (await (0, import_token_202233.findAssociatedTokenPda)({
     owner: vaultBAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12917,7 +13334,7 @@ async function repayTunaLpPositionDebtInstruction(authority, positionMint, mintA
   return getRepayTunaLpPositionDebtInstruction({
     authority,
     market: marketAddress,
-    memoProgram: import_memo21.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo22.MEMO_PROGRAM_ADDRESS,
     mintA: mintA.address,
     mintB: mintB.address,
     tokenProgramA: mintA.programAddress,
@@ -12937,39 +13354,39 @@ async function repayTunaLpPositionDebtInstruction(authority, positionMint, mintA
 }
 
 // src/txbuilder/rebalanceTunaLpPositionOrca.ts
-var import_whirlpools_client15 = require("@orca-so/whirlpools-client");
-var import_kit92 = require("@solana/kit");
+var import_whirlpools_client16 = require("@orca-so/whirlpools-client");
+var import_kit126 = require("@solana/kit");
 var import_sysvars3 = require("@solana/sysvars");
-var import_memo22 = require("@solana-program/memo");
-var import_token_202233 = require("@solana-program/token-2022");
-var import_assert23 = __toESM(require("assert"));
+var import_memo23 = require("@solana-program/memo");
+var import_token_202234 = require("@solana-program/token-2022");
+var import_assert24 = __toESM(require("assert"));
 async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await (0, import_sysvars3.fetchSysvarRent)(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 (0, import_whirlpools_client15.fetchMaybeWhirlpool)(rpc, tunaPosition.data.pool);
+  const whirlpool = await (0, import_whirlpools_client16.fetchMaybeWhirlpool)(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 (0, import_token_202233.fetchAllMaybeMint)(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  (0, import_assert23.default)(mintA.exists, "Token A account not found");
-  (0, import_assert23.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202234.fetchAllMaybeMint)(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  (0, import_assert24.default)(mintA.exists, "Token A account not found");
+  (0, import_assert24.default)(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
   const internalCleanupInstructions = [];
   const secondaryTickArrays = await OrcaUtils.getTickArraysForRebalancedPosition(whirlpool, tunaPosition);
-  const [lowerTickArray, upperTickArray] = await (0, import_whirlpools_client15.fetchAllMaybeTickArray)(rpc, [
+  const [lowerTickArray, upperTickArray] = await (0, import_whirlpools_client16.fetchAllMaybeTickArray)(rpc, [
     secondaryTickArrays.lowerTickArrayAddress,
     secondaryTickArrays.upperTickArrayAddress
   ]);
   if (!lowerTickArray.exists) {
     instructions.push(
-      (0, import_whirlpools_client15.getInitializeDynamicTickArrayInstruction)({
+      (0, import_whirlpools_client16.getInitializeDynamicTickArrayInstruction)({
         whirlpool: whirlpool.address,
         funder: authority,
         tickArray: secondaryTickArrays.lowerTickArrayAddress,
@@ -12977,11 +13394,11 @@ async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionM
         idempotent: false
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client15.getDynamicTickArrayMinSize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client16.getDynamicTickArrayMinSize)());
   }
   if (!upperTickArray.exists && secondaryTickArrays.lowerTickArrayStartIndex !== secondaryTickArrays.upperTickArrayStartIndex) {
     instructions.push(
-      (0, import_whirlpools_client15.getInitializeDynamicTickArrayInstruction)({
+      (0, import_whirlpools_client16.getInitializeDynamicTickArrayInstruction)({
         whirlpool: whirlpool.address,
         funder: authority,
         tickArray: secondaryTickArrays.upperTickArrayAddress,
@@ -12989,7 +13406,7 @@ async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionM
         idempotent: false
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client15.getDynamicTickArrayMinSize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_whirlpools_client16.getDynamicTickArrayMinSize)());
   }
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -13021,35 +13438,35 @@ async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionM
   cleanupInstructions.push(...internalCleanupInstructions);
   return {
     instructions,
-    initializationCost: (0, import_kit92.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit126.lamports)(nonRefundableRent)
   };
 }
 async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool) {
   const positionMint = tunaPosition.data.positionMint;
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
-  const orcaPositionAddress = (await (0, import_whirlpools_client15.getPositionAddress)(positionMint))[0];
-  const orcaOracleAddress = (await (0, import_whirlpools_client15.getOracleAddress)(whirlpool.address))[0];
-  const tunaPositionAta = (await (0, import_token_202233.findAssociatedTokenPda)({
+  const orcaPositionAddress = (await (0, import_whirlpools_client16.getPositionAddress)(positionMint))[0];
+  const orcaOracleAddress = (await (0, import_whirlpools_client16.getOracleAddress)(whirlpool.address))[0];
+  const tunaPositionAta = (await (0, import_token_202234.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: positionMint,
-    tokenProgram: import_token_202233.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202234.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202233.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202234.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202233.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202234.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202233.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202234.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202233.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202234.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -13065,18 +13482,18 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
   );
   const secondaryTickArrays = await OrcaUtils.getTickArraysForRebalancedPosition(whirlpool, tunaPosition);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit92.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit92.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit92.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit92.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit92.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit92.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit92.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit92.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit92.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit92.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit92.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit92.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit126.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit126.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit126.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit126.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit126.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit126.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit126.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit126.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit126.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit126.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit126.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit126.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -13108,10 +13525,10 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
     feeRecipientAtaA,
     feeRecipientAtaB,
     whirlpool: whirlpool.address,
-    whirlpoolProgram: import_whirlpools_client15.WHIRLPOOL_PROGRAM_ADDRESS,
+    whirlpoolProgram: import_whirlpools_client16.WHIRLPOOL_PROGRAM_ADDRESS,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo22.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo23.MEMO_PROGRAM_ADDRESS,
     remainingAccountsInfo
   });
   ix.accounts.push(...remainingAccounts);
@@ -13119,56 +13536,56 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
 }
 
 // src/txbuilder/rebalanceTunaLpPositionFusion.ts
-var import_fusionamm_client16 = require("@crypticdot/fusionamm-client");
-var import_kit93 = require("@solana/kit");
+var import_fusionamm_client17 = require("@crypticdot/fusionamm-client");
+var import_kit127 = require("@solana/kit");
 var import_sysvars4 = require("@solana/sysvars");
-var import_memo23 = require("@solana-program/memo");
-var import_token_202234 = require("@solana-program/token-2022");
-var import_assert24 = __toESM(require("assert"));
+var import_memo24 = require("@solana-program/memo");
+var import_token_202235 = require("@solana-program/token-2022");
+var import_assert25 = __toESM(require("assert"));
 async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await (0, import_sysvars4.fetchSysvarRent)(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 (0, import_fusionamm_client16.fetchMaybeFusionPool)(rpc, tunaPosition.data.pool);
+  const fusionPool = await (0, import_fusionamm_client17.fetchMaybeFusionPool)(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 (0, import_token_202234.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  (0, import_assert24.default)(mintA.exists, "Token A account not found");
-  (0, import_assert24.default)(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await (0, import_token_202235.fetchAllMaybeMint)(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  (0, import_assert25.default)(mintA.exists, "Token A account not found");
+  (0, import_assert25.default)(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
   const secondaryTickArrays = await FusionUtils.getTickArraysForRebalancedPosition(fusionPool, tunaPosition);
-  const [lowerTickArray, upperTickArray] = await (0, import_fusionamm_client16.fetchAllMaybeTickArray)(rpc, [
+  const [lowerTickArray, upperTickArray] = await (0, import_fusionamm_client17.fetchAllMaybeTickArray)(rpc, [
     secondaryTickArrays.lowerTickArrayAddress,
     secondaryTickArrays.upperTickArrayAddress
   ]);
   if (!lowerTickArray.exists) {
     instructions.push(
-      (0, import_fusionamm_client16.getInitializeTickArrayInstruction)({
+      (0, import_fusionamm_client17.getInitializeTickArrayInstruction)({
         fusionPool: fusionPool.address,
         funder: authority,
         tickArray: secondaryTickArrays.lowerTickArrayAddress,
         startTickIndex: secondaryTickArrays.lowerTickArrayStartIndex
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client16.getTickArraySize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client17.getTickArraySize)());
   }
   if (!upperTickArray.exists && secondaryTickArrays.lowerTickArrayStartIndex !== secondaryTickArrays.upperTickArrayStartIndex) {
     instructions.push(
-      (0, import_fusionamm_client16.getInitializeTickArrayInstruction)({
+      (0, import_fusionamm_client17.getInitializeTickArrayInstruction)({
         fusionPool: fusionPool.address,
         funder: authority,
         tickArray: secondaryTickArrays.upperTickArrayAddress,
         startTickIndex: secondaryTickArrays.upperTickArrayStartIndex
       })
     );
-    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client16.getTickArraySize)());
+    nonRefundableRent += calculateMinimumBalanceForRentExemption(rent, (0, import_fusionamm_client17.getTickArraySize)());
   }
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -13199,34 +13616,34 @@ async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positio
   instructions.push(ix);
   return {
     instructions,
-    initializationCost: (0, import_kit93.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit127.lamports)(nonRefundableRent)
   };
 }
 async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool) {
   const positionMint = tunaPosition.data.positionMint;
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
-  const fusionPositionAddress = (await (0, import_fusionamm_client16.getPositionAddress)(positionMint))[0];
-  const tunaPositionAta = (await (0, import_token_202234.findAssociatedTokenPda)({
+  const fusionPositionAddress = (await (0, import_fusionamm_client17.getPositionAddress)(positionMint))[0];
+  const tunaPositionAta = (await (0, import_token_202235.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: positionMint,
-    tokenProgram: import_token_202234.TOKEN_2022_PROGRAM_ADDRESS
+    tokenProgram: import_token_202235.TOKEN_2022_PROGRAM_ADDRESS
   }))[0];
-  const tunaPositionAtaA = (await (0, import_token_202234.findAssociatedTokenPda)({
+  const tunaPositionAtaA = (await (0, import_token_202235.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await (0, import_token_202234.findAssociatedTokenPda)({
+  const tunaPositionAtaB = (await (0, import_token_202235.findAssociatedTokenPda)({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await (0, import_token_202234.findAssociatedTokenPda)({
+  const feeRecipientAtaA = (await (0, import_token_202235.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await (0, import_token_202234.findAssociatedTokenPda)({
+  const feeRecipientAtaB = (await (0, import_token_202235.findAssociatedTokenPda)({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -13242,17 +13659,17 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
   );
   const secondaryTickArrays = await FusionUtils.getTickArraysForRebalancedPosition(fusionPool, tunaPosition);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit93.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit93.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit93.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit93.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit93.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit93.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit93.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit93.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit93.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit93.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit93.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit127.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit127.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit127.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit127.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit127.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit127.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit127.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit127.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit127.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit127.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit127.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -13283,10 +13700,10 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
     feeRecipientAtaA,
     feeRecipientAtaB,
     fusionPool: fusionPool.address,
-    fusionammProgram: import_fusionamm_client16.FUSIONAMM_PROGRAM_ADDRESS,
+    fusionammProgram: import_fusionamm_client17.FUSIONAMM_PROGRAM_ADDRESS,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: import_memo23.MEMO_PROGRAM_ADDRESS,
+    memoProgram: import_memo24.MEMO_PROGRAM_ADDRESS,
     remainingAccountsInfo
   });
   ix.accounts.push(...remainingAccounts);
@@ -13838,6 +14255,8 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
   liquidateTunaSpotPositionOrcaInstructions,
   modifyTunaSpotPositionFusionInstruction,
   modifyTunaSpotPositionFusionInstructions,
+  modifyTunaSpotPositionJupiterInstruction,
+  modifyTunaSpotPositionJupiterInstructions,
   modifyTunaSpotPositionOrcaInstruction,
   modifyTunaSpotPositionOrcaInstructions,
   mulDiv,