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

package/dist/index.mjs

@@ -1912,8 +1912,8 @@ var DlmmSingleSided = /* @__PURE__ */ ((DlmmSingleSided2) => {
 import {
   AddressLookupTableAccount,
   AddressLookupTableProgram,
-  PublicKey as PublicKey2,
-  TransactionInstruction
+  PublicKey as PublicKey3,
+  TransactionInstruction as TransactionInstruction2
 } from "@solana/web3.js";
 
 // src/constants.ts
@@ -2033,20 +2033,134 @@ 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
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction,
+  createCloseAccountInstruction,
+  getAssociatedTokenAddressSync,
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID
+} from "@solana/spl-token";
+import {
+  SystemProgram,
+  TransactionInstruction
+} from "@solana/web3.js";
+var getOrCreateATAInstruction = (_connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
+  const toAccount = getAssociatedTokenAddressSync(
+    tokenMint,
+    owner,
+    allowOwnerOffCurve,
+    tokenProgram
+  );
+  const ix = createAssociatedTokenAccountIdempotentInstruction(
+    payer,
+    toAccount,
+    owner,
+    tokenMint,
+    tokenProgram
+  );
+  return { ataPubkey: toAccount, ix };
+});
+function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
+  const wSolATAAccount = getAssociatedTokenAddressSync(
+    NATIVE_MINT,
+    owner,
+    allowOwnerOffCurve
+  );
+  if (wSolATAAccount) {
+    const closedWrappedSolInstruction = createCloseAccountInstruction(
+      wSolATAAccount,
+      receiver,
+      owner,
+      [],
+      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 = TOKEN_PROGRAM_ID) {
+  return [
+    SystemProgram.transfer({
+      fromPubkey: from,
+      toPubkey: to,
+      lamports: amount
+    }),
+    new 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(TOKEN_PROGRAM_ID)) {
+      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
+    }
+    return true;
+  });
+}
+function getCreateAtaInstructions(user, tokens) {
+  const tokenAccounts = tokens.map(
+    ({ mint, tokenProgram }) => getAssociatedTokenAddressSync(mint, user, true, tokenProgram)
+  );
+  const instructions = tokens.map(
+    ({ mint, tokenProgram }, i) => createAssociatedTokenAccountIdempotentInstruction(
+      user,
+      tokenAccounts[i],
+      user,
+      mint,
+      tokenProgram
+    )
+  );
+  return { tokenAccounts, instructions };
+}
+function isCreateAtaInstruction(ix) {
+  return ix.programId.equals(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) {
@@ -2067,37 +2181,28 @@ function isJupiterSwapInstructionForUser(swapInstruction, user) {
     Buffer.from(swapInstruction.data, "base64")
   );
   const authority = swapInstruction.accounts[layout.userTransferAuthorityIndex];
-  return authority !== void 0 && new PublicKey2(authority.pubkey).equals(user);
+  return authority !== void 0 && new PublicKey3(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",
@@ -2112,12 +2217,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",
@@ -2132,26 +2237,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) {
@@ -2181,8 +2273,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);
@@ -2216,9 +2308,9 @@ var ACTIVE_LOOKUP_TABLE_DEACTIVATION_SLOT = BigInt("0xffffffffffffffff");
 function toAddressLookupTableAccounts(addressesByLookupTableAddress) {
   return Object.entries(addressesByLookupTableAddress != null ? addressesByLookupTableAddress : {}).map(
     ([key, addresses]) => new AddressLookupTableAccount({
-      key: new PublicKey2(key),
+      key: new PublicKey3(key),
       state: {
-        addresses: addresses.map((address) => new PublicKey2(address)),
+        addresses: addresses.map((address) => new PublicKey3(address)),
         deactivationSlot: ACTIVE_LOOKUP_TABLE_DEACTIVATION_SLOT,
         lastExtendedSlot: 0,
         lastExtendedSlotStartIndex: 0
@@ -2231,7 +2323,7 @@ function fetchAddressLookupTableAccounts(connection, addresses) {
     if (addresses.length === 0) {
       return [];
     }
-    const keys = addresses.map((address) => new PublicKey2(address));
+    const keys = addresses.map((address) => new PublicKey3(address));
     const accounts = yield connection.getMultipleAccountsInfo(keys);
     return keys.map((key, i) => {
       const account = accounts[i];
@@ -2267,22 +2359,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 TransactionInstruction2({
+    keys: instruction.accounts.map((item) => ({
+      pubkey: new PublicKey3(item.pubkey),
+      isSigner: item.isSigner,
+      isWritable: item.isWritable
+    })),
+    programId: new PublicKey3(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) {
@@ -2295,27 +2400,27 @@ function buildJupiterSwapTransaction(_0, _1, _2, _3, _4, _5, _6, _7) {
       quoteResponse,
       config
     );
-    const instruction = new TransactionInstruction({
-      keys: swapInstructionResponse.swapInstruction.accounts.map((item) => {
-        return {
-          pubkey: new PublicKey2(item.pubkey),
-          isSigner: item.isSigner,
-          isWritable: item.isWritable
-        };
-      }),
-      programId: new PublicKey2(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
-import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2 } from "@solana/spl-token";
 import {
   CollectFeeMode,
   CpAmm,
@@ -2323,27 +2428,27 @@ import {
 } from "@meteora-ag/cp-amm-sdk";
 
 // src/helpers/pda.ts
-import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
 function deriveDammV2EventAuthority() {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveDammV2PoolAuthority() {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("pool_authority")],
     DAMM_V2_PROGRAM_ID
   )[0];
 }
 function deriveLedgerAccount(owner) {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("user_ledger"), owner.toBuffer()],
     ZAP_PROGRAM_ID
   )[0];
 }
 function deriveDlmmEventAuthority() {
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("__event_authority")],
     DLMM_PROGRAM_ID
   )[0];
@@ -2357,7 +2462,7 @@ function getDammV2Pool(connection, poolAddress) {
   });
 }
 function getDammV2RemainingAccounts(_0, _1, _2, _3) {
-  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = TOKEN_PROGRAM_ID, tokenBProgram = TOKEN_PROGRAM_ID, poolState) {
+  return __async(this, arguments, function* (poolAddress, user, userInputTokenAccount, userTokenOutAccount, tokenAProgram = TOKEN_PROGRAM_ID2, tokenBProgram = TOKEN_PROGRAM_ID2, poolState) {
     const remainingAccounts = [
       {
         isSigner: false,
@@ -2448,16 +2553,16 @@ function createDammV2SwapPayload(amountIn, minimumSwapAmountOut) {
 }
 
 // src/helpers/common.ts
-import { NATIVE_MINT, TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2 } from "@solana/spl-token";
+import { NATIVE_MINT as NATIVE_MINT2, TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3 } from "@solana/spl-token";
 import {
   ComputeBudgetProgram,
-  PublicKey as PublicKey4
+  PublicKey as PublicKey5
 } from "@solana/web3.js";
 import Decimal from "decimal.js";
 function getTokenProgramFromMint(connection, mint) {
   return __async(this, null, function* () {
-    if (mint.equals(NATIVE_MINT)) {
-      return TOKEN_PROGRAM_ID2;
+    if (mint.equals(NATIVE_MINT2)) {
+      return TOKEN_PROGRAM_ID3;
     }
     try {
       const mintInfo = yield connection.getAccountInfo(mint);
@@ -2465,18 +2570,18 @@ function getTokenProgramFromMint(connection, mint) {
         throw new Error(`Mint account not found: ${mint.toString()}`);
       }
       if (mintInfo.owner.equals(
-        new PublicKey4("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
+        new PublicKey5("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
       )) {
-        return new PublicKey4("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+        return new PublicKey5("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
       } else {
-        return TOKEN_PROGRAM_ID2;
+        return TOKEN_PROGRAM_ID3;
       }
     } catch (error) {
       console.warn(
         `Failed to determine token program for ${mint.toString()}, defaulting to TOKEN_PROGRAM_ID:`,
         error
       );
-      return TOKEN_PROGRAM_ID2;
+      return TOKEN_PROGRAM_ID3;
     }
   });
 }
@@ -2492,93 +2597,6 @@ function filterOutComputeBudgetInstructions(instructions) {
   );
 }
 
-// src/helpers/token.ts
-import {
-  createAssociatedTokenAccountIdempotentInstruction,
-  createCloseAccountInstruction,
-  getAssociatedTokenAddressSync,
-  NATIVE_MINT as NATIVE_MINT2,
-  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3
-} from "@solana/spl-token";
-import {
-  SystemProgram,
-  TransactionInstruction as TransactionInstruction3
-} from "@solana/web3.js";
-var getOrCreateATAInstruction = (_connection, tokenMint, owner, payer, allowOwnerOffCurve = true, tokenProgram) => __async(null, null, function* () {
-  const toAccount = getAssociatedTokenAddressSync(
-    tokenMint,
-    owner,
-    allowOwnerOffCurve,
-    tokenProgram
-  );
-  const ix = createAssociatedTokenAccountIdempotentInstruction(
-    payer,
-    toAccount,
-    owner,
-    tokenMint,
-    tokenProgram
-  );
-  return { ataPubkey: toAccount, ix };
-});
-function unwrapSOLInstruction(owner, receiver, allowOwnerOffCurve = true) {
-  const wSolATAAccount = getAssociatedTokenAddressSync(
-    NATIVE_MINT2,
-    owner,
-    allowOwnerOffCurve
-  );
-  if (wSolATAAccount) {
-    const closedWrappedSolInstruction = createCloseAccountInstruction(
-      wSolATAAccount,
-      receiver,
-      owner,
-      [],
-      TOKEN_PROGRAM_ID3
-    );
-    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 = TOKEN_PROGRAM_ID3) {
-  return [
-    SystemProgram.transfer({
-      fromPubkey: from,
-      toPubkey: to,
-      lamports: amount
-    }),
-    new TransactionInstruction3({
-      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(TOKEN_PROGRAM_ID3)) {
-      return ix.data[0] !== CLOSE_ACCOUNT_DISCRIMINATOR;
-    }
-    return true;
-  });
-}
-
 // src/helpers/dlmm.ts
 import { PublicKey as PublicKey7 } from "@solana/web3.js";
 import BN2 from "bn.js";
@@ -2956,8 +2974,8 @@ function estimateSwapOutput(inAmount, effectiveRate) {
   const estimatedOutput = inAmountDecimal.mul(effectiveRate);
   return new BN3(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(
@@ -2970,14 +2988,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 ? {
@@ -3104,7 +3123,7 @@ function estimateDlmmIndirectSwap(_0) {
     strategy,
     singleSided,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     const dlmm = yield DLMM2.create(connection, lbPair);
     const activeBin = yield dlmm.getActiveBin();
@@ -3128,14 +3147,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) {
@@ -3158,25 +3178,27 @@ function estimateDlmmIndirectSwap(_0) {
     const halfAmount = amountIn.div(new BN3(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
       )
     ]);
@@ -3272,25 +3294,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
       )
     ]);
@@ -3336,7 +3360,7 @@ function estimateDlmmDirectSwapCore(_0) {
     strategy,
     singleSided,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     if (singleSided !== void 0) {
       const singleSidedX = singleSided === 0 /* X */;
@@ -3581,7 +3605,7 @@ function estimateDlmmDirectSwap(_0) {
     strategy,
     singleSided,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     const dlmm = yield DLMM2.create(connection, lbPair);
     invariant(
@@ -3630,7 +3654,7 @@ function estimateDlmmRebalanceSwap(_0) {
     maxDeltaId,
     strategy,
     jupiterQuoteOptions,
-    config = {}
+    config
   }) {
     const dlmm = yield DLMM2.create(connection, lbPair);
     const userPosition = yield dlmm.getPosition(position);
@@ -3736,13 +3760,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 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) {
@@ -3976,13 +4000,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
@@ -3996,7 +4019,6 @@ var Zap = class {
         inputTokenMint,
         amountIn,
         positionNftMint,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         slippageBps,
         dammV2Quote,
@@ -4094,7 +4116,6 @@ var Zap = class {
             inputTokenMint,
             outputTokenMint,
             swapInAmount,
-            maxAccounts,
             slippageBps,
             void 0,
             {
@@ -4104,6 +4125,9 @@ var Zap = class {
             },
             jupiterQuoteOptions
           );
+          preInstructions.push(
+            ...getJupiterCreateAtaInstructions(result.setupInstructions)
+          );
           swapInstructions = [result.instruction];
           addressLookupTableAccounts = result.addressLookupTableAccounts;
           maxTransferAmount = getExtendMaxAmountTransfer(
@@ -4147,7 +4171,6 @@ var Zap = class {
           inputTokenMint,
           outputTokenMint,
           swapInAmount,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4157,6 +4180,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         swapInstructions = [result.instruction];
         addressLookupTableAccounts = result.addressLookupTableAccounts;
         maxTransferAmount = getExtendMaxAmountTransfer(
@@ -4236,13 +4262,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
@@ -4256,7 +4281,6 @@ var Zap = class {
         pool,
         positionNftMint,
         amountIn,
-        maxAccounts,
         maxSqrtPriceChangeBps,
         maxTransferAmountExtendPercentage,
         slippageBps,
@@ -4352,7 +4376,6 @@ var Zap = class {
           inputTokenMint,
           tokenAMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4362,6 +4385,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4407,7 +4433,6 @@ var Zap = class {
           inputTokenMint,
           tokenBMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4417,6 +4442,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4457,7 +4485,6 @@ var Zap = class {
           inputTokenMint,
           tokenAMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4467,6 +4494,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4507,7 +4537,6 @@ var Zap = class {
           inputTokenMint,
           tokenBMint,
           amountIn,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4517,6 +4546,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(result.setupInstructions)
+        );
         return {
           user,
           pool,
@@ -4598,7 +4630,6 @@ var Zap = class {
           inputTokenMint,
           tokenAMint,
           swapAmountToA,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4608,13 +4639,15 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToA.setupInstructions)
+        );
         const swapToB = yield buildJupiterSwapTransaction(
           this.connection,
           user,
           inputTokenMint,
           tokenBMint,
           swapAmountToB,
-          maxAccounts,
           slippageBps,
           void 0,
           {
@@ -4624,6 +4657,9 @@ var Zap = class {
           },
           jupiterQuoteOptions
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToB.setupInstructions)
+        );
         return __spreadProps(__spreadValues({}, baseParams), {
           maxTransferAmountA: getExtendMaxAmountTransfer(
             swapToA.quoteResponse.outAmount,
@@ -4674,7 +4710,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
@@ -4702,30 +4738,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) {
@@ -4807,7 +4826,7 @@ var Zap = class {
       const closeLedgerInstruction = yield this.closeLedgerAccount(user, user);
       return {
         instructions: [
-          ...setupInstructions,
+          ...dedupeCreateAtaInstructions(setupInstructions),
           ...swapInstructions,
           ...ledgerInstructions,
           zapInInstruction,
@@ -4831,7 +4850,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
@@ -4852,7 +4870,6 @@ var Zap = class {
         maxDeltaId,
         strategy,
         favorXInActiveId,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -4897,7 +4914,6 @@ var Zap = class {
             directSwapEstimate.swapType === 0 /* XToY */ ? tokenXMint : tokenYMint,
             directSwapEstimate.swapType === 0 /* XToY */ ? tokenYMint : tokenXMint,
             directSwapEstimate.swapAmount,
-            maxAccounts,
             swapSlippageBps,
             swapQuote.originalQuote,
             {
@@ -4906,6 +4922,9 @@ var Zap = class {
               jupiterApiVersion: this.jupiterApiVersion
             }
           );
+          preInstructions.push(
+            ...getJupiterCreateAtaInstructions(swap.setupInstructions)
+          );
           swapInstructions.push(swap.instruction);
           addressLookupTableAccounts = swap.addressLookupTableAccounts;
         } else {
@@ -5004,7 +5023,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
@@ -5025,7 +5043,6 @@ var Zap = class {
         strategy,
         favorXInActiveId,
         indirectSwapEstimate,
-        maxAccounts,
         swapSlippageBps,
         maxTransferAmountExtendPercentage,
         maxActiveBinSlippage,
@@ -5074,7 +5091,6 @@ var Zap = class {
           inputTokenMint,
           tokenXMint,
           swapAmountToXInLamports,
-          maxAccounts,
           swapSlippageBps,
           indirectSwapEstimate.swapToX,
           {
@@ -5083,6 +5099,9 @@ var Zap = class {
             jupiterApiVersion: this.jupiterApiVersion
           }
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToX.setupInstructions)
+        );
         swapInstructions.push(swapToX.instruction);
         swapLookupTables.push(swapToX.addressLookupTableAccounts);
       }
@@ -5093,7 +5112,6 @@ var Zap = class {
           inputTokenMint,
           tokenYMint,
           swapAmountToYInLamports,
-          maxAccounts,
           swapSlippageBps,
           indirectSwapEstimate.swapToY,
           {
@@ -5102,6 +5120,9 @@ var Zap = class {
             jupiterApiVersion: this.jupiterApiVersion
           }
         );
+        preInstructions.push(
+          ...getJupiterCreateAtaInstructions(swapToY.setupInstructions)
+        );
         swapInstructions.push(swapToY.instruction);
         swapLookupTables.push(swapToY.addressLookupTableAccounts);
       }
@@ -5180,7 +5201,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
@@ -5215,30 +5236,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) {
@@ -5362,7 +5366,7 @@ var Zap = class {
       const closeLedgerInstruction = yield this.closeLedgerAccount(user, user);
       return {
         instructions: [
-          ...setupInstructions,
+          ...dedupeCreateAtaInstructions(setupInstructions),
           ...swapInstructions,
           ...ledgerInstructions,
           zapInInstruction,
@@ -5395,7 +5399,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
    */
@@ -5411,36 +5414,18 @@ var Zap = class {
         swapSlippageBps,
         strategy,
         favorXInActiveId,
-        directSwapEstimate,
-        maxAccounts = 50
+        directSwapEstimate
       } = params;
       const dlmm = yield DLMM3.create(this.connection, lbPair);
       const userPosition = yield dlmm.getPosition(position);
       const { tokenXProgram, tokenYProgram } = 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 = getLiquidityStrategyParameterBuilder(strategy);
       const { x0, y0, deltaX, deltaY } = buildLiquidityStrategyParameters(
         new BN5(0),
@@ -5512,7 +5497,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,
             {
@@ -5521,6 +5505,9 @@ var Zap = class {
               jupiterApiVersion: this.jupiterApiVersion
             }
           );
+          setupInstructions.push(
+            ...getJupiterCreateAtaInstructions(swap.setupInstructions)
+          );
           swapInstructions = [swap.instruction];
           addressLookupTableAccounts = swap.addressLookupTableAccounts;
         } else {
@@ -5623,7 +5610,7 @@ var Zap = class {
       }
       return {
         instructions: [
-          ...setupInstructions,
+          ...dedupeCreateAtaInstructions(setupInstructions),
           ...filterOutComputeBudgetInstructions(initBinArrayInstructions),
           ...rebalancePositionInstruction,
           ...swapInstructions,
@@ -5700,6 +5687,7 @@ var Zap = class {
    */
   zapOutThroughJupiter(params) {
     return __async(this, null, function* () {
+      var _a;
       const {
         user,
         inputMint,
@@ -5712,29 +5700,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(
@@ -5779,7 +5759,7 @@ var Zap = class {
           },
           remainingAccounts,
           ammProgram: JUP_V6_PROGRAM_ID,
-          preInstructions,
+          preInstructions: dedupeCreateAtaInstructions(preInstructions),
           postInstructions
         }),
         getJupiterAddressLookupTableAccounts(
@@ -5822,29 +5802,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(
@@ -5919,29 +5884,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(
@@ -5999,18 +5949,12 @@ export {
   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,
@@ -6031,17 +5975,13 @@ export {
   estimateDlmmDirectSwap,
   estimateDlmmIndirectSwap,
   estimateDlmmRebalanceSwap,
-  fetchAddressLookupTableAccounts,
   filterOutCloseSplTokenAccountInstructions,
-  filterOutComputeBudgetInstructions,
   getBinArrayBitmapExtension,
   getBitFromBinArrayIndexInBitmapExtension,
   getDammV2Pool,
   getDammV2RemainingAccounts,
   getDlmmRemainingAccounts,
   getExtraAccountMetasForTransferHook,
-  getJupiterAddressLookupTableAccounts,
-  getJupiterInstructionLayout,
   getJupiterQuote,
   getJupiterSwapInstruction,
   getLbPairState,
@@ -6049,13 +5989,8 @@ export {
   getOrCreateATAInstruction,
   getTokenAccountBalance,
   getTokenProgramFromMint,
-  isJupiterBuildResponse,
-  isJupiterSwapInstructionForUser,
   isSingleSidedA,
   isSingleSidedB,
-  mergeAddressLookupTableAccounts,
-  resolveJupiterConfig,
-  toAddressLookupTableAccounts,
   toProgramStrategyType,
   unwrapSOLInstruction,
   wrapSOLInstruction