@meteora-ag/zap-sdk 2.0.0-rc.0 → 2.0.0

package/dist/index.js

@@ -76,18 +76,12 @@ __export(index_exports, {
   DAMM_V2_SWAP_DISCRIMINATOR: () => DAMM_V2_SWAP_DISCRIMINATOR,
   DEFAULT_JUPITER_API_URL: () => DEFAULT_JUPITER_API_URL,
   DEFAULT_JUPITER_API_VERSION: () => DEFAULT_JUPITER_API_VERSION,
-  DEFAULT_JUPITER_QUOTE_OPTIONS: () => DEFAULT_JUPITER_QUOTE_OPTIONS,
   DLMM_PROGRAM_ID: () => DLMM_PROGRAM_ID,
   DLMM_SWAP_DISCRIMINATOR: () => DLMM_SWAP_DISCRIMINATOR,
   DlmmDirectSwapQuoteRoute: () => DlmmDirectSwapQuoteRoute,
   DlmmSingleSided: () => DlmmSingleSided,
   DlmmSwapType: () => DlmmSwapType,
-  JUPITER_INSTRUCTION_LAYOUTS: () => JUPITER_INSTRUCTION_LAYOUTS,
   JUP_V6_PROGRAM_ID: () => JUP_V6_PROGRAM_ID,
-  JUP_V6_ROUTE_DISCRIMINATOR: () => JUP_V6_ROUTE_DISCRIMINATOR,
-  JUP_V6_ROUTE_V2_DISCRIMINATOR: () => JUP_V6_ROUTE_V2_DISCRIMINATOR,
-  JUP_V6_SHARED_ACCOUNTS_ROUTE_DISCRIMINATOR: () => JUP_V6_SHARED_ACCOUNTS_ROUTE_DISCRIMINATOR,
-  JUP_V6_SHARED_ACCOUNTS_ROUTE_V2_DISCRIMINATOR: () => JUP_V6_SHARED_ACCOUNTS_ROUTE_V2_DISCRIMINATOR,
   JupiterApiVersion: () => JupiterApiVersion,
   MEMO_PROGRAM_ID: () => MEMO_PROGRAM_ID,
   SwapExternalType: () => SwapExternalType,
@@ -108,17 +102,13 @@ __export(index_exports, {
   estimateDlmmDirectSwap: () => estimateDlmmDirectSwap,
   estimateDlmmIndirectSwap: () => estimateDlmmIndirectSwap,
   estimateDlmmRebalanceSwap: () => estimateDlmmRebalanceSwap,
-  fetchAddressLookupTableAccounts: () => fetchAddressLookupTableAccounts,
   filterOutCloseSplTokenAccountInstructions: () => filterOutCloseSplTokenAccountInstructions,
-  filterOutComputeBudgetInstructions: () => filterOutComputeBudgetInstructions,
   getBinArrayBitmapExtension: () => getBinArrayBitmapExtension,
   getBitFromBinArrayIndexInBitmapExtension: () => getBitFromBinArrayIndexInBitmapExtension,
   getDammV2Pool: () => getDammV2Pool,
   getDammV2RemainingAccounts: () => getDammV2RemainingAccounts,
   getDlmmRemainingAccounts: () => getDlmmRemainingAccounts,
   getExtraAccountMetasForTransferHook: () => getExtraAccountMetasForTransferHook,
-  getJupiterAddressLookupTableAccounts: () => getJupiterAddressLookupTableAccounts,
-  getJupiterInstructionLayout: () => getJupiterInstructionLayout,
   getJupiterQuote: () => getJupiterQuote,
   getJupiterSwapInstruction: () => getJupiterSwapInstruction,
   getLbPairState: () => getLbPairState,
@@ -126,13 +116,8 @@ __export(index_exports, {
   getOrCreateATAInstruction: () => getOrCreateATAInstruction,
   getTokenAccountBalance: () => getTokenAccountBalance,
   getTokenProgramFromMint: () => getTokenProgramFromMint,
-  isJupiterBuildResponse: () => isJupiterBuildResponse,
-  isJupiterSwapInstructionForUser: () => isJupiterSwapInstructionForUser,
   isSingleSidedA: () => isSingleSidedA,
   isSingleSidedB: () => isSingleSidedB,
-  mergeAddressLookupTableAccounts: () => mergeAddressLookupTableAccounts,
-  resolveJupiterConfig: () => resolveJupiterConfig,
-  toAddressLookupTableAccounts: () => toAddressLookupTableAccounts,
   toProgramStrategyType: () => toProgramStrategyType,
   unwrapSOLInstruction: () => unwrapSOLInstruction,
   wrapSOLInstruction: () => wrapSOLInstruction
@@ -2007,7 +1992,7 @@ var DlmmSingleSided = /* @__PURE__ */ ((DlmmSingleSided2) => {
 })(DlmmSingleSided || {});
 
 // src/helpers/jupiter.ts
-var import_web32 = require("@solana/web3.js");
+var import_web33 = require("@solana/web3.js");
 
 // src/constants.ts
 var import_web3 = require("@solana/web3.js");
@@ -2123,20 +2108,124 @@ var DAMM_V2_SWAP_DISCRIMINATOR = [
 ];
 var DEFAULT_JUPITER_API_URL = "https://api.jup.ag";
 var DEFAULT_JUPITER_API_VERSION = "v2" /* V2 */;
-var DEFAULT_JUPITER_QUOTE_OPTIONS = {
-  dynamicSlippage: false,
-  onlyDirectRoutes: true,
-  restrictIntermediateTokens: true,
-  forJitoBundle: true
-};
+
+// src/helpers/token.ts
+var import_spl_token = require("@solana/spl-token");
+var import_web32 = require("@solana/web3.js");
+var getOrCreateATAInstruction = (_connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
+  const toAccount = (0, import_spl_token.getAssociatedTokenAddressSync)(
+    tokenMint,
+    owner,
+    allowOwnerOffCurve,
+    tokenProgram
+  );
+  const ix = (0, import_spl_token.createAssociatedTokenAccountIdempotentInstruction)(
+    payer,
+    toAccount,
+    owner,
+    tokenMint,
+    tokenProgram
+  );
+  return { ataPubkey: toAccount, ix };
+});
+function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
+  const wSolATAAccount = (0, import_spl_token.getAssociatedTokenAddressSync)(
+    import_spl_token.NATIVE_MINT,
+    owner,
+    allowOwnerOffCurve
+  );
+  if (wSolATAAccount) {
+    const closedWrappedSolInstruction = (0, import_spl_token.createCloseAccountInstruction)(
+      wSolATAAccount,
+      receiver,
+      owner,
+      [],
+      import_spl_token.TOKEN_PROGRAM_ID
+    );
+    return closedWrappedSolInstruction;
+  }
+  return null;
+}
+function getTokenAccountBalance(connection, tokenAccount) {
+  return __async(this, null, function* () {
+    let balance;
+    try {
+      balance = (yield connection.getTokenAccountBalance(tokenAccount)).value.amount;
+    } catch (e) {
+      balance = "0";
+    }
+    return balance;
+  });
+}
+function wrapSOLInstruction(from, to, amount, tokenProgram = import_spl_token.TOKEN_PROGRAM_ID) {
+  return [
+    import_web32.SystemProgram.transfer({
+      fromPubkey: from,
+      toPubkey: to,
+      lamports: amount
+    }),
+    new import_web32.TransactionInstruction({
+      keys: [
+        {
+          pubkey: to,
+          isSigner: false,
+          isWritable: true
+        }
+      ],
+      data: Buffer.from(new Uint8Array([17])),
+      programId: tokenProgram
+    })
+  ];
+}
+var CLOSE_ACCOUNT_DISCRIMINATOR = 9;
+function filterOutCloseSplTokenAccountInstructions(instructions) {
+  return instructions.filter((ix) => {
+    if (ix.programId.equals(import_spl_token.TOKEN_PROGRAM_ID)) {
+      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
+    }
+    return true;
+  });
+}
+function getCreateAtaInstructions(user, tokens) {
+  const tokenAccounts = tokens.map(
+    ({ mint, tokenProgram }) => (0, import_spl_token.getAssociatedTokenAddressSync)(mint, user, true, tokenProgram)
+  );
+  const instructions = tokens.map(
+    ({ mint, tokenProgram }, i) => (0, import_spl_token.createAssociatedTokenAccountIdempotentInstruction)(
+      user,
+      tokenAccounts[i],
+      user,
+      mint,
+      tokenProgram
+    )
+  );
+  return { tokenAccounts, instructions };
+}
+function isCreateAtaInstruction(ix) {
+  return ix.programId.equals(import_spl_token.ASSOCIATED_TOKEN_PROGRAM_ID) && (ix.data.length === 0 || ix.data[0] === 0 || ix.data[0] === 1);
+}
+function dedupeCreateAtaInstructions(instructions) {
+  const createdAccounts = /* @__PURE__ */ new Set();
+  return instructions.filter((ix) => {
+    if (!isCreateAtaInstruction(ix)) {
+      return true;
+    }
+    const account = ix.keys[1].pubkey.toBase58();
+    if (createdAccounts.has(account)) {
+      return false;
+    }
+    createdAccounts.add(account);
+    return true;
+  });
+}
 
 // src/helpers/jupiter.ts
-function resolveJupiterConfig(config = {}) {
+function resolveJupiterConfig(config) {
   var _a;
   return {
-    url: config.jupiterApiUrl || DEFAULT_JUPITER_API_URL,
-    apiKey: config.jupiterApiKey || "",
-    version: (_a = config.jupiterApiVersion) != null ? _a : DEFAULT_JUPITER_API_VERSION
+    url: (config == null ? void 0 : config.jupiterApiUrl) || DEFAULT_JUPITER_API_URL,
+    apiKey: (config == null ? void 0 : config.jupiterApiKey) || "",
+    version: (_a = config == null ? void 0 : config.jupiterApiVersion) != null ? _a : DEFAULT_JUPITER_API_VERSION
   };
 }
 function getJupiterInstructionLayout(data) {
@@ -2157,37 +2246,28 @@ function isJupiterSwapInstructionForUser(swapInstruction, user) {
     Buffer.from(swapInstruction.data, "base64")
   );
   const authority = swapInstruction.accounts[layout.userTransferAuthorityIndex];
-  return authority !== void 0 && new import_web32.PublicKey(authority.pubkey).equals(user);
+  return authority !== void 0 && new import_web33.PublicKey(authority.pubkey).equals(user);
 }
 function jupiterHeaders(apiKey, json) {
   return __spreadValues(__spreadValues({
     Accept: "application/json"
   }, json ? { "Content-Type": "application/json" } : {}), apiKey ? { "x-api-key": apiKey } : {});
 }
-function toSearchParams(query) {
+function toSearchParams(params) {
   var _a;
-  const params = new URLSearchParams(__spreadProps(__spreadValues({
-    inputMint: query.inputMint.toString(),
-    outputMint: query.outputMint.toString(),
-    amount: query.amount,
-    slippageBps: query.slippageBps.toString()
-  }, query.maxAccounts !== void 0 ? { maxAccounts: query.maxAccounts.toString() } : {}), {
-    onlyDirectRoutes: query.onlyDirectRoutes.toString(),
-    restrictIntermediateTokens: query.restrictIntermediateTokens.toString(),
-    dynamicSlippage: query.dynamicSlippage.toString(),
-    forJitoBundle: query.forJitoBundle.toString()
-  }));
-  for (const [name, value] of Object.entries(
-    (_a = query.additionalQueryParams) != null ? _a : {}
-  )) {
-    params.set(name, value);
+  const searchParams = new URLSearchParams();
+  for (const [name, value] of Object.entries((_a = params.queryParams) != null ? _a : {})) {
+    searchParams.set(name, value.toString());
   }
-  return params;
+  searchParams.set("inputMint", params.inputMint.toString());
+  searchParams.set("outputMint", params.outputMint.toString());
+  searchParams.set("amount", params.amount.toString());
+  return searchParams;
 }
-function fetchJupiterQuoteV1(query, config) {
+function fetchJupiterQuoteV1(params, config) {
   return __async(this, null, function* () {
     const { url: baseUrl, apiKey } = resolveJupiterConfig(config);
-    const url = `${baseUrl}/swap/v1/quote?${toSearchParams(query).toString()}`;
+    const url = `${baseUrl}/swap/v1/quote?${toSearchParams(params).toString()}`;
     try {
       const response = yield fetch(url, {
         method: "GET",
@@ -2202,12 +2282,12 @@ function fetchJupiterQuoteV1(query, config) {
     }
   });
 }
-function fetchJupiterBuildV2(query, taker, config) {
+function fetchJupiterBuildV2(params, config) {
   return __async(this, null, function* () {
     const { url: baseUrl, apiKey } = resolveJupiterConfig(config);
-    const params = toSearchParams(query);
-    params.set("taker", taker.toString());
-    const url = `${baseUrl}/swap/v2/build?${params.toString()}`;
+    const searchParams = toSearchParams(params);
+    searchParams.set("taker", params.user.toString());
+    const url = `${baseUrl}/swap/v2/build?${searchParams.toString()}`;
     try {
       const response = yield fetch(url, {
         method: "GET",
@@ -2222,26 +2302,13 @@ function fetchJupiterBuildV2(query, taker, config) {
     }
   });
 }
-function getJupiterQuote(_0) {
-  return __async(this, arguments, function* (params, config = {}) {
-    var _a, _b, _c, _d;
-    const query = {
-      inputMint: params.inputMint,
-      outputMint: params.outputMint,
-      amount: params.amount.toString(),
-      slippageBps: params.slippageBps,
-      maxAccounts: params.maxAccounts,
-      dynamicSlippage: (_a = params.dynamicSlippage) != null ? _a : DEFAULT_JUPITER_QUOTE_OPTIONS.dynamicSlippage,
-      onlyDirectRoutes: (_b = params.onlyDirectRoutes) != null ? _b : DEFAULT_JUPITER_QUOTE_OPTIONS.onlyDirectRoutes,
-      restrictIntermediateTokens: (_c = params.restrictIntermediateTokens) != null ? _c : DEFAULT_JUPITER_QUOTE_OPTIONS.restrictIntermediateTokens,
-      forJitoBundle: (_d = params.forJitoBundle) != null ? _d : DEFAULT_JUPITER_QUOTE_OPTIONS.forJitoBundle,
-      additionalQueryParams: params.additionalQueryParams
-    };
+function getJupiterQuote(params, config) {
+  return __async(this, null, function* () {
     const { version } = resolveJupiterConfig(config);
     if (version === "v1" /* V1 */) {
-      return fetchJupiterQuoteV1(query, config);
+      return fetchJupiterQuoteV1(params, config);
     }
-    return fetchJupiterBuildV2(query, params.user, config);
+    return fetchJupiterBuildV2(params, config);
   });
 }
 function fetchJupiterSwapInstructionV1(userPublicKey, quoteResponse, config) {
@@ -2271,8 +2338,8 @@ function fetchJupiterSwapInstructionV1(userPublicKey, quoteResponse, config) {
     return yield response.json();
   });
 }
-function getJupiterSwapInstruction(_0, _1) {
-  return __async(this, arguments, function* (userPublicKey, quoteResponse, config = {}) {
+function getJupiterSwapInstruction(userPublicKey, quoteResponse, config) {
+  return __async(this, null, function* () {
     const { version } = resolveJupiterConfig(config);
     if (version === "v1" /* V1 */) {
       return fetchJupiterSwapInstructionV1(userPublicKey, quoteResponse, config);
@@ -2305,10 +2372,10 @@ function isQuoteMatchesSwap(quoteResponse, user, amount) {
 var ACTIVE_LOOKUP_TABLE_DEACTIVATION_SLOT = BigInt("0xffffffffffffffff");
 function toAddressLookupTableAccounts(addressesByLookupTableAddress) {
   return Object.entries(addressesByLookupTableAddress != null ? addressesByLookupTableAddress : {}).map(
-    ([key, addresses]) => new import_web32.AddressLookupTableAccount({
-      key: new import_web32.PublicKey(key),
+    ([key, addresses]) => new import_web33.AddressLookupTableAccount({
+      key: new import_web33.PublicKey(key),
       state: {
-        addresses: addresses.map((address) => new import_web32.PublicKey(address)),
+        addresses: addresses.map((address) => new import_web33.PublicKey(address)),
         deactivationSlot: ACTIVE_LOOKUP_TABLE_DEACTIVATION_SLOT,
         lastExtendedSlot: 0,
         lastExtendedSlotStartIndex: 0
@@ -2321,16 +2388,16 @@ function fetchAddressLookupTableAccounts(connection, addresses) {
     if (addresses.length === 0) {
       return [];
     }
-    const keys = addresses.map((address) => new import_web32.PublicKey(address));
+    const keys = addresses.map((address) => new import_web33.PublicKey(address));
     const accounts = yield connection.getMultipleAccountsInfo(keys);
     return keys.map((key, i) => {
       const account = accounts[i];
-      if (!account || !account.owner.equals(import_web32.AddressLookupTableProgram.programId)) {
+      if (!account || !account.owner.equals(import_web33.AddressLookupTableProgram.programId)) {
         throw new Error(`Address lookup table not found: ${key.toBase58()}`);
       }
-      return new import_web32.AddressLookupTableAccount({
+      return new import_web33.AddressLookupTableAccount({
         key,
-        state: import_web32.AddressLookupTableAccount.deserialize(account.data)
+        state: import_web33.AddressLookupTableAccount.deserialize(account.data)
       });
     });
   });
@@ -2357,22 +2424,35 @@ function getJupiterAddressLookupTableAccounts(connection, response) {
     );
   });
 }
-function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6, _7) {
-  return __async(this, arguments, function* (connection, user, inputMint, outputMint, amount, maxAccounts, slippageBps, jupiterQuoteResponse, config = {}, jupiterQuoteOptions = {}) {
+function toTransactionInstruction(instruction) {
+  return new import_web33.TransactionInstruction({
+    keys: instruction.accounts.map((item) => ({
+      pubkey: new import_web33.PublicKey(item.pubkey),
+      isSigner: item.isSigner,
+      isWritable: item.isWritable
+    })),
+    programId: new import_web33.PublicKey(instruction.programId),
+    data: Buffer.from(instruction.data, "base64")
+  });
+}
+function getJupiterCreateAtaInstructions(setupInstructions) {
+  return setupInstructions.filter(isCreateAtaInstruction);
+}
+function buildJupiterSwapTransaction(connection, user, inputMint, outputMint, amount, slippageBps, jupiterQuoteResponse, config, jupiterQuoteOptions) {
+  return __async(this, null, function* () {
     if (jupiterQuoteResponse && !isQuoteMatchesSwap(jupiterQuoteResponse, user, amount)) {
       throw new Error(
         `Jupiter quote does not match the swap of ${amount.toString()} by ${user.toBase58()} (quoted inAmount ${jupiterQuoteResponse.inAmount})`
       );
     }
     const quoteResponse = jupiterQuoteResponse != null ? jupiterQuoteResponse : yield getJupiterQuote(
-      __spreadValues({
+      {
         inputMint,
         outputMint,
         amount,
         user,
-        maxAccounts,
-        slippageBps
-      }, jupiterQuoteOptions),
+        queryParams: __spreadValues({ slippageBps }, jupiterQuoteOptions)
+      },
       config
     );
     if (!quoteResponse) {
@@ -2385,51 +2465,51 @@ function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6, _7) {
       quoteResponse,
       config
     );
-    const instruction = new import_web32.TransactionInstruction({
-      keys: swapInstructionResponse.swapInstruction.accounts.map((item) => {
-        return {
-          pubkey: new import_web32.PublicKey(item.pubkey),
-          isSigner: item.isSigner,
-          isWritable: item.isWritable
-        };
-      }),
-      programId: new import_web32.PublicKey(swapInstructionResponse.swapInstruction.programId),
-      data: Buffer.from(swapInstructionResponse.swapInstruction.data, "base64")
-    });
+    const instruction = toTransactionInstruction(
+      swapInstructionResponse.swapInstruction
+    );
+    const setupInstructions = swapInstructionResponse.setupInstructions.map(
+      toTransactionInstruction
+    );
     const addressLookupTableAccounts = yield getJupiterAddressLookupTableAccounts(
       connection,
       swapInstructionResponse
     );
-    return { instruction, addressLookupTableAccounts, quoteResponse };
+    return {
+      instruction,
+      setupInstructions,
+      addressLookupTableAccounts,
+      quoteResponse
+    };
   });
 }
 
 // src/helpers/dammV2.ts
-var import_spl_token = require("@solana/spl-token");
+var import_spl_token2 = require("@solana/spl-token");
 var import_cp_amm_sdk = require("@meteora-ag/cp-amm-sdk");
 
 // src/helpers/pda.ts
-var import_web33 = require("@solana/web3.js");
+var import_web34 = require("@solana/web3.js");
 function deriveDammV2EventAuthority() {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveDammV2PoolAuthority() {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("pool_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveLedgerAccount(owner) {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("user_ledger"), owner.toBuffer()],
     ZAP_PROGRAM_ID
   )[0];
 }
 function deriveDlmmEventAuthority() {
-  return import_web33.PublicKey.findProgramAddressSync(
+  return import_web34.PublicKey.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DLMM_PROGRAM_ID
   )[0];
@@ -2443,7 +2523,7 @@ function getDammV2Pool(connection, poolAddress) {
   });
 }
 function getDammV2RemainingAccounts(_0, _1, _2, _3) {
-  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = import_spl_token.TOKEN_PROGRAM_ID, tokenBProgram = import_spl_token.TOKEN_PROGRAM_ID, poolState) {
+  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = import_spl_token2.TOKEN_PROGRAM_ID, tokenBProgram = import_spl_token2.TOKEN_PROGRAM_ID, poolState) {
     const remainingAccounts = [
       {
         isSigner: false,
@@ -2534,13 +2614,13 @@ function createDammV2SwapPayload(amountIn, minimumSwapAmountOut) {
 }
 
 // src/helpers/common.ts
-var import_spl_token2 = require("@solana/spl-token");
-var import_web34 = require("@solana/web3.js");
+var import_spl_token3 = require("@solana/spl-token");
+var import_web35 = require("@solana/web3.js");
 var import_decimal = __toESM(require("decimal.js"));
 function getTokenProgramFromMint(connection, mint) {
   return __async(this, null, function* () {
-    if (mint.equals(import_spl_token2.NATIVE_MINT)) {
-      return import_spl_token2.TOKEN_PROGRAM_ID;
+    if (mint.equals(import_spl_token3.NATIVE_MINT)) {
+      return import_spl_token3.TOKEN_PROGRAM_ID;
     }
     try {
       const mintInfo = yield connection.getAccountInfo(mint);
@@ -2548,18 +2628,18 @@ function getTokenProgramFromMint(connection, mint) {
         throw new Error(`Mint account not found: ${mint.toString()}`);
       }
       if (mintInfo.owner.equals(
-        new import_web34.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
+        new import_web35.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
       )) {
-        return new import_web34.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+        return new import_web35.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
       } else {
-        return import_spl_token2.TOKEN_PROGRAM_ID;
+        return import_spl_token3.TOKEN_PROGRAM_ID;
       }
     } catch (error) {
       console.warn(
         `Failed to determine token program for ${mint.toString()}, defaulting to TOKEN_PROGRAM_ID:`,
         error
       );
-      return import_spl_token2.TOKEN_PROGRAM_ID;
+      return import_spl_token3.TOKEN_PROGRAM_ID;
     }
   });
 }
@@ -2571,86 +2651,8 @@ function convertUiAmountToLamports(amount, decimals) {
 }
 function filterOutComputeBudgetInstructions(instructions) {
   return instructions.filter(
-    (ix) => !ix.programId.equals(import_web34.ComputeBudgetProgram.programId)
-  );
-}
-
-// src/helpers/token.ts
-var import_spl_token3 = require("@solana/spl-token");
-var import_web35 = require("@solana/web3.js");
-var getOrCreateATAInstruction = (_connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
-  const toAccount = (0, import_spl_token3.getAssociatedTokenAddressSync)(
-    tokenMint,
-    owner,
-    allowOwnerOffCurve,
-    tokenProgram
+    (ix) => !ix.programId.equals(import_web35.ComputeBudgetProgram.programId)
   );
-  const ix = (0, import_spl_token3.createAssociatedTokenAccountIdempotentInstruction)(
-    payer,
-    toAccount,
-    owner,
-    tokenMint,
-    tokenProgram
-  );
-  return { ataPubkey: toAccount, ix };
-});
-function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
-  const wSolATAAccount = (0, import_spl_token3.getAssociatedTokenAddressSync)(
-    import_spl_token3.NATIVE_MINT,
-    owner,
-    allowOwnerOffCurve
-  );
-  if (wSolATAAccount) {
-    const closedWrappedSolInstruction = (0, import_spl_token3.createCloseAccountInstruction)(
-      wSolATAAccount,
-      receiver,
-      owner,
-      [],
-      import_spl_token3.TOKEN_PROGRAM_ID
-    );
-    return closedWrappedSolInstruction;
-  }
-  return null;
-}
-function getTokenAccountBalance(connection, tokenAccount) {
-  return __async(this, null, function* () {
-    let balance;
-    try {
-      balance = (yield connection.getTokenAccountBalance(tokenAccount)).value.amount;
-    } catch (e) {
-      balance = "0";
-    }
-    return balance;
-  });
-}
-function wrapSOLInstruction(from, to, amount, tokenProgram = import_spl_token3.TOKEN_PROGRAM_ID) {
-  return [
-    import_web35.SystemProgram.transfer({
-      fromPubkey: from,
-      toPubkey: to,
-      lamports: amount
-    }),
-    new import_web35.TransactionInstruction({
-      keys: [
-        {
-          pubkey: to,
-          isSigner: false,
-          isWritable: true
-        }
-      ],
-      data: Buffer.from(new Uint8Array([17])),
-      programId: tokenProgram
-    })
-  ];
-}
-var CLOSE_ACCOUNT_DISCRIMINATOR = 9;
-function filterOutCloseSplTokenAccountInstructions(instructions) {
-  return instructions.filter((ix) => {
-    if (ix.programId.equals(import_spl_token3.TOKEN_PROGRAM_ID)) {
-      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
-    }
-    return true;
-  });
 }
 
 // src/helpers/dlmm.ts
@@ -3014,8 +3016,8 @@ function estimateSwapOutput(inAmount, effectiveRate) {
   const estimatedOutput = inAmountDecimal.mul(effectiveRate);
   return new import_bn3.default(estimatedOutput.floor().toString());
 }
-function getBestSwapQuoteJupiterDlmm(_0, _1, _2, _3, _4, _5, _6, _7) {
-  return __async(this, arguments, function* (dlmm, user, inMint, outMint, inAmount, swapSlippageBps, swapForY, binArrays, config = {}, jupiterQuoteOptions = {}) {
+function getBestSwapQuoteJupiterDlmm(dlmm, user, inMint, outMint, inAmount, swapSlippageBps, swapForY, binArrays, config, jupiterQuoteOptions) {
+  return __async(this, null, function* () {
     let dlmmQuoteResult = null;
     try {
       dlmmQuoteResult = dlmm.swapQuote(
@@ -3028,14 +3030,15 @@ function getBestSwapQuoteJupiterDlmm(_0, _1, _2, _3, _4, _5, _6, _7) {
       console.error("Error getting DLMM quote, using jupiter quote only:", error);
     }
     const jupiterQuoteResult = yield getJupiterQuote(
-      __spreadValues({
+      {
         inputMint: inMint,
         outputMint: outMint,
         amount: inAmount,
         user,
-        maxAccounts: 50,
-        slippageBps: swapSlippageBps
-      }, jupiterQuoteOptions),
+        queryParams: __spreadValues({
+          slippageBps: swapSlippageBps
+        }, jupiterQuoteOptions)
+      },
       config
     );
     const jupiterQuote = jupiterQuoteResult ? {
@@ -3162,7 +3165,7 @@ function estimateDlmmIndirectSwap(_0) {
     strategy,
     singleSided,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     const dlmm = yield import_dlmm3.default.create(connection, lbPair);
     const activeBin = yield dlmm.getActiveBin();
@@ -3186,14 +3189,15 @@ function estimateDlmmIndirectSwap(_0) {
       const singleSidedX = singleSided === 0 /* X */;
       const outputTokenMint = singleSidedX ? tokenXMint : tokenYMint;
       const quote = yield getJupiterQuote(
-        __spreadValues({
+        {
           inputMint: inputTokenMint,
           outputMint: outputTokenMint,
           amount: amountIn,
           user,
-          maxAccounts: 50,
-          slippageBps: swapSlippageBps
-        }, jupiterQuoteOptions),
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       );
       if (!quote) {
@@ -3216,25 +3220,27 @@ function estimateDlmmIndirectSwap(_0) {
     const halfAmount = amountIn.div(new import_bn3.default(2));
     const [quoteToXResult, quoteToYResult] = yield Promise.allSettled([
       getJupiterQuote(
-        __spreadValues({
+        {
           inputMint: inputTokenMint,
           outputMint: tokenXMint,
           amount: halfAmount,
           user,
-          maxAccounts: 50,
-          slippageBps: swapSlippageBps
-        }, jupiterQuoteOptions),
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       ),
       getJupiterQuote(
-        __spreadValues({
+        {
           inputMint: inputTokenMint,
           outputMint: tokenYMint,
           amount: halfAmount,
           user,
-          maxAccounts: 50,
-          slippageBps: swapSlippageBps
-        }, jupiterQuoteOptions),
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       )
     ]);
@@ -3330,25 +3336,27 @@ function estimateDlmmIndirectSwap(_0) {
     }
     const [finalQuoteToXResult, finalQuoteToYResult] = yield Promise.allSettled([
       getJupiterQuote(
-        __spreadValues({
+        {
           inputMint: inputTokenMint,
           outputMint: tokenXMint,
           amount: bestAmountToX,
           user,
-          maxAccounts: 50,
-          slippageBps: swapSlippageBps
-        }, jupiterQuoteOptions),
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       ),
       getJupiterQuote(
-        __spreadValues({
+        {
           inputMint: inputTokenMint,
           outputMint: tokenYMint,
           amount: bestAmountToY,
           user,
-          maxAccounts: 50,
-          slippageBps: swapSlippageBps
-        }, jupiterQuoteOptions),
+          queryParams: __spreadValues({
+            slippageBps: swapSlippageBps
+          }, jupiterQuoteOptions)
+        },
         config
       )
     ]);
@@ -3394,7 +3402,7 @@ function estimateDlmmDirectSwapCore(_0) {
     strategy,
     singleSided,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     if (singleSided !== void 0) {
       const singleSidedX = singleSided === 0 /* X */;
@@ -3639,7 +3647,7 @@ function estimateDlmmDirectSwap(_0) {
     strategy,
     singleSided,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     const dlmm = yield import_dlmm3.default.create(connection, lbPair);
     (0, import_invariant.default)(
@@ -3688,7 +3696,7 @@ function estimateDlmmRebalanceSwap(_0) {
     maxDeltaId,
     strategy,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     const dlmm = yield import_dlmm3.default.create(connection, lbPair);
     const userPosition = yield dlmm.getPosition(position);
@@ -3773,13 +3781,13 @@ var Zap = class {
    * @param connection - The connection to the Solana cluster
    * @param config - Optional configuration for Jupiter API URL (default: https://api.jup.ag), API key (default: empty string) and API version (default: JupiterApiVersion.V2)
    */
-  constructor(connection, config = {}) {
+  constructor(connection, config) {
     var _a;
     this.connection = connection;
     this.zapProgram = new import_core.Program(idl_default, { connection });
-    this.jupiterApiUrl = config.jupiterApiUrl || DEFAULT_JUPITER_API_URL;
-    this.jupiterApiKey = config.jupiterApiKey || "";
-    this.jupiterApiVersion = (_a = config.jupiterApiVersion) != null ? _a : DEFAULT_JUPITER_API_VERSION;
+    this.jupiterApiUrl = (config == null ? void 0 : config.jupiterApiUrl) || DEFAULT_JUPITER_API_URL;
+    this.jupiterApiKey = (config == null ? void 0 : config.jupiterApiKey) || "";
+    this.jupiterApiVersion = (_a = config == null ? void 0 : config.jupiterApiVersion) != null ? _a : DEFAULT_JUPITER_API_VERSION;
   }
   /////// PRIVATE FUNDTIONS //////
   initializeLedgerAccount(owner, payer) {
@@ -4013,13 +4021,12 @@ var Zap = class {
    * @param params.amountIn - The amount of input token
    * @param params.inputTokenMint - The input token mint
    * @param params.positionNftMint - The position NFT mint account's public key
-   * @param params.maxAccounts - The maximum number of accounts for the Jupiter swap query
    * @param params.maxSqrtPriceChangeBps - The maximum sqrt price change in basis points
    * @param params.slippageBps - The swap slippage tolerance in basis points
    * @param params.dammV2Quote - The DAMM V2 swap quote for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.jupiterQuote - The Jupiter swap quote for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
-   * @param params.jupiterQuoteOptions - Optional Jupiter quote options, see `JupiterQuoteOptions`
+   * @param params.jupiterQuoteOptions - Optional Jupiter query parameters, see `GetJupiterQuoteParams.queryParams`
    * @returns The zap-in transaction parameters for a DAMM V2 direct pool
    * @throws if input token mint matches either tokenA or tokenB in the pool
    * @throws if failed to get both Jupiter and DAMM v2 swap quotes
@@ -4033,7 +4040,6 @@ var Zap = class {
         inputTokenMint,
         amountIn,
         positionNftMint,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         slippageBps,
         dammV2Quote,
@@ -4131,7 +4137,6 @@ var Zap = class {
             inputTokenMint,
             outputTokenMint,
             swapInAmount,
-            maxAccounts,
             slippageBps,
             void 0,
             {
@@ -4141,6 +4146,9 @@ var Zap = class {
             },
             jupiterQuoteOptions
           );
+          preInstructions.push(
+            ...getJupiterCreateAtaInstructions(result.setupInstructions)
+          );
           swapInstructions = [result.instruction];
           addressLookupTableAccounts = result.addressLookupTableAccounts;
           maxTransferAmount = getExtendMaxAmountTransfer(
@@ -4184,7 +4192,6 @@ var Zap = class {
           inputTokenMint,
           outputTokenMint,
           swapInAmount,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4194,6 +4201,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         swapInstructions = [result.instruction];
         addressLookupTableAccounts = result.addressLookupTableAccounts;
         maxTransferAmount = getExtendMaxAmountTransfer(
@@ -4273,13 +4283,12 @@ var Zap = class {
    * @param params.amountIn - The amount of input token
    * @param params.inputTokenMint - The input token mint
    * @param params.positionNftMint - The position NFT mint account's public key
-   * @param params.maxAccounts - The maximum number of accounts for the Jupiter swap query
    * @param params.maxSqrtPriceChangeBps - The maximum sqrt price change in basis points
    * @param params.slippageBps - The swap slippage tolerance in basis points
    * @param params.jupiterQuoteToA - The Jupiter quote for swapping to tokenA for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.jupiterQuoteToB - The Jupiter quote for swapping to tokenB for exactly 1 input token in lamports (used for price calculation, not the actual amountIn)
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
-   * @param params.jupiterQuoteOptions - Optional Jupiter quote options, see `JupiterQuoteOptions`
+   * @param params.jupiterQuoteOptions - Optional Jupiter query parameters, see `GetJupiterQuoteParams.queryParams`
    * @returns The zap-in transaction parameters for a DAMM V2 indirect pool
    * @throws if input token mint matches either tokenA or tokenB in the pool
    * @throws if no Jupiter quote provided for both tokens
@@ -4293,7 +4302,6 @@ var Zap = class {
         pool,
         positionNftMint,
         amountIn,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         maxTransferAmountExtendPercentage,
         slippageBps,
@@ -4389,7 +4397,6 @@ var Zap = class {
           inputTokenMint,
           tokenAMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4399,6 +4406,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4444,7 +4454,6 @@ var Zap = class {
           inputTokenMint,
           tokenBMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4454,6 +4463,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4494,7 +4506,6 @@ var Zap = class {
           inputTokenMint,
           tokenAMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4504,6 +4515,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4544,7 +4558,6 @@ var Zap = class {
           inputTokenMint,
           tokenBMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4554,6 +4567,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4635,7 +4651,6 @@ var Zap = class {
           inputTokenMint,
           tokenAMint,
           swapAmountToA,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4645,13 +4660,15 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToA.setupInstructions)
+        );
         const swapToB = yield buildJupiterSwapTransaction(
           this.connection,
           user,
           inputTokenMint,
           tokenBMint,
           swapAmountToB,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4661,6 +4678,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToB.setupInstructions)
+        );
         return __spreadProps(__spreadValues({}, baseParams), {
           maxTransferAmountA: getExtendMaxAmountTransfer(
             swapToA.quoteResponse.outAmount,
@@ -4711,7 +4731,7 @@ var Zap = class {
    * @param params.amount - The amount to deposit
    * @param params.preSqrtPrice - The sqrt price before the operation
    * @param params.maxSqrtPriceChangeBps - The maximum sqrt price change in basis points
-   * @param params.preInstructions - Instructions to run before the zap in
+   * @param params.preInstructions - Instructions to run before the zap in, including the token accounts the Jupiter swaps need. Token account creation repeated here is removed
    * @param params.swapInstructions - Swap instructions to execute
    * @param params.addressLookupTableAccounts - Lookup tables used by the swap instructions
    * @param params.cleanUpInstructions - Instructions to run after the zap in
@@ -4739,30 +4759,13 @@ var Zap = class {
         addressLookupTableAccounts,
         cleanUpInstructions
       } = params;
-      const [
-        { ataPubkey: tokenAAccount, ix: initializeTokenAIx },
-        { ataPubkey: tokenBAccount, ix: initializeTokenBIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenAMint,
-          user,
-          user,
-          false,
-          tokenAProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenBMint,
-          user,
-          user,
-          false,
-          tokenBProgram
-        )
+      const {
+        tokenAccounts: [tokenAAccount, tokenBAccount],
+        instructions: setupInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: tokenAMint, tokenProgram: tokenAProgram },
+        { mint: tokenBMint, tokenProgram: tokenBProgram }
       ]);
-      const setupInstructions = [];
-      initializeTokenAIx && setupInstructions.push(initializeTokenAIx);
-      initializeTokenBIx && setupInstructions.push(initializeTokenBIx);
       setupInstructions.push(...preInstructions);
       const ledgerInstructions = yield this.resetOrInitializeLedgerAccount(user);
       if (isDirectPool) {
@@ -4844,7 +4847,7 @@ var Zap = class {
       const closeLedgerInstruction = yield this.closeLedgerAccount(user, user);
       return {
         instructions: [
-          ...setupInstructions,
+          ...dedupeCreateAtaInstructions(setupInstructions),
           ...swapInstructions,
           ...ledgerInstructions,
           zapInInstruction,
@@ -4868,7 +4871,6 @@ var Zap = class {
    * @param params.maxDeltaId - The bin delta relative to the active bin for the upper bin position
    * @param params.strategy - The liquidity distribution strategy
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
-   * @param params.maxAccounts - Max accounts for the Jupiter swap query. Example value is `50`; this is not safe for every pool/size. Combined with Direct estimators (`onlyDirectRoutes=true`) this can select a much thinner route than Jupiter UI.
    * @param params.swapSlippageBps - Swap slippage vs the **quoted route**, not vs a fair input/output price. Validate `directSwapEstimate` / `outAmount` before send.
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
    * @param params.maxActiveBinSlippage - The maximum active bin slippage
@@ -4889,7 +4891,6 @@ var Zap = class {
         maxDeltaId,
         strategy,
         favorXInActiveId,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -4934,7 +4935,6 @@ var Zap = class {
             directSwapEstimate.swapType === 0 /* XToY */ ? tokenXMint : tokenYMint,
             directSwapEstimate.swapType === 0 /* XToY */ ? tokenYMint : tokenXMint,
             directSwapEstimate.swapAmount,
-            maxAccounts,
             swapSlippageBps,
             swapQuote.originalQuote,
             {
@@ -4943,6 +4943,9 @@ var Zap = class {
               jupiterApiVersion: this.jupiterApiVersion
             }
           );
+          preInstructions.push(
+            ...getJupiterCreateAtaInstructions(swap.setupInstructions)
+          );
           swapInstructions.push(swap.instruction);
           addressLookupTableAccounts = swap.addressLookupTableAccounts;
         } else {
@@ -5041,7 +5044,6 @@ var Zap = class {
    * @param params.strategy - The liquidity distribution strategy
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
    * @param params.indirectSwapEstimate - The result from the indirect swap estimate
-   * @param params.maxAccounts - The maximum number of accounts for the Jupiter swap query
    * @param params.swapSlippageBps - The swap slippage tolerance in basis points
    * @param params.maxTransferAmountExtendPercentage - The percentage to extend the max transfer amount after the swap
    * @param params.maxActiveBinSlippage - The maximum active bin slippage
@@ -5062,7 +5064,6 @@ var Zap = class {
         strategy,
         favorXInActiveId,
         indirectSwapEstimate,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -5111,7 +5112,6 @@ var Zap = class {
           inputTokenMint,
           tokenXMint,
           swapAmountToXInLamports,
-          maxAccounts,
           swapSlippageBps,
           indirectSwapEstimate.swapToX,
           {
@@ -5120,6 +5120,9 @@ var Zap = class {
             jupiterApiVersion: this.jupiterApiVersion
           }
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToX.setupInstructions)
+        );
         swapInstructions.push(swapToX.instruction);
         swapLookupTables.push(swapToX.addressLookupTableAccounts);
       }
@@ -5130,7 +5133,6 @@ var Zap = class {
           inputTokenMint,
           tokenYMint,
           swapAmountToYInLamports,
-          maxAccounts,
           swapSlippageBps,
           indirectSwapEstimate.swapToY,
           {
@@ -5139,6 +5141,9 @@ var Zap = class {
             jupiterApiVersion: this.jupiterApiVersion
           }
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToY.setupInstructions)
+        );
         swapInstructions.push(swapToY.instruction);
         swapLookupTables.push(swapToY.addressLookupTableAccounts);
       }
@@ -5217,7 +5222,7 @@ var Zap = class {
    * @param params.maxActiveBinSlippage - The maximum active bin slippage
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
    * @param params.strategy - The liquidity distribution strategy
-   * @param params.preInstructions - Instructions to run before the zap in
+   * @param params.preInstructions - Instructions to run before the zap in, including the token accounts the Jupiter swaps need. Token account creation repeated here is removed
    * @param params.swapInstructions - Swap instructions to execute
    * @param params.addressLookupTableAccounts - Lookup tables used by the swap instructions
    * @param params.cleanUpInstructions - Instructions to run after the zap in
@@ -5252,30 +5257,13 @@ var Zap = class {
         isDirectRoute,
         singleSided
       } = params;
-      const [
-        { ataPubkey: tokenXAccount, ix: initializeTokenXIx },
-        { ataPubkey: tokenYAccount, ix: initializeTokenYIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenXMint,
-          user,
-          user,
-          false,
-          tokenXProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          tokenYMint,
-          user,
-          user,
-          false,
-          tokenYProgram
-        )
+      const {
+        tokenAccounts: [tokenXAccount, tokenYAccount],
+        instructions: setupInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: tokenXMint, tokenProgram: tokenXProgram },
+        { mint: tokenYMint, tokenProgram: tokenYProgram }
       ]);
-      const setupInstructions = [];
-      initializeTokenXIx && setupInstructions.push(initializeTokenXIx);
-      initializeTokenYIx && setupInstructions.push(initializeTokenYIx);
       setupInstructions.push(...preInstructions);
       const ledgerInstructions = yield this.resetOrInitializeLedgerAccount(user);
       if (isDirectRoute) {
@@ -5399,7 +5387,7 @@ var Zap = class {
       const closeLedgerInstruction = yield this.closeLedgerAccount(user, user);
       return {
         instructions: [
-          ...setupInstructions,
+          ...dedupeCreateAtaInstructions(setupInstructions),
           ...swapInstructions,
           ...ledgerInstructions,
           zapInInstruction,
@@ -5432,7 +5420,6 @@ var Zap = class {
    * @param params.strategy - The strategy to use for the rebalance
    * @param params.favorXInActiveId - Whether to favor token X in the active bin
    * @param params.directSwapEstimate - The estimate of the direct swap operation
-   * @param params.maxAccounts - The maximum number of accounts to use for the swap operation
    * @returns The ordered instructions, the lookup tables they use, and the estimated balances
    * @throws if fail to get jupiter quote or jupiter swap instruction
    */
@@ -5448,36 +5435,18 @@ var Zap = class {
         swapSlippageBps,
         strategy,
         favorXInActiveId,
-        directSwapEstimate,
-        maxAccounts = 50
+        directSwapEstimate
       } = params;
       const dlmm = yield import_dlmm4.default.create(this.connection, lbPair);
       const userPosition = yield dlmm.getPosition(position);
       const { tokenXProgram, tokenYProgram } = (0, import_dlmm4.getTokenProgramId)(dlmm.lbPair);
-      const [
-        { ataPubkey: userTokenX, ix: userTokenXIx },
-        { ataPubkey: userTokenY, ix: userTokenYIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          dlmm.lbPair.tokenXMint,
-          user,
-          user,
-          true,
-          tokenXProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          dlmm.lbPair.tokenYMint,
-          user,
-          user,
-          true,
-          tokenYProgram
-        )
+      const {
+        tokenAccounts: [userTokenX, userTokenY],
+        instructions: setupInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: dlmm.lbPair.tokenXMint, tokenProgram: tokenXProgram },
+        { mint: dlmm.lbPair.tokenYMint, tokenProgram: tokenYProgram }
       ]);
-      const setupInstructions = [];
-      userTokenXIx && setupInstructions.push(userTokenXIx);
-      userTokenYIx && setupInstructions.push(userTokenYIx);
       const strategyParamBuilder = (0, import_dlmm4.getLiquidityStrategyParameterBuilder)(strategy);
       const { x0, y0, deltaX, deltaY } = (0, import_dlmm4.buildLiquidityStrategyParameters)(
         new import_core.BN(0),
@@ -5549,7 +5518,6 @@ var Zap = class {
             directSwapEstimate.swapType === 0 /* XToY */ ? dlmm.lbPair.tokenXMint : dlmm.lbPair.tokenYMint,
             directSwapEstimate.swapType === 0 /* XToY */ ? dlmm.lbPair.tokenYMint : dlmm.lbPair.tokenXMint,
             directSwapEstimate.swapAmount,
-            maxAccounts,
             swapSlippageBps,
             swapQuote.originalQuote,
             {
@@ -5558,6 +5526,9 @@ var Zap = class {
               jupiterApiVersion: this.jupiterApiVersion
             }
           );
+          setupInstructions.push(
+            ...getJupiterCreateAtaInstructions(swap.setupInstructions)
+          );
           swapInstructions = [swap.instruction];
           addressLookupTableAccounts = swap.addressLookupTableAccounts;
         } else {
@@ -5660,7 +5631,7 @@ var Zap = class {
       }
       return {
         instructions: [
-          ...setupInstructions,
+          ...dedupeCreateAtaInstructions(setupInstructions),
           ...filterOutComputeBudgetInstructions(initBinArrayInstructions),
           ...rebalancePositionInstruction,
           ...swapInstructions,
@@ -5737,6 +5708,7 @@ var Zap = class {
    */
   zapOutThroughJupiter(params) {
     return __async(this, null, function* () {
+      var _a;
       const {
         user,
         inputMint,
@@ -5749,29 +5721,21 @@ var Zap = class {
       } = params;
       const preInstructions = [];
       const postInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: inputTokenAccountIx },
-        { ix: outputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          inputMint,
-          user,
-          user,
-          true,
-          inputTokenProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          outputMint,
-          user,
-          user,
-          true,
-          outputTokenProgram
-        )
+      const {
+        tokenAccounts: [inputTokenAccount],
+        instructions: createAtaInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: inputMint, tokenProgram: inputTokenProgram },
+        { mint: outputMint, tokenProgram: outputTokenProgram }
       ]);
-      inputTokenAccountIx && preInstructions.push(inputTokenAccountIx);
-      outputTokenAccountIx && preInstructions.push(outputTokenAccountIx);
+      preInstructions.push(...createAtaInstructions);
+      preInstructions.push(
+        ...getJupiterCreateAtaInstructions(
+          ((_a = jupiterSwapResponse.setupInstructions) != null ? _a : []).map(
+            toTransactionInstruction
+          )
+        )
+      );
       let preUserTokenBalance;
       try {
         preUserTokenBalance = yield getTokenAccountBalance(
@@ -5816,7 +5780,7 @@ var Zap = class {
           },
           remainingAccounts,
           ammProgram: JUP_V6_PROGRAM_ID,
-          preInstructions,
+          preInstructions: dedupeCreateAtaInstructions(preInstructions),
           postInstructions
         }),
         getJupiterAddressLookupTableAccounts(
@@ -5859,29 +5823,14 @@ var Zap = class {
       const poolState = yield getDammV2Pool(this.connection, poolAddress);
       const preInstructions = [];
       const postInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: inputTokenAccountIx },
-        { ataPubkey: outputTokenAccount, ix: outputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          inputMint,
-          user,
-          user,
-          true,
-          inputTokenProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          outputMint,
-          user,
-          user,
-          true,
-          outputTokenProgram
-        )
+      const {
+        tokenAccounts: [inputTokenAccount, outputTokenAccount],
+        instructions: createAtaInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: inputMint, tokenProgram: inputTokenProgram },
+        { mint: outputMint, tokenProgram: outputTokenProgram }
       ]);
-      inputTokenAccountIx && preInstructions.push(inputTokenAccountIx);
-      outputTokenAccountIx && preInstructions.push(outputTokenAccountIx);
+      preInstructions.push(...createAtaInstructions);
       let preUserTokenBalance;
       try {
         preUserTokenBalance = yield getTokenAccountBalance(
@@ -5956,29 +5905,14 @@ var Zap = class {
       const lbPairState = yield getLbPairState(this.connection, lbPairAddress);
       const preInstructions = [];
       const postInstructions = [];
-      const [
-        { ataPubkey: inputTokenAccount, ix: inputTokenAccountIx },
-        { ataPubkey: outputTokenAccount, ix: outputTokenAccountIx }
-      ] = yield Promise.all([
-        getOrCreateATAInstruction(
-          this.connection,
-          inputMint,
-          user,
-          user,
-          true,
-          inputTokenProgram
-        ),
-        getOrCreateATAInstruction(
-          this.connection,
-          outputMint,
-          user,
-          user,
-          true,
-          outputTokenProgram
-        )
+      const {
+        tokenAccounts: [inputTokenAccount, outputTokenAccount],
+        instructions: createAtaInstructions
+      } = getCreateAtaInstructions(user, [
+        { mint: inputMint, tokenProgram: inputTokenProgram },
+        { mint: outputMint, tokenProgram: outputTokenProgram }
       ]);
-      inputTokenAccountIx && preInstructions.push(inputTokenAccountIx);
-      outputTokenAccountIx && preInstructions.push(outputTokenAccountIx);
+      preInstructions.push(...createAtaInstructions);
       let preUserTokenBalance;
       try {
         preUserTokenBalance = yield getTokenAccountBalance(
@@ -6037,18 +5971,12 @@ var Zap = class {
   DAMM_V2_SWAP_DISCRIMINATOR,
   DEFAULT_JUPITER_API_URL,
   DEFAULT_JUPITER_API_VERSION,
-  DEFAULT_JUPITER_QUOTE_OPTIONS,
   DLMM_PROGRAM_ID,
   DLMM_SWAP_DISCRIMINATOR,
   DlmmDirectSwapQuoteRoute,
   DlmmSingleSided,
   DlmmSwapType,
-  JUPITER_INSTRUCTION_LAYOUTS,
   JUP_V6_PROGRAM_ID,
-  JUP_V6_ROUTE_DISCRIMINATOR,
-  JUP_V6_ROUTE_V2_DISCRIMINATOR,
-  JUP_V6_SHARED_ACCOUNTS_ROUTE_DISCRIMINATOR,
-  JUP_V6_SHARED_ACCOUNTS_ROUTE_V2_DISCRIMINATOR,
   JupiterApiVersion,
   MEMO_PROGRAM_ID,
   SwapExternalType,
@@ -6069,17 +5997,13 @@ var Zap = class {
   estimateDlmmDirectSwap,
   estimateDlmmIndirectSwap,
   estimateDlmmRebalanceSwap,
-  fetchAddressLookupTableAccounts,
   filterOutCloseSplTokenAccountInstructions,
-  filterOutComputeBudgetInstructions,
   getBinArrayBitmapExtension,
   getBitFromBinArrayIndexInBitmapExtension,
   getDammV2Pool,
   getDammV2RemainingAccounts,
   getDlmmRemainingAccounts,
   getExtraAccountMetasForTransferHook,
-  getJupiterAddressLookupTableAccounts,
-  getJupiterInstructionLayout,
   getJupiterQuote,
   getJupiterSwapInstruction,
   getLbPairState,
@@ -6087,13 +6011,8 @@ var Zap = class {
   getOrCreateATAInstruction,
   getTokenAccountBalance,
   getTokenProgramFromMint,
-  isJupiterBuildResponse,
-  isJupiterSwapInstructionForUser,
   isSingleSidedA,
   isSingleSidedB,
-  mergeAddressLookupTableAccounts,
-  resolveJupiterConfig,
-  toAddressLookupTableAccounts,
   toProgramStrategyType,
   unwrapSOLInstruction,
   wrapSOLInstruction