@crypticdot/defituna-client 3.3.0 → 3.3.2

package/dist/index.mjs

@@ -4915,10 +4915,9 @@ function getModifyTunaSpotPositionFusionInstructionDataEncoder() {
     getStructEncoder29([
       ["discriminator", fixEncoderSize28(getBytesEncoder28(), 8)],
       ["decreasePercent", getU32Encoder14()],
-      ["decreaseAcceptableSwapAmount", getU64Encoder13()],
       ["collateralAmount", getU64Encoder13()],
       ["borrowAmount", getU64Encoder13()],
-      ["increaseMinSwapAmountOut", getU64Encoder13()],
+      ["requiredSwapAmount", getU64Encoder13()],
       ["remainingAccountsInfo", getRemainingAccountsInfoEncoder()]
     ]),
     (value) => ({
@@ -4931,10 +4930,9 @@ function getModifyTunaSpotPositionFusionInstructionDataDecoder() {
   return getStructDecoder29([
     ["discriminator", fixDecoderSize27(getBytesDecoder27(), 8)],
     ["decreasePercent", getU32Decoder14()],
-    ["decreaseAcceptableSwapAmount", getU64Decoder13()],
     ["collateralAmount", getU64Decoder13()],
     ["borrowAmount", getU64Decoder13()],
-    ["increaseMinSwapAmountOut", getU64Decoder13()],
+    ["requiredSwapAmount", getU64Decoder13()],
     ["remainingAccountsInfo", getRemainingAccountsInfoDecoder()]
   ]);
 }
@@ -5338,10 +5336,9 @@ function getModifyTunaSpotPositionOrcaInstructionDataEncoder() {
     getStructEncoder31([
       ["discriminator", fixEncoderSize30(getBytesEncoder30(), 8)],
       ["decreasePercent", getU32Encoder16()],
-      ["decreaseAcceptableSwapAmount", getU64Encoder15()],
       ["collateralAmount", getU64Encoder15()],
       ["borrowAmount", getU64Encoder15()],
-      ["increaseMinSwapAmountOut", getU64Encoder15()],
+      ["requiredSwapAmount", getU64Encoder15()],
       ["remainingAccountsInfo", getRemainingAccountsInfoEncoder()]
     ]),
     (value) => ({
@@ -5354,10 +5351,9 @@ function getModifyTunaSpotPositionOrcaInstructionDataDecoder() {
   return getStructDecoder31([
     ["discriminator", fixDecoderSize29(getBytesDecoder29(), 8)],
     ["decreasePercent", getU32Decoder16()],
-    ["decreaseAcceptableSwapAmount", getU64Decoder15()],
     ["collateralAmount", getU64Decoder15()],
     ["borrowAmount", getU64Decoder15()],
-    ["increaseMinSwapAmountOut", getU64Decoder15()],
+    ["requiredSwapAmount", getU64Decoder15()],
     ["remainingAccountsInfo", getRemainingAccountsInfoDecoder()]
   ]);
 }
@@ -10834,23 +10830,29 @@ async function modifyTunaSpotPositionOrcaInstructions(rpc, authority, poolAddres
     (await getLendingVaultAddress(pool.data.tokenMintA))[0],
     (await getLendingVaultAddress(pool.data.tokenMintB))[0]
   ]);
-  const tunaPositionAtaAAddress = (await findAssociatedTokenPda13({
-    owner: tunaPositionAddress,
-    mint: mintA.address,
-    tokenProgram: mintA.programAddress
-  }))[0];
-  const tunaPositionAtaBAddress = (await findAssociatedTokenPda13({
-    owner: tunaPositionAddress,
-    mint: mintB.address,
-    tokenProgram: mintB.programAddress
-  }))[0];
-  const [tunaPositionAtaA, tunaPositionAtaB] = await 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 findAssociatedTokenPda13({
+      owner: tunaPositionAddress,
+      mint: mintA.address,
+      tokenProgram: mintA.programAddress
+    }))[0];
+    const tunaPositionAtaBAddress = (await findAssociatedTokenPda13({
+      owner: tunaPositionAddress,
+      mint: mintB.address,
+      tokenProgram: mintB.programAddress
+    }))[0];
+    const [tunaPositionAtaA, tunaPositionAtaB] = await 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,
@@ -11007,23 +11009,29 @@ async function modifyTunaSpotPositionFusionInstructions(rpc, authority, poolAddr
     (await getLendingVaultAddress(pool.data.tokenMintA))[0],
     (await getLendingVaultAddress(pool.data.tokenMintB))[0]
   ]);
-  const tunaPositionAtaAAddress = (await findAssociatedTokenPda14({
-    owner: tunaPosition.address,
-    mint: mintA.address,
-    tokenProgram: mintA.programAddress
-  }))[0];
-  const tunaPositionAtaBAddress = (await findAssociatedTokenPda14({
-    owner: tunaPosition.address,
-    mint: mintB.address,
-    tokenProgram: mintB.programAddress
-  }))[0];
-  const [tunaPositionAtaA, tunaPositionAtaB] = await fetchAllToken2(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 findAssociatedTokenPda14({
+      owner: tunaPositionAddress,
+      mint: mintA.address,
+      tokenProgram: mintA.programAddress
+    }))[0];
+    const tunaPositionAtaBAddress = (await findAssociatedTokenPda14({
+      owner: tunaPositionAddress,
+      mint: mintB.address,
+      tokenProgram: mintB.programAddress
+    }))[0];
+    const [tunaPositionAtaA, tunaPositionAtaB] = await fetchAllToken2(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,
@@ -11149,27 +11157,803 @@ async function modifyTunaSpotPositionFusionInstruction(authority, tunaConfig, mi
   return ix;
 }
 
-// src/txbuilder/closeTunaSpotPosition.ts
+// src/txbuilder/modifyTunaSpotPositionJupiter.ts
+import { fetchFusionPool as fetchFusionPool2 } from "@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
+import {
+  assertAccountExists as assertAccountExists7,
+  assertAccountsExist as assertAccountsExist8,
+  combineCodec as combineCodec62,
+  decodeAccount as decodeAccount7,
+  fetchEncodedAccount as fetchEncodedAccount7,
+  fetchEncodedAccounts as fetchEncodedAccounts7,
+  fixDecoderSize as fixDecoderSize56,
+  fixEncoderSize as fixEncoderSize57,
+  getAddressDecoder as getAddressDecoder16,
+  getAddressEncoder as getAddressEncoder20,
+  getBytesDecoder as getBytesDecoder56,
+  getBytesEncoder as getBytesEncoder57,
+  getStructDecoder as getStructDecoder58,
+  getStructEncoder as getStructEncoder58,
+  getU64Decoder as getU64Decoder23,
+  getU64Encoder as getU64Encoder23,
+  transformEncoder as transformEncoder56
+} from "@solana/kit";
+import {
+  isProgramError as isProgramError2
+} from "@solana/kit";
+import {
+  containsBytes as containsBytes2,
+  fixEncoderSize as fixEncoderSize210,
+  getBytesEncoder as getBytesEncoder210
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec210,
+  fixDecoderSize as fixDecoderSize210,
+  fixEncoderSize as fixEncoderSize310,
+  getBytesDecoder as getBytesDecoder210,
+  getBytesEncoder as getBytesEncoder310,
+  getStructDecoder as getStructDecoder210,
+  getStructEncoder as getStructEncoder210,
+  getU8Decoder as getU8Decoder6,
+  getU8Encoder as getU8Encoder6,
+  transformEncoder as transformEncoder210
+} from "@solana/kit";
+import {
+  AccountRole as AccountRole10,
+  isProgramDerivedAddress as isProgramDerivedAddress2,
+  isTransactionSigner as kitIsTransactionSigner2,
+  upgradeRoleToSigner as upgradeRoleToSigner2
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec310,
+  fixDecoderSize as fixDecoderSize310,
+  fixEncoderSize as fixEncoderSize410,
+  getAddressEncoder as getAddressEncoder22,
+  getBytesDecoder as getBytesDecoder310,
+  getBytesEncoder as getBytesEncoder410,
+  getProgramDerivedAddress as getProgramDerivedAddress2,
+  getStructDecoder as getStructDecoder310,
+  getStructEncoder as getStructEncoder310,
+  getU8Decoder as getU8Decoder22,
+  getU8Encoder as getU8Encoder22,
+  transformEncoder as transformEncoder310
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec410,
+  fixDecoderSize as fixDecoderSize410,
+  fixEncoderSize as fixEncoderSize58,
+  getBooleanDecoder as getBooleanDecoder9,
+  getBooleanEncoder as getBooleanEncoder9,
+  getBytesDecoder as getBytesDecoder410,
+  getBytesEncoder as getBytesEncoder58,
+  getStructDecoder as getStructDecoder410,
+  getStructEncoder as getStructEncoder410,
+  getU8Decoder as getU8Decoder32,
+  getU8Encoder as getU8Encoder32,
+  transformEncoder as transformEncoder410
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec510,
+  fixDecoderSize as fixDecoderSize57,
+  fixEncoderSize as fixEncoderSize62,
+  getAddressEncoder as getAddressEncoder32,
+  getBytesDecoder as getBytesDecoder57,
+  getBytesEncoder as getBytesEncoder62,
+  getProgramDerivedAddress as getProgramDerivedAddress22,
+  getStructDecoder as getStructDecoder59,
+  getStructEncoder as getStructEncoder59,
+  transformEncoder as transformEncoder57
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec63,
+  fixDecoderSize as fixDecoderSize62,
+  fixEncoderSize as fixEncoderSize72,
+  getAddressEncoder as getAddressEncoder42,
+  getBytesDecoder as getBytesDecoder62,
+  getBytesEncoder as getBytesEncoder72,
+  getProgramDerivedAddress as getProgramDerivedAddress3,
+  getStructDecoder as getStructDecoder62,
+  getStructEncoder as getStructEncoder62,
+  getU8Decoder as getU8Decoder42,
+  getU8Encoder as getU8Encoder42,
+  transformEncoder as transformEncoder62
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec72,
+  fixDecoderSize as fixDecoderSize72,
+  fixEncoderSize as fixEncoderSize82,
+  getBytesDecoder as getBytesDecoder72,
+  getBytesEncoder as getBytesEncoder82,
+  getStructDecoder as getStructDecoder72,
+  getStructEncoder as getStructEncoder72,
+  getU8Decoder as getU8Decoder52,
+  getU8Encoder as getU8Encoder52,
+  transformEncoder as transformEncoder72
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec82,
+  fixDecoderSize as fixDecoderSize82,
+  fixEncoderSize as fixEncoderSize92,
+  getBytesDecoder as getBytesDecoder82,
+  getBytesEncoder as getBytesEncoder92,
+  getStructDecoder as getStructDecoder82,
+  getStructEncoder as getStructEncoder82,
+  transformEncoder as transformEncoder82
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec212,
+  fixDecoderSize as fixDecoderSize92,
+  fixEncoderSize as fixEncoderSize102,
+  getArrayDecoder as getArrayDecoder3,
+  getArrayEncoder as getArrayEncoder3,
+  getBytesDecoder as getBytesDecoder92,
+  getBytesEncoder as getBytesEncoder102,
+  getStructDecoder as getStructDecoder182,
+  getStructEncoder as getStructEncoder182,
+  getU16Decoder as getU16Decoder22,
+  getU16Encoder as getU16Encoder22,
+  getU64Decoder as getU64Decoder52,
+  getU64Encoder as getU64Encoder52,
+  getU8Decoder as getU8Decoder11,
+  getU8Encoder as getU8Encoder11,
+  transformEncoder as transformEncoder92
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec92,
+  getEnumDecoder as getEnumDecoder5,
+  getEnumEncoder as getEnumEncoder5
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec102,
+  getEnumDecoder as getEnumDecoder22,
+  getEnumEncoder as getEnumEncoder22
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec112,
+  getArrayDecoder as getArrayDecoder2,
+  getArrayEncoder as getArrayEncoder2,
+  getStructDecoder as getStructDecoder92,
+  getStructEncoder as getStructEncoder92
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec122,
+  getStructDecoder as getStructDecoder102,
+  getStructEncoder as getStructEncoder102,
+  getU8Decoder as getU8Decoder62,
+  getU8Encoder as getU8Encoder62
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec132,
+  getAddressDecoder as getAddressDecoder22,
+  getAddressEncoder as getAddressEncoder52,
+  getStructDecoder as getStructDecoder112,
+  getStructEncoder as getStructEncoder112,
+  getU64Decoder as getU64Decoder24,
+  getU64Encoder as getU64Encoder24
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec142,
+  getArrayDecoder as getArrayDecoder22,
+  getArrayEncoder as getArrayEncoder22,
+  getStructDecoder as getStructDecoder122,
+  getStructEncoder as getStructEncoder122
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec152,
+  getStructDecoder as getStructDecoder132,
+  getStructEncoder as getStructEncoder132,
+  getU8Decoder as getU8Decoder7,
+  getU8Encoder as getU8Encoder7
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec162,
+  getStructDecoder as getStructDecoder142,
+  getStructEncoder as getStructEncoder142,
+  getU8Decoder as getU8Decoder8,
+  getU8Encoder as getU8Encoder8
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec172,
+  getStructDecoder as getStructDecoder152,
+  getStructEncoder as getStructEncoder152,
+  getU16Decoder as getU16Decoder9,
+  getU16Encoder as getU16Encoder9,
+  getU8Decoder as getU8Decoder9,
+  getU8Encoder as getU8Encoder9
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec182,
+  getEnumDecoder as getEnumDecoder32,
+  getEnumEncoder as getEnumEncoder32
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec192,
+  getBooleanDecoder as getBooleanDecoder22,
+  getBooleanEncoder as getBooleanEncoder22,
+  getDiscriminatedUnionDecoder,
+  getDiscriminatedUnionEncoder,
+  getOptionDecoder as getOptionDecoder3,
+  getOptionEncoder as getOptionEncoder3,
+  getStructDecoder as getStructDecoder162,
+  getStructEncoder as getStructEncoder162,
+  getU32Decoder as getU32Decoder27,
+  getU32Encoder as getU32Encoder27,
+  getU64Decoder as getU64Decoder32,
+  getU64Encoder as getU64Encoder32,
+  getU8Decoder as getU8Decoder10,
+  getU8Encoder as getU8Encoder10,
+  getUnitDecoder,
+  getUnitEncoder
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec202,
+  getAddressDecoder as getAddressDecoder32,
+  getAddressEncoder as getAddressEncoder62,
+  getStructDecoder as getStructDecoder172,
+  getStructEncoder as getStructEncoder172,
+  getU64Decoder as getU64Decoder42,
+  getU64Encoder as getU64Encoder42
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec222,
+  fixDecoderSize as fixDecoderSize102,
+  fixEncoderSize as fixEncoderSize112,
+  getArrayDecoder as getArrayDecoder4,
+  getArrayEncoder as getArrayEncoder4,
+  getBytesDecoder as getBytesDecoder102,
+  getBytesEncoder as getBytesEncoder112,
+  getStructDecoder as getStructDecoder192,
+  getStructEncoder as getStructEncoder192,
+  getU16Decoder as getU16Decoder32,
+  getU16Encoder as getU16Encoder32,
+  getU64Decoder as getU64Decoder62,
+  getU64Encoder as getU64Encoder62,
+  transformEncoder as transformEncoder102
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec232,
+  fixDecoderSize as fixDecoderSize112,
+  fixEncoderSize as fixEncoderSize122,
+  getArrayDecoder as getArrayDecoder5,
+  getArrayEncoder as getArrayEncoder5,
+  getBytesDecoder as getBytesDecoder112,
+  getBytesEncoder as getBytesEncoder122,
+  getStructDecoder as getStructDecoder202,
+  getStructEncoder as getStructEncoder202,
+  getU16Decoder as getU16Decoder42,
+  getU16Encoder as getU16Encoder42,
+  getU64Decoder as getU64Decoder72,
+  getU64Encoder as getU64Encoder72,
+  getU8Decoder as getU8Decoder12,
+  getU8Encoder as getU8Encoder12,
+  transformEncoder as transformEncoder112
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec242,
+  fixDecoderSize as fixDecoderSize122,
+  fixEncoderSize as fixEncoderSize132,
+  getArrayDecoder as getArrayDecoder6,
+  getArrayEncoder as getArrayEncoder6,
+  getBytesDecoder as getBytesDecoder122,
+  getBytesEncoder as getBytesEncoder132,
+  getStructDecoder as getStructDecoder212,
+  getStructEncoder as getStructEncoder212,
+  getU16Decoder as getU16Decoder52,
+  getU16Encoder as getU16Encoder52,
+  getU64Decoder as getU64Decoder82,
+  getU64Encoder as getU64Encoder82,
+  transformEncoder as transformEncoder122
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec252,
+  fixDecoderSize as fixDecoderSize132,
+  fixEncoderSize as fixEncoderSize142,
+  getArrayDecoder as getArrayDecoder7,
+  getArrayEncoder as getArrayEncoder7,
+  getBytesDecoder as getBytesDecoder132,
+  getBytesEncoder as getBytesEncoder142,
+  getStructDecoder as getStructDecoder222,
+  getStructEncoder as getStructEncoder222,
+  getU16Decoder as getU16Decoder62,
+  getU16Encoder as getU16Encoder62,
+  getU64Decoder as getU64Decoder92,
+  getU64Encoder as getU64Encoder92,
+  getU8Decoder as getU8Decoder13,
+  getU8Encoder as getU8Encoder13,
+  transformEncoder as transformEncoder132
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec262,
+  fixDecoderSize as fixDecoderSize142,
+  fixEncoderSize as fixEncoderSize152,
+  getBytesDecoder as getBytesDecoder142,
+  getBytesEncoder as getBytesEncoder152,
+  getStructDecoder as getStructDecoder232,
+  getStructEncoder as getStructEncoder232,
+  transformEncoder as transformEncoder142
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec272,
+  fixDecoderSize as fixDecoderSize152,
+  fixEncoderSize as fixEncoderSize162,
+  getArrayDecoder as getArrayDecoder8,
+  getArrayEncoder as getArrayEncoder8,
+  getBytesDecoder as getBytesDecoder152,
+  getBytesEncoder as getBytesEncoder162,
+  getStructDecoder as getStructDecoder242,
+  getStructEncoder as getStructEncoder242,
+  getU16Decoder as getU16Decoder72,
+  getU16Encoder as getU16Encoder72,
+  getU64Decoder as getU64Decoder102,
+  getU64Encoder as getU64Encoder102,
+  getU8Decoder as getU8Decoder14,
+  getU8Encoder as getU8Encoder14,
+  transformEncoder as transformEncoder152
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec282,
+  fixDecoderSize as fixDecoderSize162,
+  fixEncoderSize as fixEncoderSize172,
+  getArrayDecoder as getArrayDecoder9,
+  getArrayEncoder as getArrayEncoder9,
+  getBytesDecoder as getBytesDecoder162,
+  getBytesEncoder as getBytesEncoder172,
+  getStructDecoder as getStructDecoder252,
+  getStructEncoder as getStructEncoder252,
+  getU16Decoder as getU16Decoder82,
+  getU16Encoder as getU16Encoder82,
+  getU64Decoder as getU64Decoder112,
+  getU64Encoder as getU64Encoder112,
+  getU8Decoder as getU8Decoder15,
+  getU8Encoder as getU8Encoder15,
+  transformEncoder as transformEncoder162
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec292,
+  fixDecoderSize as fixDecoderSize172,
+  fixEncoderSize as fixEncoderSize182,
+  getArrayDecoder as getArrayDecoder10,
+  getArrayEncoder as getArrayEncoder10,
+  getBytesDecoder as getBytesDecoder172,
+  getBytesEncoder as getBytesEncoder182,
+  getStructDecoder as getStructDecoder262,
+  getStructEncoder as getStructEncoder262,
+  getU16Decoder as getU16Decoder92,
+  getU16Encoder as getU16Encoder92,
+  getU64Decoder as getU64Decoder122,
+  getU64Encoder as getU64Encoder122,
+  getU8Decoder as getU8Decoder16,
+  getU8Encoder as getU8Encoder16,
+  transformEncoder as transformEncoder172
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec302,
+  fixDecoderSize as fixDecoderSize182,
+  fixEncoderSize as fixEncoderSize192,
+  getArrayDecoder as getArrayDecoder11,
+  getArrayEncoder as getArrayEncoder11,
+  getBytesDecoder as getBytesDecoder182,
+  getBytesEncoder as getBytesEncoder192,
+  getStructDecoder as getStructDecoder272,
+  getStructEncoder as getStructEncoder272,
+  getU16Decoder as getU16Decoder10,
+  getU16Encoder as getU16Encoder10,
+  getU64Decoder as getU64Decoder132,
+  getU64Encoder as getU64Encoder132,
+  getU8Decoder as getU8Decoder17,
+  getU8Encoder as getU8Encoder17,
+  transformEncoder as transformEncoder182
+} from "@solana/kit";
+import {
+  combineCodec as combineCodec312,
+  fixDecoderSize as fixDecoderSize192,
+  fixEncoderSize as fixEncoderSize202,
+  getArrayDecoder as getArrayDecoder12,
+  getArrayEncoder as getArrayEncoder12,
+  getBytesDecoder as getBytesDecoder192,
+  getBytesEncoder as getBytesEncoder202,
+  getStructDecoder as getStructDecoder282,
+  getStructEncoder as getStructEncoder282,
+  getU16Decoder as getU16Decoder11,
+  getU16Encoder as getU16Encoder11,
+  getU64Decoder as getU64Decoder142,
+  getU64Encoder as getU64Encoder142,
+  getU8Decoder as getU8Decoder18,
+  getU8Encoder as getU8Encoder18,
+  transformEncoder as transformEncoder192
+} from "@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
+import { fetchWhirlpool as fetchWhirlpool2 } from "@orca-so/whirlpools-client";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS10 } from "@solana-program/memo";
 import { fetchAllMaybeMint as fetchAllMaybeMint13, findAssociatedTokenPda as findAssociatedTokenPda15 } from "@solana-program/token-2022";
 import assert13 from "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 fetchFusionPool2(rpc, poolAddress) : await fetchWhirlpool2(rpc, poolAddress);
+  const [mintA, mintB] = await fetchAllMaybeMint13(rpc, [pool.data.tokenMintA, pool.data.tokenMintB]);
+  assert13(mintA.exists, "Token A account not found");
+  assert13(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 findAssociatedTokenPda15({
+    owner: authority.address,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda15({
+    owner: authority.address,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  const feeRecipientAtaA = (await findAssociatedTokenPda15({
+    owner: tunaConfig.data.feeRecipient,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const feeRecipientAtaB = (await findAssociatedTokenPda15({
+    owner: tunaConfig.data.feeRecipient,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  const tunaPositionAtaA = (await findAssociatedTokenPda15({
+    owner: tunaPositionAddress,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const tunaPositionAtaB = (await findAssociatedTokenPda15({
+    owner: tunaPositionAddress,
+    mint: mintB.address,
+    tokenProgram: mintB.programAddress
+  }))[0];
+  const vaultAAta = (await findAssociatedTokenPda15({
+    owner: vaultA.address,
+    mint: mintA.address,
+    tokenProgram: mintA.programAddress
+  }))[0];
+  const vaultBAta = (await findAssociatedTokenPda15({
+    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: MEMO_PROGRAM_ADDRESS10,
+    ...args
+  });
+  ix.accounts.push(...remainingAccounts);
+  return ix;
+}
+
+// src/txbuilder/closeTunaSpotPosition.ts
+import { fetchAllMaybeMint as fetchAllMaybeMint14, findAssociatedTokenPda as findAssociatedTokenPda16 } from "@solana-program/token-2022";
+import assert14 from "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 fetchAllMaybeMint13(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  assert13(mintA.exists, "Token A account not found");
-  assert13(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint14(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  assert14(mintA.exists, "Token A account not found");
+  assert14(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 findAssociatedTokenPda15({
+  const tunaPositionAtaA = (await findAssociatedTokenPda16({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda15({
+  const tunaPositionAtaB = (await findAssociatedTokenPda16({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11213,11 +11997,11 @@ async function createTunaConfigInstruction(authority, ownerAuthority, adminAutho
 }
 
 // src/txbuilder/createVault.ts
-import { findAssociatedTokenPda as findAssociatedTokenPda16 } from "@solana-program/token-2022";
+import { findAssociatedTokenPda as findAssociatedTokenPda17 } from "@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 findAssociatedTokenPda16({
+  const vaultAta = (await findAssociatedTokenPda17({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -11238,9 +12022,9 @@ async function createVaultInstructions(authority, mint, args) {
 
 // src/txbuilder/liquidateTunaLpPositionOrca.ts
 import { getOracleAddress as getOracleAddress4, getPositionAddress as getPositionAddress11, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS7 } from "@orca-so/whirlpools-client";
-import { AccountRole as AccountRole10 } from "@solana/kit";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS10 } from "@solana-program/memo";
-import { findAssociatedTokenPda as findAssociatedTokenPda17, TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS11 } from "@solana-program/token-2022";
+import { AccountRole as AccountRole11 } from "@solana/kit";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS11 } from "@solana-program/memo";
+import { findAssociatedTokenPda as findAssociatedTokenPda18, TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS11 } from "@solana-program/token-2022";
 async function liquidateTunaLpPositionOrcaInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, decreasePercent) {
   const instructions = [];
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
@@ -11280,37 +12064,37 @@ async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, t
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
   const orcaPositionAddress = (await getPositionAddress11(positionMint))[0];
   const orcaOracleAddress = (await getOracleAddress4(whirlpool.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda17({
+  const tunaPositionAta = (await findAssociatedTokenPda18({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS11
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda17({
+  const tunaPositionAtaA = (await findAssociatedTokenPda18({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda17({
+  const tunaPositionAtaB = (await findAssociatedTokenPda18({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda17({
+  const vaultAAta = (await findAssociatedTokenPda18({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda17({
+  const vaultBAta = (await findAssociatedTokenPda18({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda17({
+  const feeRecipientAtaA = (await findAssociatedTokenPda18({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda17({
+  const feeRecipientAtaB = (await findAssociatedTokenPda18({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11325,16 +12109,16 @@ async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, t
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole10.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole10.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole10.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole10.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole10.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole10.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole10.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: AccountRole10.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: AccountRole10.WRITABLE },
-    { address: orcaOracleAddress, role: AccountRole10.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole11.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole11.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole11.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole11.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole11.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole11.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole11.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: AccountRole11.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: AccountRole11.WRITABLE },
+    { address: orcaOracleAddress, role: AccountRole11.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11369,7 +12153,7 @@ async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, t
     whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS7,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS10,
+    memoProgram: MEMO_PROGRAM_ADDRESS11,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11379,9 +12163,9 @@ async function liquidateTunaLpPositionOrcaInstruction(authority, tunaPosition, t
 
 // src/txbuilder/liquidateTunaLpPositionFusion.ts
 import { FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS7, getPositionAddress as getPositionAddress12 } from "@crypticdot/fusionamm-client";
-import { AccountRole as AccountRole11 } from "@solana/kit";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS11 } from "@solana-program/memo";
-import { findAssociatedTokenPda as findAssociatedTokenPda18, TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS12 } from "@solana-program/token-2022";
+import { AccountRole as AccountRole12 } from "@solana/kit";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS12 } from "@solana-program/memo";
+import { findAssociatedTokenPda as findAssociatedTokenPda19, TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS12 } from "@solana-program/token-2022";
 async function liquidateTunaLpPositionFusionInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, decreasePercent) {
   const instructions = [];
   const createFeeRecipientAtaAInstructions = await getCreateAtaInstructions(
@@ -11420,37 +12204,37 @@ async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition,
   const positionMint = tunaPosition.data.positionMint;
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
   const fusionPositionAddress = (await getPositionAddress12(positionMint))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda18({
+  const tunaPositionAta = (await findAssociatedTokenPda19({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS12
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda18({
+  const tunaPositionAtaA = (await findAssociatedTokenPda19({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda18({
+  const tunaPositionAtaB = (await findAssociatedTokenPda19({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda18({
+  const vaultAAta = (await findAssociatedTokenPda19({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda18({
+  const vaultBAta = (await findAssociatedTokenPda19({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda18({
+  const feeRecipientAtaA = (await findAssociatedTokenPda19({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda18({
+  const feeRecipientAtaB = (await findAssociatedTokenPda19({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11465,15 +12249,15 @@ async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition,
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole11.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole11.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole11.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole11.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole11.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole11.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole11.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: AccountRole11.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: AccountRole11.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole12.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole12.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole12.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole12.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole12.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole12.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole12.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: AccountRole12.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: AccountRole12.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11507,7 +12291,7 @@ async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition,
     fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS7,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS11,
+    memoProgram: MEMO_PROGRAM_ADDRESS12,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11517,9 +12301,9 @@ async function liquidateTunaLpPositionFusionInstruction(authority, tunaPosition,
 
 // src/txbuilder/liquidateTunaSpotPositionFusion.ts
 import { FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS8 } from "@crypticdot/fusionamm-client";
-import { AccountRole as AccountRole12 } from "@solana/kit";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS12 } from "@solana-program/memo";
-import { findAssociatedTokenPda as findAssociatedTokenPda19 } from "@solana-program/token-2022";
+import { AccountRole as AccountRole13 } from "@solana/kit";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS13 } from "@solana-program/memo";
+import { findAssociatedTokenPda as findAssociatedTokenPda20 } from "@solana-program/token-2022";
 async function liquidateTunaSpotPositionFusionInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool, createTunaPositionOwnerAta, decreasePercent) {
   const instructions = [];
   if (createTunaPositionOwnerAta) {
@@ -11567,55 +12351,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 findAssociatedTokenPda19({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda20({
     owner: tunaPosition.data.authority,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda19({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda20({
     owner: tunaPosition.data.authority,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda19({
+  const tunaPositionAtaA = (await findAssociatedTokenPda20({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda19({
+  const tunaPositionAtaB = (await findAssociatedTokenPda20({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda19({
+  const feeRecipientAtaA = (await findAssociatedTokenPda20({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda19({
+  const feeRecipientAtaB = (await findAssociatedTokenPda20({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda19({
+  const vaultAAta = (await findAssociatedTokenPda20({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda19({
+  const vaultBAta = (await findAssociatedTokenPda20({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const swapTickArrays = await FusionUtils.getSwapTickArrayAddresses(fusionPool);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole12.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole12.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole12.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole12.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole12.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: AccountRole12.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: AccountRole12.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole13.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole13.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole13.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole13.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole13.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: AccountRole13.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: AccountRole13.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11648,7 +12432,7 @@ async function liquidateTunaSpotPositionFusionInstruction(authority, tunaPositio
     feeRecipientAtaB,
     fusionPool: fusionPool.address,
     fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS8,
-    memoProgram: MEMO_PROGRAM_ADDRESS12,
+    memoProgram: MEMO_PROGRAM_ADDRESS13,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11658,9 +12442,9 @@ async function liquidateTunaSpotPositionFusionInstruction(authority, tunaPositio
 
 // src/txbuilder/liquidateTunaSpotPositionOrca.ts
 import { getOracleAddress as getOracleAddress5, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS8 } from "@orca-so/whirlpools-client";
-import { AccountRole as AccountRole13 } from "@solana/kit";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS13 } from "@solana-program/memo";
-import { findAssociatedTokenPda as findAssociatedTokenPda20 } from "@solana-program/token-2022";
+import { AccountRole as AccountRole14 } from "@solana/kit";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS14 } from "@solana-program/memo";
+import { findAssociatedTokenPda as findAssociatedTokenPda21 } from "@solana-program/token-2022";
 async function liquidateTunaSpotPositionOrcaInstructions(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, createTunaPositionOwnerAta, decreasePercent) {
   const instructions = [];
   if (createTunaPositionOwnerAta) {
@@ -11709,56 +12493,56 @@ 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 getOracleAddress5(whirlpool.address))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda20({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda21({
     owner: tunaPosition.data.authority,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda20({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda21({
     owner: tunaPosition.data.authority,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda20({
+  const tunaPositionAtaA = (await findAssociatedTokenPda21({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda20({
+  const tunaPositionAtaB = (await findAssociatedTokenPda21({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda20({
+  const feeRecipientAtaA = (await findAssociatedTokenPda21({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda20({
+  const feeRecipientAtaB = (await findAssociatedTokenPda21({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda20({
+  const vaultAAta = (await findAssociatedTokenPda21({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda20({
+  const vaultBAta = (await findAssociatedTokenPda21({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const swapTickArrays = await OrcaUtils.getSwapTickArrayAddresses(whirlpool);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole13.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole13.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole13.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole13.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole13.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: AccountRole13.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: AccountRole13.WRITABLE },
-    { address: orcaOracleAddress, role: AccountRole13.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole14.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole14.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole14.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole14.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole14.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: AccountRole14.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: AccountRole14.WRITABLE },
+    { address: orcaOracleAddress, role: AccountRole14.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -11792,7 +12576,7 @@ async function liquidateTunaSpotPositionOrcaInstruction(authority, tunaPosition,
     feeRecipientAtaB,
     whirlpool: whirlpool.address,
     whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS8,
-    memoProgram: MEMO_PROGRAM_ADDRESS13,
+    memoProgram: MEMO_PROGRAM_ADDRESS14,
     decreasePercent,
     remainingAccountsInfo
   });
@@ -11804,31 +12588,31 @@ async function liquidateTunaSpotPositionOrcaInstruction(authority, tunaPosition,
 import { fetchMaybeWhirlpool as fetchMaybeWhirlpool6, getPositionAddress as getPositionAddress13, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS9 } from "@orca-so/whirlpools-client";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-  fetchAllMaybeMint as fetchAllMaybeMint14,
-  findAssociatedTokenPda as findAssociatedTokenPda21,
+  fetchAllMaybeMint as fetchAllMaybeMint15,
+  findAssociatedTokenPda as findAssociatedTokenPda22,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS13
 } from "@solana-program/token-2022";
-import assert14 from "assert";
+import assert15 from "assert";
 async function openTunaLpPositionOrcaInstruction(rpc, authority, positionMint, whirlpoolAddress, args) {
   const whirlpool = await fetchMaybeWhirlpool6(rpc, whirlpoolAddress);
   if (!whirlpool.exists) throw new Error("Whirlpool account not found");
-  const [mintA, mintB] = await fetchAllMaybeMint14(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  assert14(mintA.exists, "Token A account not found");
-  assert14(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint15(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  assert15(mintA.exists, "Token A account not found");
+  assert15(mintB.exists, "Token B account not found");
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
   const orcaPositionAddress = (await getPositionAddress13(positionMint.address))[0];
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda21({
+  const tunaPositionAta = (await findAssociatedTokenPda22({
     owner: tunaPositionAddress,
     mint: positionMint.address,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS13
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda21({
+  const tunaPositionAtaA = (await findAssociatedTokenPda22({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda21({
+  const tunaPositionAtaB = (await findAssociatedTokenPda22({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11860,31 +12644,31 @@ import { fetchMaybeFusionPool as fetchMaybeFusionPool6, FUSIONAMM_PROGRAM_ADDRES
 import { FP_NFT_UPDATE_AUTH } from "@crypticdot/fusionamm-client";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS2,
-  fetchAllMaybeMint as fetchAllMaybeMint15,
-  findAssociatedTokenPda as findAssociatedTokenPda22,
+  fetchAllMaybeMint as fetchAllMaybeMint16,
+  findAssociatedTokenPda as findAssociatedTokenPda23,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS14
 } from "@solana-program/token-2022";
-import assert15 from "assert";
+import assert16 from "assert";
 async function openTunaLpPositionFusionInstruction(rpc, authority, positionMint, fusionPoolAddress, args) {
   const fusionPool = await fetchMaybeFusionPool6(rpc, fusionPoolAddress);
-  if (!fusionPool.exists) throw new Error("Whirlpool account not found");
-  const [mintA, mintB] = await fetchAllMaybeMint15(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  assert15(mintA.exists, "Token A account not found");
-  assert15(mintB.exists, "Token B account not found");
+  if (!fusionPool.exists) throw new Error("Whirlpool account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint16(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  assert16(mintA.exists, "Token A account not found");
+  assert16(mintB.exists, "Token B account not found");
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
   const fusionPositionAddress = (await getPositionAddress14(positionMint.address))[0];
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda22({
+  const tunaPositionAta = (await findAssociatedTokenPda23({
     owner: tunaPositionAddress,
     mint: positionMint.address,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS14
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda22({
+  const tunaPositionAtaA = (await findAssociatedTokenPda23({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda22({
+  const tunaPositionAtaB = (await findAssociatedTokenPda23({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -11924,19 +12708,19 @@ import {
 } from "@orca-so/whirlpools-client";
 import { getTickArrayStartTickIndex as getTickArrayStartTickIndex6 } from "@orca-so/whirlpools-core";
 import {
-  AccountRole as AccountRole14,
+  AccountRole as AccountRole15,
   generateKeyPairSigner,
   lamports
 } from "@solana/kit";
 import { fetchSysvarRent } from "@solana/sysvars";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS14 } from "@solana-program/memo";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS15 } from "@solana-program/memo";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS3,
-  fetchAllMaybeMint as fetchAllMaybeMint16,
-  findAssociatedTokenPda as findAssociatedTokenPda23,
+  fetchAllMaybeMint as fetchAllMaybeMint17,
+  findAssociatedTokenPda as findAssociatedTokenPda24,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS15
 } from "@solana-program/token-2022";
-import assert16 from "assert";
+import assert17 from "assert";
 
 // src/utils/sysvar.ts
 var ACCOUNT_STORAGE_OVERHEAD = 128;
@@ -11960,9 +12744,9 @@ async function openAndIncreaseTunaLpPositionOrcaInstructions(rpc, authority, whi
   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 fetchAllMaybeMint16(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  assert16(mintA.exists, "Token A account not found");
-  assert16(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint17(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  assert17(mintA.exists, "Token A account not found");
+  assert17(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]
@@ -12071,47 +12855,47 @@ async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionM
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
   const orcaPositionAddress = (await getPositionAddress15(positionMint.address))[0];
   const orcaOracleAddress = (await getOracleAddress6(whirlpool.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda23({
+  const tunaPositionAta = (await findAssociatedTokenPda24({
     owner: tunaPositionAddress,
     mint: positionMint.address,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS15
   }))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda23({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda24({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda23({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda24({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda23({
+  const tunaPositionAtaA = (await findAssociatedTokenPda24({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda23({
+  const tunaPositionAtaB = (await findAssociatedTokenPda24({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda23({
+  const vaultAAta = (await findAssociatedTokenPda24({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda23({
+  const vaultBAta = (await findAssociatedTokenPda24({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda23({
+  const feeRecipientAtaA = (await findAssociatedTokenPda24({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda23({
+  const feeRecipientAtaB = (await findAssociatedTokenPda24({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12120,16 +12904,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: AccountRole14.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole14.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole14.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole14.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole14.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole14.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole14.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: AccountRole14.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: AccountRole14.WRITABLE },
-    { address: orcaOracleAddress, role: AccountRole14.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole15.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole15.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole15.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole15.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole15.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole15.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole15.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: AccountRole15.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: AccountRole15.WRITABLE },
+    { address: orcaOracleAddress, role: AccountRole15.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -12167,7 +12951,7 @@ async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionM
     orcaPosition: orcaPositionAddress,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS14,
+    memoProgram: MEMO_PROGRAM_ADDRESS15,
     metadataUpdateAuth: WP_NFT_UPDATE_AUTH,
     associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS3,
     token2022Program: TOKEN_2022_PROGRAM_ADDRESS15,
@@ -12191,19 +12975,19 @@ import {
 } from "@crypticdot/fusionamm-client";
 import { getTickArrayStartTickIndex as getTickArrayStartTickIndex7 } from "@crypticdot/fusionamm-core";
 import {
-  AccountRole as AccountRole15,
+  AccountRole as AccountRole16,
   generateKeyPairSigner as generateKeyPairSigner2,
   lamports as lamports2
 } from "@solana/kit";
 import { fetchSysvarRent as fetchSysvarRent2 } from "@solana/sysvars";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS15 } from "@solana-program/memo";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS16 } from "@solana-program/memo";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS4,
-  fetchAllMaybeMint as fetchAllMaybeMint17,
-  findAssociatedTokenPda as findAssociatedTokenPda24,
+  fetchAllMaybeMint as fetchAllMaybeMint18,
+  findAssociatedTokenPda as findAssociatedTokenPda25,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS16
 } from "@solana-program/token-2022";
-import assert17 from "assert";
+import assert18 from "assert";
 async function openAndIncreaseTunaLpPositionFusionInstructions(rpc, authority, fusionPoolAddress, args, createInstructions, cleanupInstructions) {
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
@@ -12216,9 +13000,9 @@ async function openAndIncreaseTunaLpPositionFusionInstructions(rpc, authority, f
   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 fetchAllMaybeMint17(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  assert17(mintA.exists, "Token A account not found");
-  assert17(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint18(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  assert18(mintA.exists, "Token A account not found");
+  assert18(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]
@@ -12324,47 +13108,47 @@ async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positio
   const tunaPositionAddress = (await getTunaLpPositionAddress(positionMint.address))[0];
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
   const fusionPositionAddress = (await getPositionAddress16(positionMint.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda24({
+  const tunaPositionAta = (await findAssociatedTokenPda25({
     owner: tunaPositionAddress,
     mint: positionMint.address,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS16
   }))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda24({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda25({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda24({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda25({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda24({
+  const tunaPositionAtaA = (await findAssociatedTokenPda25({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda24({
+  const tunaPositionAtaB = (await findAssociatedTokenPda25({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda24({
+  const vaultAAta = (await findAssociatedTokenPda25({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda24({
+  const vaultBAta = (await findAssociatedTokenPda25({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda24({
+  const feeRecipientAtaA = (await findAssociatedTokenPda25({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda24({
+  const feeRecipientAtaB = (await findAssociatedTokenPda25({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12373,15 +13157,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: AccountRole15.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole15.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole15.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole15.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole15.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole15.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole15.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: AccountRole15.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: AccountRole15.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole16.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole16.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole16.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole16.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole16.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole16.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole16.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: AccountRole16.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: AccountRole16.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -12418,7 +13202,7 @@ async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positio
     fusionPosition: fusionPositionAddress,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS15,
+    memoProgram: MEMO_PROGRAM_ADDRESS16,
     metadataUpdateAuth: FP_NFT_UPDATE_AUTH2,
     associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS4,
     token2022Program: TOKEN_2022_PROGRAM_ADDRESS16,
@@ -12433,40 +13217,40 @@ async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positio
 import { FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS11, getFusionPoolDecoder } from "@crypticdot/fusionamm-client";
 import { getWhirlpoolDecoder, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS11 } from "@orca-so/whirlpools-client";
 import {
-  decodeAccount as decodeAccount7,
-  fetchEncodedAccount as fetchEncodedAccount7
+  decodeAccount as decodeAccount8,
+  fetchEncodedAccount as fetchEncodedAccount8
 } from "@solana/kit";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS5,
-  fetchAllMaybeMint as fetchAllMaybeMint18,
-  findAssociatedTokenPda as findAssociatedTokenPda25
+  fetchAllMaybeMint as fetchAllMaybeMint19,
+  findAssociatedTokenPda as findAssociatedTokenPda26
 } from "@solana-program/token-2022";
-import assert18 from "assert";
+import assert19 from "assert";
 async function openTunaSpotPositionInstructions(rpc, authority, poolAddress, args) {
-  const poolAccount = await fetchEncodedAccount7(rpc, poolAddress);
-  assert18(poolAccount.exists, "Pool account not found");
+  const poolAccount = await fetchEncodedAccount8(rpc, poolAddress);
+  assert19(poolAccount.exists, "Pool account not found");
   let pool;
   if (poolAccount.programAddress == FUSIONAMM_PROGRAM_ADDRESS11) {
-    pool = decodeAccount7(poolAccount, getFusionPoolDecoder());
+    pool = decodeAccount8(poolAccount, getFusionPoolDecoder());
   } else if (poolAccount.programAddress == WHIRLPOOL_PROGRAM_ADDRESS11) {
-    pool = decodeAccount7(poolAccount, getWhirlpoolDecoder());
+    pool = decodeAccount8(poolAccount, getWhirlpoolDecoder());
   } else {
     throw new Error("Incorrect Fusion or Orca pool account");
   }
-  const [mintA, mintB] = await fetchAllMaybeMint18(rpc, [pool.data.tokenMintA, pool.data.tokenMintB]);
-  assert18(mintA.exists, "Token A account not found");
-  assert18(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint19(rpc, [pool.data.tokenMintA, pool.data.tokenMintB]);
+  assert19(mintA.exists, "Token A account not found");
+  assert19(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 findAssociatedTokenPda25({
+  const tunaPositionAtaA = (await findAssociatedTokenPda26({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda25({
+  const tunaPositionAtaB = (await findAssociatedTokenPda26({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12498,16 +13282,16 @@ import {
 } from "@orca-so/whirlpools-client";
 import { collectRewardsQuote as collectRewardsQuote2, getTickArrayStartTickIndex as getTickArrayStartTickIndex8, getTickIndexInArray as getTickIndexInArray2 } from "@orca-so/whirlpools-core";
 import {
-  AccountRole as AccountRole16,
-  assertAccountsExist as assertAccountsExist8
+  AccountRole as AccountRole17,
+  assertAccountsExist as assertAccountsExist9
 } from "@solana/kit";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS16 } from "@solana-program/memo";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS17 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint19,
-  findAssociatedTokenPda as findAssociatedTokenPda26,
+  fetchAllMaybeMint as fetchAllMaybeMint20,
+  findAssociatedTokenPda as findAssociatedTokenPda27,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS17
 } from "@solana-program/token-2022";
-import assert19 from "assert";
+import assert20 from "assert";
 async function decreaseTunaLpPositionOrcaInstructions(rpc, authority, positionMint, args, createInstructions, cleanupInstructions) {
   const tunaPosition = await fetchMaybeTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
   if (!tunaPosition.exists) throw new Error("Tuna position account not found");
@@ -12518,15 +13302,15 @@ async function decreaseTunaLpPositionOrcaInstructions(rpc, authority, positionMi
     (await getLendingVaultAddress(whirlpool.data.tokenMintA))[0],
     (await getLendingVaultAddress(whirlpool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB, ...rewardMints] = await fetchAllMaybeMint19(rpc, [
+  const [mintA, mintB, ...rewardMints] = await fetchAllMaybeMint20(rpc, [
     whirlpool.data.tokenMintA,
     whirlpool.data.tokenMintB,
     ...whirlpool.data.rewardInfos.map((x) => x.mint).filter((x) => x !== DEFAULT_ADDRESS)
   ]);
   const allMints = [mintA, mintB, ...rewardMints];
-  assert19(mintA.exists, "Token A account not found");
-  assert19(mintB.exists, "Token B account not found");
-  assertAccountsExist8(rewardMints);
+  assert20(mintA.exists, "Token A account not found");
+  assert20(mintB.exists, "Token B account not found");
+  assertAccountsExist9(rewardMints);
   const lowerTickArrayStartIndex = getTickArrayStartTickIndex8(
     tunaPosition.data.tickLowerIndex,
     whirlpool.data.tickSpacing
@@ -12566,7 +13350,7 @@ async function decreaseTunaLpPositionOrcaInstructions(rpc, authority, positionMi
   }
   for (const mintAddress of requiredMints) {
     const mint = allMints.find((mint2) => mint2.address == mintAddress);
-    assert19(mint && mint.exists);
+    assert20(mint && mint.exists);
     const ixs = await getCreateAtaInstructions(rpc, authority, mint.address, authority.address, mint.programAddress);
     createInstructions.push(...ixs.init);
     internalCleanupInstructions.push(...ixs.cleanup);
@@ -12594,37 +13378,37 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
   const orcaPositionAddress = (await getPositionAddress17(positionMint))[0];
   const orcaOracleAddress = (await getOracleAddress7(whirlpool.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda26({
+  const tunaPositionAta = (await findAssociatedTokenPda27({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS17
   }))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda26({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda27({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda26({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda27({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda26({
+  const tunaPositionAtaA = (await findAssociatedTokenPda27({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda26({
+  const tunaPositionAtaB = (await findAssociatedTokenPda27({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda26({
+  const vaultAAta = (await findAssociatedTokenPda27({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda26({
+  const vaultBAta = (await findAssociatedTokenPda27({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12639,30 +13423,30 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole16.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole16.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole16.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole16.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole16.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole16.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole16.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: AccountRole16.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: AccountRole16.WRITABLE },
-    { address: orcaOracleAddress, role: AccountRole16.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole17.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole17.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole17.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole17.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole17.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole17.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole17.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: AccountRole17.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: AccountRole17.WRITABLE },
+    { address: orcaOracleAddress, role: AccountRole17.WRITABLE }
   ];
   for (const rewardIndex of rewardIndicesToClaim) {
     const rewardInfo = whirlpool.data.rewardInfos[rewardIndex];
     const rewardMint = rewardMints.find((mint) => mint.address == rewardInfo.mint);
-    assert19(rewardMint, "Reward mint not found in the provided reward mint accounts");
-    const ownerAta = await findAssociatedTokenPda26({
+    assert20(rewardMint, "Reward mint not found in the provided reward mint accounts");
+    const ownerAta = await findAssociatedTokenPda27({
       owner: authority.address,
       mint: rewardMint.address,
       tokenProgram: rewardMint.programAddress
     });
-    remainingAccounts.push({ address: rewardMint.address, role: AccountRole16.READONLY });
-    remainingAccounts.push({ address: rewardMint.programAddress, role: AccountRole16.READONLY });
-    remainingAccounts.push({ address: ownerAta[0], role: AccountRole16.WRITABLE });
-    remainingAccounts.push({ address: rewardInfo.vault, role: AccountRole16.WRITABLE });
+    remainingAccounts.push({ address: rewardMint.address, role: AccountRole17.READONLY });
+    remainingAccounts.push({ address: rewardMint.programAddress, role: AccountRole17.READONLY });
+    remainingAccounts.push({ address: ownerAta[0], role: AccountRole17.WRITABLE });
+    remainingAccounts.push({ address: rewardInfo.vault, role: AccountRole17.WRITABLE });
   }
   const remainingAccountsInfo = {
     slices: [
@@ -12700,7 +13484,7 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
     whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS12,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS16,
+    memoProgram: MEMO_PROGRAM_ADDRESS17,
     ...args,
     remainingAccountsInfo
   });
@@ -12715,15 +13499,15 @@ import {
   getPositionAddress as getPositionAddress18
 } from "@crypticdot/fusionamm-client";
 import {
-  AccountRole as AccountRole17
+  AccountRole as AccountRole18
 } from "@solana/kit";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS17 } from "@solana-program/memo";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS18 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint20,
-  findAssociatedTokenPda as findAssociatedTokenPda27,
+  fetchAllMaybeMint as fetchAllMaybeMint21,
+  findAssociatedTokenPda as findAssociatedTokenPda28,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS18
 } from "@solana-program/token-2022";
-import assert20 from "assert";
+import assert21 from "assert";
 async function decreaseTunaLpPositionFusionInstructions(rpc, authority, positionMint, args, createInstructions, cleanupInstructions) {
   const tunaPosition = await fetchMaybeTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
   if (!tunaPosition.exists) throw new Error("Tuna position account not found");
@@ -12733,9 +13517,9 @@ async function decreaseTunaLpPositionFusionInstructions(rpc, authority, position
     (await getLendingVaultAddress(fusionPool.data.tokenMintA))[0],
     (await getLendingVaultAddress(fusionPool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint20(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  assert20(mintA.exists, "Token A account not found");
-  assert20(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint21(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  assert21(mintA.exists, "Token A account not found");
+  assert21(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -12776,37 +13560,37 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
   const tunaConfig = (await getTunaConfigAddress())[0];
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
   const fusionPositionAddress = (await getPositionAddress18(positionMint))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda27({
+  const tunaPositionAta = (await findAssociatedTokenPda28({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS18
   }))[0];
-  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda27({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda28({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda27({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda28({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda27({
+  const tunaPositionAtaA = (await findAssociatedTokenPda28({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda27({
+  const tunaPositionAtaB = (await findAssociatedTokenPda28({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const vaultAAta = (await findAssociatedTokenPda27({
+  const vaultAAta = (await findAssociatedTokenPda28({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda27({
+  const vaultBAta = (await findAssociatedTokenPda28({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12821,15 +13605,15 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole17.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole17.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole17.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole17.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole17.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole17.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole17.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: AccountRole17.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: AccountRole17.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole18.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole18.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole18.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole18.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole18.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole18.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole18.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: AccountRole18.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: AccountRole18.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -12863,7 +13647,7 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
     fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS12,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS17,
+    memoProgram: MEMO_PROGRAM_ADDRESS18,
     ...args,
     remainingAccountsInfo
   });
@@ -12872,19 +13656,19 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
 }
 
 // src/txbuilder/repayBadDebt.ts
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS18 } from "@solana-program/memo";
-import { fetchMaybeMint as fetchMaybeMint2, findAssociatedTokenPda as findAssociatedTokenPda28 } from "@solana-program/token-2022";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS19 } from "@solana-program/memo";
+import { fetchMaybeMint as fetchMaybeMint2, findAssociatedTokenPda as findAssociatedTokenPda29 } from "@solana-program/token-2022";
 async function repayBadDebtInstruction(rpc, authority, mintAddress, funds, shares) {
   const mint = await fetchMaybeMint2(rpc, mintAddress);
   if (!mint.exists) throw new Error("Mint account not found");
   const tunaConfig = (await getTunaConfigAddress())[0];
   const vault = (await getLendingVaultAddress(mint.address))[0];
-  const vaultAta = (await findAssociatedTokenPda28({
+  const vaultAta = (await findAssociatedTokenPda29({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
   }))[0];
-  const authorityAta = (await findAssociatedTokenPda28({
+  const authorityAta = (await findAssociatedTokenPda29({
     owner: authority.address,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -12897,7 +13681,7 @@ async function repayBadDebtInstruction(rpc, authority, mintAddress, funds, share
     tunaConfig,
     vault,
     tokenProgram: mint.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS18,
+    memoProgram: MEMO_PROGRAM_ADDRESS19,
     funds,
     shares
   });
@@ -12929,20 +13713,20 @@ async function setTunaSpotPositionLimitOrdersInstruction(authority, poolAddress,
 }
 
 // src/txbuilder/resetTunaSpotPosition.ts
-import { fetchAllMaybeMint as fetchAllMaybeMint21, findAssociatedTokenPda as findAssociatedTokenPda29 } from "@solana-program/token-2022";
-import assert21 from "assert";
+import { fetchAllMaybeMint as fetchAllMaybeMint22, findAssociatedTokenPda as findAssociatedTokenPda30 } from "@solana-program/token-2022";
+import assert22 from "assert";
 async function resetTunaSpotPositionInstruction(rpc, authority, poolAddress, args) {
   const tunaPositionAddress = (await getTunaSpotPositionAddress(authority.address, poolAddress))[0];
   const tunaPosition = await fetchTunaSpotPosition(rpc, tunaPositionAddress);
-  const [mintA, mintB] = await fetchAllMaybeMint21(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  assert21(mintA.exists, "Token A not found");
-  assert21(mintB.exists, "Token B not found");
-  const tunaPositionAtaA = (await findAssociatedTokenPda29({
+  const [mintA, mintB] = await fetchAllMaybeMint22(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  assert22(mintA.exists, "Token A not found");
+  assert22(mintB.exists, "Token B not found");
+  const tunaPositionAtaA = (await findAssociatedTokenPda30({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda29({
+  const tunaPositionAtaB = (await findAssociatedTokenPda30({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -12983,8 +13767,8 @@ async function updateVaultInstruction(authority, mint, args) {
 }
 
 // src/txbuilder/withdraw.ts
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS19 } from "@solana-program/memo";
-import { fetchMaybeMint as fetchMaybeMint3, findAssociatedTokenPda as findAssociatedTokenPda30 } from "@solana-program/token-2022";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS20 } from "@solana-program/memo";
+import { fetchMaybeMint as fetchMaybeMint3, findAssociatedTokenPda as findAssociatedTokenPda31 } from "@solana-program/token-2022";
 async function withdrawInstructions(rpc, authority, mintAddress, funds, shares) {
   const instructions = [];
   const mint = await fetchMaybeMint3(rpc, mintAddress);
@@ -13006,12 +13790,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 findAssociatedTokenPda30({
+  const vaultAta = (await findAssociatedTokenPda31({
     owner: vault,
     mint: mint.address,
     tokenProgram: mint.programAddress
   }))[0];
-  const authorityAta = (await findAssociatedTokenPda30({
+  const authorityAta = (await findAssociatedTokenPda31({
     owner: authority.address,
     mint: mint.address,
     tokenProgram: mint.programAddress
@@ -13025,26 +13809,26 @@ async function withdrawInstruction(authority, mint, funds, shares) {
     vault,
     vaultAta,
     tokenProgram: mint.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS19,
+    memoProgram: MEMO_PROGRAM_ADDRESS20,
     funds,
     shares
   });
 }
 
 // src/txbuilder/createMarketLookupTable.ts
-import { fetchFusionPool as fetchFusionPool2, FP_NFT_UPDATE_AUTH as FP_NFT_UPDATE_AUTH3, FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS13 } from "@crypticdot/fusionamm-client";
-import { fetchWhirlpool as fetchWhirlpool2, getOracleAddress as getOracleAddress8, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS13 } from "@orca-so/whirlpools-client";
+import { fetchFusionPool as fetchFusionPool3, FP_NFT_UPDATE_AUTH as FP_NFT_UPDATE_AUTH3, FUSIONAMM_PROGRAM_ADDRESS as FUSIONAMM_PROGRAM_ADDRESS13 } from "@crypticdot/fusionamm-client";
+import { fetchWhirlpool as fetchWhirlpool3, getOracleAddress as getOracleAddress8, WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS13 } from "@orca-so/whirlpools-client";
 import {
   address as address3
 } from "@solana/kit";
 import { fetchAddressLookupTable, getExtendLookupTableInstruction as getExtendLookupTableInstruction2 } from "@solana-program/address-lookup-table";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS20 } from "@solana-program/memo";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS21 } from "@solana-program/memo";
 import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import { TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS2 } from "@solana-program/token";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS as ASSOCIATED_TOKEN_PROGRAM_ADDRESS6,
   fetchMint,
-  findAssociatedTokenPda as findAssociatedTokenPda31,
+  findAssociatedTokenPda as findAssociatedTokenPda32,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS19
 } from "@solana-program/token-2022";
 async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
@@ -13052,15 +13836,15 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
   const marketAddress = (await getMarketAddress(poolAddress))[0];
   const orcaOracleAddress = (await getOracleAddress8(poolAddress))[0];
   const tunaConfig = await fetchTunaConfig(rpc, tunaConfigAddress);
-  const pool = marketMaker == 0 /* Orca */ ? await fetchWhirlpool2(rpc, poolAddress) : await fetchFusionPool2(rpc, poolAddress);
+  const pool = marketMaker == 0 /* Orca */ ? await fetchWhirlpool3(rpc, poolAddress) : await fetchFusionPool3(rpc, poolAddress);
   const mintA = await fetchMint(rpc, pool.data.tokenMintA);
   const mintB = await fetchMint(rpc, pool.data.tokenMintB);
-  const feeRecipientAtaA = (await findAssociatedTokenPda31({
+  const feeRecipientAtaA = (await findAssociatedTokenPda32({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda31({
+  const feeRecipientAtaB = (await findAssociatedTokenPda32({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -13069,12 +13853,12 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
     (await getLendingVaultAddress(mintA.address))[0],
     (await getLendingVaultAddress(mintB.address))[0]
   ]);
-  const vaultAAta = (await findAssociatedTokenPda31({
+  const vaultAAta = (await findAssociatedTokenPda32({
     owner: vaultA.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const vaultBAta = (await findAssociatedTokenPda31({
+  const vaultBAta = (await findAssociatedTokenPda32({
     owner: vaultB.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -13086,7 +13870,7 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
     TOKEN_PROGRAM_ADDRESS2,
     TOKEN_2022_PROGRAM_ADDRESS19,
     NATIVE_MINT,
-    MEMO_PROGRAM_ADDRESS20,
+    MEMO_PROGRAM_ADDRESS21,
     tunaConfigAddress,
     marketAddress,
     mintA.address,
@@ -13141,17 +13925,17 @@ async function extendAddressLookupTableForMarketInstructions(rpc, poolAddress, m
 }
 
 // src/txbuilder/repayTunaLpPositionDebt.ts
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS21 } from "@solana-program/memo";
-import { fetchAllMaybeMint as fetchAllMaybeMint22, findAssociatedTokenPda as findAssociatedTokenPda32 } from "@solana-program/token-2022";
-import assert22 from "assert";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS22 } from "@solana-program/memo";
+import { fetchAllMaybeMint as fetchAllMaybeMint23, findAssociatedTokenPda as findAssociatedTokenPda33 } from "@solana-program/token-2022";
+import assert23 from "assert";
 async function repayTunaLpPositionDebtInstructions(rpc, authority, positionMint, collateralA, collateralB, createInstructions, cleanupInstructions) {
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
   const tunaPosition = await fetchTunaLpPosition(rpc, (await getTunaLpPositionAddress(positionMint))[0]);
-  const [mintA, mintB] = await fetchAllMaybeMint22(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
-  assert22(mintA.exists, "Token A not found");
-  assert22(mintB.exists, "Token B not found");
+  const [mintA, mintB] = await fetchAllMaybeMint23(rpc, [tunaPosition.data.mintA, tunaPosition.data.mintB]);
+  assert23(mintA.exists, "Token A not found");
+  assert23(mintB.exists, "Token B not found");
   const marketAddress = (await getMarketAddress(tunaPosition.data.pool))[0];
   const createUserAtaAInstructions = await getCreateAtaInstructions(
     rpc,
@@ -13187,34 +13971,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 findAssociatedTokenPda32({
+  const tunaPositionOwnerAtaA = (await findAssociatedTokenPda33({
     owner: authority.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda32({
+  const tunaPositionOwnerAtaB = (await findAssociatedTokenPda33({
     owner: authority.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda32({
+  const tunaPositionAtaA = (await findAssociatedTokenPda33({
     owner: tunaPositionAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda32({
+  const tunaPositionAtaB = (await findAssociatedTokenPda33({
     owner: tunaPositionAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
   const vaultAAddress = (await getLendingVaultAddress(mintA.address))[0];
-  const vaultAAta = (await findAssociatedTokenPda32({
+  const vaultAAta = (await findAssociatedTokenPda33({
     owner: vaultAAddress,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
   const vaultBAddress = (await getLendingVaultAddress(mintB.address))[0];
-  const vaultBAta = (await findAssociatedTokenPda32({
+  const vaultBAta = (await findAssociatedTokenPda33({
     owner: vaultBAddress,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -13222,7 +14006,7 @@ async function repayTunaLpPositionDebtInstruction(authority, positionMint, mintA
   return getRepayTunaLpPositionDebtInstruction({
     authority,
     market: marketAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS21,
+    memoProgram: MEMO_PROGRAM_ADDRESS22,
     mintA: mintA.address,
     mintB: mintB.address,
     tokenProgramA: mintA.programAddress,
@@ -13252,17 +14036,17 @@ import {
   WHIRLPOOL_PROGRAM_ADDRESS as WHIRLPOOL_PROGRAM_ADDRESS14
 } from "@orca-so/whirlpools-client";
 import {
-  AccountRole as AccountRole18,
+  AccountRole as AccountRole19,
   lamports as lamports3
 } from "@solana/kit";
 import { fetchSysvarRent as fetchSysvarRent3 } from "@solana/sysvars";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS22 } from "@solana-program/memo";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS23 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint23,
-  findAssociatedTokenPda as findAssociatedTokenPda33,
+  fetchAllMaybeMint as fetchAllMaybeMint24,
+  findAssociatedTokenPda as findAssociatedTokenPda34,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS20
 } from "@solana-program/token-2022";
-import assert23 from "assert";
+import assert24 from "assert";
 async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await fetchSysvarRent3(rpc);
   let nonRefundableRent = 0n;
@@ -13275,9 +14059,9 @@ async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionM
     (await getLendingVaultAddress(whirlpool.data.tokenMintA))[0],
     (await getLendingVaultAddress(whirlpool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint23(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
-  assert23(mintA.exists, "Token A account not found");
-  assert23(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint24(rpc, [whirlpool.data.tokenMintA, whirlpool.data.tokenMintB]);
+  assert24(mintA.exists, "Token A account not found");
+  assert24(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -13349,27 +14133,27 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
   const marketAddress = (await getMarketAddress(whirlpool.address))[0];
   const orcaPositionAddress = (await getPositionAddress19(positionMint))[0];
   const orcaOracleAddress = (await getOracleAddress9(whirlpool.address))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda33({
+  const tunaPositionAta = (await findAssociatedTokenPda34({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS20
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda33({
+  const tunaPositionAtaA = (await findAssociatedTokenPda34({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda33({
+  const tunaPositionAtaB = (await findAssociatedTokenPda34({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda33({
+  const feeRecipientAtaA = (await findAssociatedTokenPda34({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda33({
+  const feeRecipientAtaB = (await findAssociatedTokenPda34({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -13385,18 +14169,18 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
   );
   const secondaryTickArrays = await OrcaUtils.getTickArraysForRebalancedPosition(whirlpool, tunaPosition);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole18.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole18.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole18.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole18.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole18.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole18.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole18.WRITABLE },
-    { address: secondaryTickArrays.lowerTickArrayAddress, role: AccountRole18.WRITABLE },
-    { address: secondaryTickArrays.upperTickArrayAddress, role: AccountRole18.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: AccountRole18.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: AccountRole18.WRITABLE },
-    { address: orcaOracleAddress, role: AccountRole18.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole19.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole19.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole19.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole19.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole19.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole19.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole19.WRITABLE },
+    { address: secondaryTickArrays.lowerTickArrayAddress, role: AccountRole19.WRITABLE },
+    { address: secondaryTickArrays.upperTickArrayAddress, role: AccountRole19.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: AccountRole19.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: AccountRole19.WRITABLE },
+    { address: orcaOracleAddress, role: AccountRole19.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -13431,7 +14215,7 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
     whirlpoolProgram: WHIRLPOOL_PROGRAM_ADDRESS14,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS22,
+    memoProgram: MEMO_PROGRAM_ADDRESS23,
     remainingAccountsInfo
   });
   ix.accounts.push(...remainingAccounts);
@@ -13448,17 +14232,17 @@ import {
   getTickArraySize as getTickArraySize2
 } from "@crypticdot/fusionamm-client";
 import {
-  AccountRole as AccountRole19,
+  AccountRole as AccountRole20,
   lamports as lamports4
 } from "@solana/kit";
 import { fetchSysvarRent as fetchSysvarRent4 } from "@solana/sysvars";
-import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS23 } from "@solana-program/memo";
+import { MEMO_PROGRAM_ADDRESS as MEMO_PROGRAM_ADDRESS24 } from "@solana-program/memo";
 import {
-  fetchAllMaybeMint as fetchAllMaybeMint24,
-  findAssociatedTokenPda as findAssociatedTokenPda34,
+  fetchAllMaybeMint as fetchAllMaybeMint25,
+  findAssociatedTokenPda as findAssociatedTokenPda35,
   TOKEN_2022_PROGRAM_ADDRESS as TOKEN_2022_PROGRAM_ADDRESS21
 } from "@solana-program/token-2022";
-import assert24 from "assert";
+import assert25 from "assert";
 async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positionMint, createInstructions, cleanupInstructions) {
   const rent = await fetchSysvarRent4(rpc);
   let nonRefundableRent = 0n;
@@ -13471,9 +14255,9 @@ async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positio
     (await getLendingVaultAddress(fusionPool.data.tokenMintA))[0],
     (await getLendingVaultAddress(fusionPool.data.tokenMintB))[0]
   ]);
-  const [mintA, mintB] = await fetchAllMaybeMint24(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
-  assert24(mintA.exists, "Token A account not found");
-  assert24(mintB.exists, "Token B account not found");
+  const [mintA, mintB] = await fetchAllMaybeMint25(rpc, [fusionPool.data.tokenMintA, fusionPool.data.tokenMintB]);
+  assert25(mintA.exists, "Token A account not found");
+  assert25(mintB.exists, "Token B account not found");
   const instructions = [];
   if (!createInstructions) createInstructions = instructions;
   if (!cleanupInstructions) cleanupInstructions = instructions;
@@ -13540,27 +14324,27 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
   const positionMint = tunaPosition.data.positionMint;
   const marketAddress = (await getMarketAddress(fusionPool.address))[0];
   const fusionPositionAddress = (await getPositionAddress20(positionMint))[0];
-  const tunaPositionAta = (await findAssociatedTokenPda34({
+  const tunaPositionAta = (await findAssociatedTokenPda35({
     owner: tunaPosition.address,
     mint: positionMint,
     tokenProgram: TOKEN_2022_PROGRAM_ADDRESS21
   }))[0];
-  const tunaPositionAtaA = (await findAssociatedTokenPda34({
+  const tunaPositionAtaA = (await findAssociatedTokenPda35({
     owner: tunaPosition.address,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const tunaPositionAtaB = (await findAssociatedTokenPda34({
+  const tunaPositionAtaB = (await findAssociatedTokenPda35({
     owner: tunaPosition.address,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
   }))[0];
-  const feeRecipientAtaA = (await findAssociatedTokenPda34({
+  const feeRecipientAtaA = (await findAssociatedTokenPda35({
     owner: tunaConfig.data.feeRecipient,
     mint: mintA.address,
     tokenProgram: mintA.programAddress
   }))[0];
-  const feeRecipientAtaB = (await findAssociatedTokenPda34({
+  const feeRecipientAtaB = (await findAssociatedTokenPda35({
     owner: tunaConfig.data.feeRecipient,
     mint: mintB.address,
     tokenProgram: mintB.programAddress
@@ -13576,17 +14360,17 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
   );
   const secondaryTickArrays = await FusionUtils.getTickArraysForRebalancedPosition(fusionPool, tunaPosition);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: AccountRole19.WRITABLE },
-    { address: swapTickArrays[1], role: AccountRole19.WRITABLE },
-    { address: swapTickArrays[2], role: AccountRole19.WRITABLE },
-    { address: swapTickArrays[3], role: AccountRole19.WRITABLE },
-    { address: swapTickArrays[4], role: AccountRole19.WRITABLE },
-    { address: lowerTickArrayAddress, role: AccountRole19.WRITABLE },
-    { address: upperTickArrayAddress, role: AccountRole19.WRITABLE },
-    { address: secondaryTickArrays.lowerTickArrayAddress, role: AccountRole19.WRITABLE },
-    { address: secondaryTickArrays.upperTickArrayAddress, role: AccountRole19.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: AccountRole19.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: AccountRole19.WRITABLE }
+    { address: swapTickArrays[0], role: AccountRole20.WRITABLE },
+    { address: swapTickArrays[1], role: AccountRole20.WRITABLE },
+    { address: swapTickArrays[2], role: AccountRole20.WRITABLE },
+    { address: swapTickArrays[3], role: AccountRole20.WRITABLE },
+    { address: swapTickArrays[4], role: AccountRole20.WRITABLE },
+    { address: lowerTickArrayAddress, role: AccountRole20.WRITABLE },
+    { address: upperTickArrayAddress, role: AccountRole20.WRITABLE },
+    { address: secondaryTickArrays.lowerTickArrayAddress, role: AccountRole20.WRITABLE },
+    { address: secondaryTickArrays.upperTickArrayAddress, role: AccountRole20.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: AccountRole20.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: AccountRole20.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -13620,7 +14404,7 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
     fusionammProgram: FUSIONAMM_PROGRAM_ADDRESS14,
     tokenProgramA: mintA.programAddress,
     tokenProgramB: mintB.programAddress,
-    memoProgram: MEMO_PROGRAM_ADDRESS23,
+    memoProgram: MEMO_PROGRAM_ADDRESS24,
     remainingAccountsInfo
   });
   ix.accounts.push(...remainingAccounts);
@@ -14171,6 +14955,8 @@ export {
   liquidateTunaSpotPositionOrcaInstructions,
   modifyTunaSpotPositionFusionInstruction,
   modifyTunaSpotPositionFusionInstructions,
+  modifyTunaSpotPositionJupiterInstruction,
+  modifyTunaSpotPositionJupiterInstructions,
   modifyTunaSpotPositionOrcaInstruction,
   modifyTunaSpotPositionOrcaInstructions,
   mulDiv,