@crypticdot/defituna-client 3.5.4 → 3.5.5

package/dist/index.cjs

@@ -773,13 +773,13 @@ function decodeLendingPosition(encodedAccount) {
     getLendingPositionDecoder()
   );
 }
-async function fetchLendingPosition(rpc, address4, config) {
-  const maybeAccount = await fetchMaybeLendingPosition(rpc, address4, config);
+async function fetchLendingPosition(rpc, address5, config) {
+  const maybeAccount = await fetchMaybeLendingPosition(rpc, address5, config);
   (0, import_kit.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeLendingPosition(rpc, address4, config) {
-  const maybeAccount = await (0, import_kit.fetchEncodedAccount)(rpc, address4, config);
+async function fetchMaybeLendingPosition(rpc, address5, config) {
+  const maybeAccount = await (0, import_kit.fetchEncodedAccount)(rpc, address5, config);
   return decodeLendingPosition(maybeAccount);
 }
 async function fetchAllLendingPosition(rpc, addresses, config) {
@@ -1007,13 +1007,13 @@ function decodeMarket(encodedAccount) {
     getMarketDecoder()
   );
 }
-async function fetchMarket(rpc, address4, config) {
-  const maybeAccount = await fetchMaybeMarket(rpc, address4, config);
+async function fetchMarket(rpc, address5, config) {
+  const maybeAccount = await fetchMaybeMarket(rpc, address5, config);
   (0, import_kit8.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeMarket(rpc, address4, config) {
-  const maybeAccount = await (0, import_kit8.fetchEncodedAccount)(rpc, address4, config);
+async function fetchMaybeMarket(rpc, address5, config) {
+  const maybeAccount = await (0, import_kit8.fetchEncodedAccount)(rpc, address5, config);
   return decodeMarket(maybeAccount);
 }
 async function fetchAllMarket(rpc, addresses, config) {
@@ -1100,13 +1100,13 @@ function decodeTunaConfig(encodedAccount) {
     getTunaConfigDecoder()
   );
 }
-async function fetchTunaConfig(rpc, address4, config) {
-  const maybeAccount = await fetchMaybeTunaConfig(rpc, address4, config);
+async function fetchTunaConfig(rpc, address5, config) {
+  const maybeAccount = await fetchMaybeTunaConfig(rpc, address5, config);
   (0, import_kit9.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeTunaConfig(rpc, address4, config) {
-  const maybeAccount = await (0, import_kit9.fetchEncodedAccount)(rpc, address4, config);
+async function fetchMaybeTunaConfig(rpc, address5, config) {
+  const maybeAccount = await (0, import_kit9.fetchEncodedAccount)(rpc, address5, config);
   return decodeTunaConfig(maybeAccount);
 }
 async function fetchAllTunaConfig(rpc, addresses, config) {
@@ -1221,13 +1221,13 @@ function decodeTunaLpPosition(encodedAccount) {
     getTunaLpPositionDecoder()
   );
 }
-async function fetchTunaLpPosition(rpc, address4, config) {
-  const maybeAccount = await fetchMaybeTunaLpPosition(rpc, address4, config);
+async function fetchTunaLpPosition(rpc, address5, config) {
+  const maybeAccount = await fetchMaybeTunaLpPosition(rpc, address5, config);
   (0, import_kit10.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeTunaLpPosition(rpc, address4, config) {
-  const maybeAccount = await (0, import_kit10.fetchEncodedAccount)(rpc, address4, config);
+async function fetchMaybeTunaLpPosition(rpc, address5, config) {
+  const maybeAccount = await (0, import_kit10.fetchEncodedAccount)(rpc, address5, config);
   return decodeTunaLpPosition(maybeAccount);
 }
 async function fetchAllTunaLpPosition(rpc, addresses, config) {
@@ -1325,13 +1325,13 @@ function decodeTunaSpotPosition(encodedAccount) {
     getTunaSpotPositionDecoder()
   );
 }
-async function fetchTunaSpotPosition(rpc, address4, config) {
-  const maybeAccount = await fetchMaybeTunaSpotPosition(rpc, address4, config);
+async function fetchTunaSpotPosition(rpc, address5, config) {
+  const maybeAccount = await fetchMaybeTunaSpotPosition(rpc, address5, config);
   (0, import_kit11.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeTunaSpotPosition(rpc, address4, config) {
-  const maybeAccount = await (0, import_kit11.fetchEncodedAccount)(rpc, address4, config);
+async function fetchMaybeTunaSpotPosition(rpc, address5, config) {
+  const maybeAccount = await (0, import_kit11.fetchEncodedAccount)(rpc, address5, config);
   return decodeTunaSpotPosition(maybeAccount);
 }
 async function fetchAllTunaSpotPosition(rpc, addresses, config) {
@@ -1420,13 +1420,13 @@ function decodeVault(encodedAccount) {
     getVaultDecoder()
   );
 }
-async function fetchVault(rpc, address4, config) {
-  const maybeAccount = await fetchMaybeVault(rpc, address4, config);
+async function fetchVault(rpc, address5, config) {
+  const maybeAccount = await fetchMaybeVault(rpc, address5, config);
   (0, import_kit12.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeVault(rpc, address4, config) {
-  const maybeAccount = await (0, import_kit12.fetchEncodedAccount)(rpc, address4, config);
+async function fetchMaybeVault(rpc, address5, config) {
+  const maybeAccount = await (0, import_kit12.fetchEncodedAccount)(rpc, address5, config);
   return decodeVault(maybeAccount);
 }
 async function fetchAllVault(rpc, addresses, config) {
@@ -9672,47 +9672,47 @@ async function fetchDecodedProgramAccounts(rpc, programAddress, filters, decoder
 }
 
 // src/gpa/tunaLpPosition.ts
-function tunaLpPositionAuthorityFilter(address4) {
+function tunaLpPositionAuthorityFilter(address5) {
   return {
     memcmp: {
       offset: 11n,
-      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function tunaLpPositionPoolFilter(address4) {
+function tunaLpPositionPoolFilter(address5) {
   return {
     memcmp: {
       offset: 43n,
-      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function tunaLpPositionMintAFilter(address4) {
+function tunaLpPositionMintAFilter(address5) {
   return {
     memcmp: {
       offset: 75n,
-      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function tunaLpPositionMintBFilter(address4) {
+function tunaLpPositionMintBFilter(address5) {
   return {
     memcmp: {
       offset: 107n,
-      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function tunaLpPositionMintFilter(address4) {
+function tunaLpPositionMintFilter(address5) {
   return {
     memcmp: {
       offset: 139n,
-      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit76.getBase58Decoder)().decode((0, import_kit76.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
@@ -9745,38 +9745,38 @@ async function fetchAllTunaLpPositionWithFilter(rpc, ...filters) {
 
 // src/gpa/tunaSpotPosition.ts
 var import_kit77 = require("@solana/kit");
-function tunaSpotPositionAuthorityFilter(address4) {
+function tunaSpotPositionAuthorityFilter(address5) {
   return {
     memcmp: {
       offset: 11n,
-      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function tunaSpotPositionPoolFilter(address4) {
+function tunaSpotPositionPoolFilter(address5) {
   return {
     memcmp: {
       offset: 43n,
-      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function tunaSpotPositionMintAFilter(address4) {
+function tunaSpotPositionMintAFilter(address5) {
   return {
     memcmp: {
       offset: 75n,
-      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function tunaSpotPositionMintBFilter(address4) {
+function tunaSpotPositionMintBFilter(address5) {
   return {
     memcmp: {
       offset: 107n,
-      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit77.getBase58Decoder)().decode((0, import_kit77.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
@@ -9800,29 +9800,29 @@ async function fetchAllTunaSpotPositionWithFilter(rpc, ...filters) {
 
 // src/gpa/lendingPosition.ts
 var import_kit78 = require("@solana/kit");
-function lendingPositionAuthorityFilter(address4) {
+function lendingPositionAuthorityFilter(address5) {
   return {
     memcmp: {
       offset: 11n,
-      bytes: (0, import_kit78.getBase58Decoder)().decode((0, import_kit78.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit78.getBase58Decoder)().decode((0, import_kit78.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function lendingPositionMintFilter(address4) {
+function lendingPositionMintFilter(address5) {
   return {
     memcmp: {
       offset: 43n,
-      bytes: (0, import_kit78.getBase58Decoder)().decode((0, import_kit78.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit78.getBase58Decoder)().decode((0, import_kit78.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
 }
-function lendingPositionVaultFilter(address4) {
+function lendingPositionVaultFilter(address5) {
   return {
     memcmp: {
       offset: 91n,
-      bytes: (0, import_kit78.getBase58Decoder)().decode((0, import_kit78.getAddressEncoder)().encode(address4)),
+      bytes: (0, import_kit78.getBase58Decoder)().decode((0, import_kit78.getAddressEncoder)().encode(address5)),
       encoding: "base58"
     }
   };
@@ -13120,6 +13120,7 @@ function getOpenTunaLpPositionOrcaInstructionWithEphemeralSigner(input, config)
 // src/txbuilder/openTunaLpPositionFusion.ts
 var import_fusionamm_client11 = require("@crypticdot/fusionamm-client");
 var import_fusionamm_client12 = require("@crypticdot/fusionamm-client");
+var import_kit128 = require("@solana/kit");
 var import_token_202225 = require("@solana-program/token-2022");
 var import_assert16 = __toESM(require("assert"), 1);
 async function openTunaLpPositionFusionInstruction(rpc, authority, positionMint, fusionPoolAddress, args) {
@@ -13187,79 +13188,85 @@ async function openTunaLpPositionFusionInstruction(rpc, authority, positionMint,
     ...args
   });
 }
-function getOpenTunaLpPositionFusionInstructionWithEphemeralSigner(input, config) {
-  const programAddress = config?.programAddress ?? TUNA_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    authority: { value: input.authority ?? null, isWritable: true },
-    mintA: { value: input.mintA ?? null, isWritable: false },
-    mintB: { value: input.mintB ?? null, isWritable: false },
-    tokenProgramA: { value: input.tokenProgramA ?? null, isWritable: false },
-    tokenProgramB: { value: input.tokenProgramB ?? null, isWritable: false },
-    market: { value: input.market ?? null, isWritable: false },
-    tunaPosition: { value: input.tunaPosition ?? null, isWritable: true },
-    tunaPositionMint: {
-      value: input.tunaPositionMint ?? null,
-      isWritable: true
-    },
-    tunaPositionAta: { value: input.tunaPositionAta ?? null, isWritable: true },
-    tunaPositionAtaA: {
-      value: input.tunaPositionAtaA ?? null,
-      isWritable: true
-    },
-    tunaPositionAtaB: {
-      value: input.tunaPositionAtaB ?? null,
-      isWritable: true
-    },
-    fusionammProgram: {
-      value: input.fusionammProgram ?? null,
-      isWritable: false
-    },
-    fusionPool: { value: input.fusionPool ?? null, isWritable: false },
-    fusionPosition: { value: input.fusionPosition ?? null, isWritable: true },
-    metadataUpdateAuth: {
-      value: input.metadataUpdateAuth ?? null,
-      isWritable: false
-    },
-    token2022Program: {
-      value: input.token2022Program ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+function getOpenTunaLpPositionFusionInstructionWithEphemeralSigner(input) {
   const instruction = {
     accounts: [
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.mintA),
-      getAccountMeta(accounts.mintB),
-      getAccountMeta(accounts.tokenProgramA),
-      getAccountMeta(accounts.tokenProgramB),
-      getAccountMeta(accounts.market),
-      getAccountMeta(accounts.tunaPosition),
-      getAccountMeta(accounts.tunaPositionMint),
-      getAccountMeta(accounts.tunaPositionAta),
-      getAccountMeta(accounts.tunaPositionAtaA),
-      getAccountMeta(accounts.tunaPositionAtaB),
-      getAccountMeta(accounts.fusionammProgram),
-      getAccountMeta(accounts.fusionPool),
-      getAccountMeta(accounts.fusionPosition),
-      getAccountMeta(accounts.metadataUpdateAuth),
-      getAccountMeta(accounts.token2022Program),
-      getAccountMeta(accounts.systemProgram),
-      getAccountMeta(accounts.associatedTokenProgram)
+      {
+        address: input.authority.address,
+        role: import_kit128.AccountRole.WRITABLE_SIGNER
+      },
+      {
+        address: input.mintA,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.mintB,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.tokenProgramA,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.tokenProgramB,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.market,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.tunaPosition,
+        role: import_kit128.AccountRole.WRITABLE
+      },
+      {
+        address: input.tunaPositionMint,
+        role: import_kit128.AccountRole.WRITABLE_SIGNER
+      },
+      {
+        address: input.tunaPositionAta,
+        role: import_kit128.AccountRole.WRITABLE
+      },
+      {
+        address: input.tunaPositionAtaA,
+        role: import_kit128.AccountRole.WRITABLE
+      },
+      {
+        address: input.tunaPositionAtaB,
+        role: import_kit128.AccountRole.WRITABLE
+      },
+      {
+        address: input.fusionammProgram,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.fusionPool,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.fusionPosition,
+        role: import_kit128.AccountRole.WRITABLE
+      },
+      {
+        address: input.metadataUpdateAuth,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.token2022Program,
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.systemProgram ?? (0, import_kit128.address)("11111111111111111111111111111111"),
+        role: import_kit128.AccountRole.READONLY
+      },
+      {
+        address: input.associatedTokenProgram,
+        role: import_kit128.AccountRole.READONLY
+      }
     ],
-    programAddress,
+    programAddress: TUNA_PROGRAM_ADDRESS,
     data: getOpenTunaLpPositionFusionInstructionDataEncoder().encode(
-      args
+      input
     )
   };
   return instruction;
@@ -13268,7 +13275,7 @@ function getOpenTunaLpPositionFusionInstructionWithEphemeralSigner(input, config
 // src/txbuilder/openAndIncreaseTunaLpPositionOrca.ts
 var import_whirlpools_client12 = require("@orca-so/whirlpools-client");
 var import_whirlpools_core4 = require("@orca-so/whirlpools-core");
-var import_kit128 = require("@solana/kit");
+var import_kit129 = require("@solana/kit");
 var import_sysvars = require("@solana/sysvars");
 var import_memo16 = require("@solana-program/memo");
 var import_token_202226 = require("@solana-program/token-2022");
@@ -13380,7 +13387,7 @@ async function openAndIncreaseTunaLpPositionOrcaInstructions(rpc, authority, pos
   cleanupInstructions.push(...createUserAtaBInstructions.cleanup);
   return {
     instructions,
-    initializationCost: (0, import_kit128.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit129.lamports)(nonRefundableRent)
   };
 }
 async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionMint, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool, args) {
@@ -13438,16 +13445,16 @@ async function openAndIncreaseTunaLpPositionOrcaInstruction(authority, positionM
   const lowerTickArrayAddress = await OrcaUtils.getTickArrayAddressFromTickIndex(whirlpool, args.tickLowerIndex);
   const upperTickArrayAddress = await OrcaUtils.getTickArrayAddressFromTickIndex(whirlpool, args.tickUpperIndex);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit128.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit128.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit128.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit128.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit128.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit128.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit128.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit128.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit128.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit128.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit129.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit129.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit129.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit129.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit129.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit129.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit129.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit129.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit129.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit129.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -13650,7 +13657,7 @@ function getOpenAndIncreaseTunaLpPositionOrcaInstructionWithEphemeralSigner(inpu
 // src/txbuilder/openAndIncreaseTunaLpPositionFusion.ts
 var import_fusionamm_client13 = require("@crypticdot/fusionamm-client");
 var import_fusionamm_core4 = require("@crypticdot/fusionamm-core");
-var import_kit129 = require("@solana/kit");
+var import_kit130 = require("@solana/kit");
 var import_sysvars2 = require("@solana/sysvars");
 var import_memo17 = require("@solana-program/memo");
 var import_token_202227 = require("@solana-program/token-2022");
@@ -13749,7 +13756,7 @@ async function openAndIncreaseTunaLpPositionFusionInstructions(rpc, authority, p
   cleanupInstructions.push(...createUserAtaBInstructions.cleanup);
   return {
     instructions,
-    initializationCost: (0, import_kit129.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit130.lamports)(nonRefundableRent)
   };
 }
 async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positionMint, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool, args) {
@@ -13806,15 +13813,15 @@ async function openAndIncreaseTunaLpPositionFusionInstruction(authority, positio
   const lowerTickArrayAddress = await FusionUtils.getTickArrayAddressFromTickIndex(fusionPool, args.tickLowerIndex);
   const upperTickArrayAddress = await FusionUtils.getTickArrayAddressFromTickIndex(fusionPool, args.tickUpperIndex);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit129.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit129.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit129.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit129.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit129.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit129.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit129.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit129.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit129.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit130.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit130.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit130.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit130.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit130.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit130.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit130.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit130.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit130.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -14016,17 +14023,17 @@ function getOpenAndIncreaseTunaLpPositionFusionInstructionWithEphemeralSigner(in
 // src/txbuilder/openTunaSpotPosition.ts
 var import_fusionamm_client14 = require("@crypticdot/fusionamm-client");
 var import_whirlpools_client13 = require("@orca-so/whirlpools-client");
-var import_kit130 = require("@solana/kit");
+var import_kit131 = require("@solana/kit");
 var import_token_202228 = require("@solana-program/token-2022");
 var import_assert19 = __toESM(require("assert"), 1);
 async function openTunaSpotPositionInstructions(rpc, authority, poolAddress, args) {
-  const poolAccount = await (0, import_kit130.fetchEncodedAccount)(rpc, poolAddress);
+  const poolAccount = await (0, import_kit131.fetchEncodedAccount)(rpc, poolAddress);
   (0, import_assert19.default)(poolAccount.exists, "Pool account not found");
   let pool;
   if (poolAccount.programAddress == import_fusionamm_client14.FUSIONAMM_PROGRAM_ADDRESS) {
-    pool = (0, import_kit130.decodeAccount)(poolAccount, (0, import_fusionamm_client14.getFusionPoolDecoder)());
+    pool = (0, import_kit131.decodeAccount)(poolAccount, (0, import_fusionamm_client14.getFusionPoolDecoder)());
   } else if (poolAccount.programAddress == import_whirlpools_client13.WHIRLPOOL_PROGRAM_ADDRESS) {
-    pool = (0, import_kit130.decodeAccount)(poolAccount, (0, import_whirlpools_client13.getWhirlpoolDecoder)());
+    pool = (0, import_kit131.decodeAccount)(poolAccount, (0, import_whirlpools_client13.getWhirlpoolDecoder)());
   } else {
     throw new Error("Incorrect Fusion or Orca pool account");
   }
@@ -14066,7 +14073,7 @@ async function openTunaSpotPositionInstruction(authority, mintA, mintB, poolAddr
 // src/txbuilder/decreaseTunaLpPositionOrca.ts
 var import_whirlpools_client14 = require("@orca-so/whirlpools-client");
 var import_whirlpools_core5 = require("@orca-so/whirlpools-core");
-var import_kit131 = require("@solana/kit");
+var import_kit132 = require("@solana/kit");
 var import_memo18 = require("@solana-program/memo");
 var import_token_202229 = require("@solana-program/token-2022");
 var import_assert20 = __toESM(require("assert"), 1);
@@ -14088,7 +14095,7 @@ async function decreaseTunaLpPositionOrcaInstructions(rpc, authority, positionMi
   const allMints = [mintA, mintB, ...rewardMints];
   (0, import_assert20.default)(mintA.exists, "Token A account not found");
   (0, import_assert20.default)(mintB.exists, "Token B account not found");
-  (0, import_kit131.assertAccountsExist)(rewardMints);
+  (0, import_kit132.assertAccountsExist)(rewardMints);
   const lowerTickArrayStartIndex = (0, import_whirlpools_core5.getTickArrayStartTickIndex)(
     tunaPosition.data.tickLowerIndex,
     whirlpool.data.tickSpacing
@@ -14200,16 +14207,16 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit131.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit131.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit131.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit131.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit131.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit131.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit131.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit131.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit131.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit131.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit132.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit132.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit132.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit132.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit132.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit132.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit132.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit132.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit132.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit132.AccountRole.WRITABLE }
   ];
   for (const rewardIndex of rewardIndicesToClaim) {
     const rewardInfo = whirlpool.data.rewardInfos[rewardIndex];
@@ -14220,10 +14227,10 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
       mint: rewardMint.address,
       tokenProgram: rewardMint.programAddress
     });
-    remainingAccounts.push({ address: rewardMint.address, role: import_kit131.AccountRole.READONLY });
-    remainingAccounts.push({ address: rewardMint.programAddress, role: import_kit131.AccountRole.READONLY });
-    remainingAccounts.push({ address: ownerAta[0], role: import_kit131.AccountRole.WRITABLE });
-    remainingAccounts.push({ address: rewardInfo.vault, role: import_kit131.AccountRole.WRITABLE });
+    remainingAccounts.push({ address: rewardMint.address, role: import_kit132.AccountRole.READONLY });
+    remainingAccounts.push({ address: rewardMint.programAddress, role: import_kit132.AccountRole.READONLY });
+    remainingAccounts.push({ address: ownerAta[0], role: import_kit132.AccountRole.WRITABLE });
+    remainingAccounts.push({ address: rewardInfo.vault, role: import_kit132.AccountRole.WRITABLE });
   }
   const remainingAccountsInfo = {
     slices: [
@@ -14271,7 +14278,7 @@ async function decreaseTunaLpPositionOrcaInstruction(authority, tunaPosition, mi
 
 // src/txbuilder/decreaseTunaLpPositionFusion.ts
 var import_fusionamm_client15 = require("@crypticdot/fusionamm-client");
-var import_kit132 = require("@solana/kit");
+var import_kit133 = require("@solana/kit");
 var import_memo19 = require("@solana-program/memo");
 var import_token_202230 = require("@solana-program/token-2022");
 var import_assert21 = __toESM(require("assert"), 1);
@@ -14371,15 +14378,15 @@ async function decreaseTunaLpPositionFusionInstruction(authority, tunaPosition,
     tunaPosition.data.tickUpperIndex
   );
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit132.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit132.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit132.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit132.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit132.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit132.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit132.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit132.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit132.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit133.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit133.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit133.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit133.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit133.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit133.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit133.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit133.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit133.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -14591,7 +14598,7 @@ async function withdrawInstruction(authority, mint, vault, funds, shares) {
 // src/txbuilder/createMarketLookupTable.ts
 var import_fusionamm_client16 = require("@crypticdot/fusionamm-client");
 var import_whirlpools_client15 = require("@orca-so/whirlpools-client");
-var import_kit133 = require("@solana/kit");
+var import_kit134 = require("@solana/kit");
 var import_address_lookup_table2 = require("@solana-program/address-lookup-table");
 var import_memo22 = require("@solana-program/memo");
 var import_system2 = require("@solana-program/system");
@@ -14631,7 +14638,7 @@ async function getAddressesForMarketLookupTable(rpc, poolAddress, marketMaker) {
   }))[0];
   const addresses = [
     import_system2.SYSTEM_PROGRAM_ADDRESS,
-    (0, import_kit133.address)("SysvarRent111111111111111111111111111111111"),
+    (0, import_kit134.address)("SysvarRent111111111111111111111111111111111"),
     import_token_202234.ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
     import_token2.TOKEN_PROGRAM_ADDRESS,
     import_token_202234.TOKEN_2022_PROGRAM_ADDRESS,
@@ -14791,7 +14798,7 @@ async function repayTunaLpPositionDebtInstruction(authority, positionMint, mintA
 
 // src/txbuilder/rebalanceTunaLpPositionOrca.ts
 var import_whirlpools_client16 = require("@orca-so/whirlpools-client");
-var import_kit134 = require("@solana/kit");
+var import_kit135 = require("@solana/kit");
 var import_sysvars3 = require("@solana/sysvars");
 var import_memo24 = require("@solana-program/memo");
 var import_token_202236 = require("@solana-program/token-2022");
@@ -14874,7 +14881,7 @@ async function rebalanceTunaLpPositionOrcaInstructions(rpc, authority, positionM
   cleanupInstructions.push(...internalCleanupInstructions);
   return {
     instructions,
-    initializationCost: (0, import_kit134.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit135.lamports)(nonRefundableRent)
   };
 }
 async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, whirlpool) {
@@ -14918,18 +14925,18 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
   );
   const secondaryTickArrays = await OrcaUtils.getTickArraysForRebalancedPosition(whirlpool, tunaPosition);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit134.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit134.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit134.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit134.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit134.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit134.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit134.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit134.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit134.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultA, role: import_kit134.AccountRole.WRITABLE },
-    { address: whirlpool.data.tokenVaultB, role: import_kit134.AccountRole.WRITABLE },
-    { address: orcaOracleAddress, role: import_kit134.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit135.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit135.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit135.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit135.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit135.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultA, role: import_kit135.AccountRole.WRITABLE },
+    { address: whirlpool.data.tokenVaultB, role: import_kit135.AccountRole.WRITABLE },
+    { address: orcaOracleAddress, role: import_kit135.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [
@@ -14973,7 +14980,7 @@ async function rebalanceTunaLpPositionOrcaInstruction(authority, tunaPosition, t
 
 // src/txbuilder/rebalanceTunaLpPositionFusion.ts
 var import_fusionamm_client17 = require("@crypticdot/fusionamm-client");
-var import_kit135 = require("@solana/kit");
+var import_kit136 = require("@solana/kit");
 var import_sysvars4 = require("@solana/sysvars");
 var import_memo25 = require("@solana-program/memo");
 var import_token_202237 = require("@solana-program/token-2022");
@@ -15052,7 +15059,7 @@ async function rebalanceTunaLpPositionFusionInstructions(rpc, authority, positio
   instructions.push(ix);
   return {
     instructions,
-    initializationCost: (0, import_kit135.lamports)(nonRefundableRent)
+    initializationCost: (0, import_kit136.lamports)(nonRefundableRent)
   };
 }
 async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition, tunaConfig, mintA, mintB, vaultA, vaultB, fusionPool) {
@@ -15095,17 +15102,17 @@ async function rebalanceTunaLpPositionFusionInstruction(authority, tunaPosition,
   );
   const secondaryTickArrays = await FusionUtils.getTickArraysForRebalancedPosition(fusionPool, tunaPosition);
   const remainingAccounts = [
-    { address: swapTickArrays[0], role: import_kit135.AccountRole.WRITABLE },
-    { address: swapTickArrays[1], role: import_kit135.AccountRole.WRITABLE },
-    { address: swapTickArrays[2], role: import_kit135.AccountRole.WRITABLE },
-    { address: swapTickArrays[3], role: import_kit135.AccountRole.WRITABLE },
-    { address: swapTickArrays[4], role: import_kit135.AccountRole.WRITABLE },
-    { address: lowerTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
-    { address: upperTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
-    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit135.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultA, role: import_kit135.AccountRole.WRITABLE },
-    { address: fusionPool.data.tokenVaultB, role: import_kit135.AccountRole.WRITABLE }
+    { address: swapTickArrays[0], role: import_kit136.AccountRole.WRITABLE },
+    { address: swapTickArrays[1], role: import_kit136.AccountRole.WRITABLE },
+    { address: swapTickArrays[2], role: import_kit136.AccountRole.WRITABLE },
+    { address: swapTickArrays[3], role: import_kit136.AccountRole.WRITABLE },
+    { address: swapTickArrays[4], role: import_kit136.AccountRole.WRITABLE },
+    { address: lowerTickArrayAddress, role: import_kit136.AccountRole.WRITABLE },
+    { address: upperTickArrayAddress, role: import_kit136.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.lowerTickArrayAddress, role: import_kit136.AccountRole.WRITABLE },
+    { address: secondaryTickArrays.upperTickArrayAddress, role: import_kit136.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultA, role: import_kit136.AccountRole.WRITABLE },
+    { address: fusionPool.data.tokenVaultB, role: import_kit136.AccountRole.WRITABLE }
   ];
   const remainingAccountsInfo = {
     slices: [