@meteora-ag/zap-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1055 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AMOUNT_IN_DAMM_V2_OFFSET: () => AMOUNT_IN_DAMM_V2_OFFSET,
+  AMOUNT_IN_DLMM_OFFSET: () => AMOUNT_IN_DLMM_OFFSET,
+  AMOUNT_IN_JUP_V6_REVERSE_OFFSET: () => AMOUNT_IN_JUP_V6_REVERSE_OFFSET,
+  AccountsType: () => AccountsType,
+  BIN_ARRAY_INDEX_BOUND: () => BIN_ARRAY_INDEX_BOUND,
+  DAMM_V2_PROGRAM_ID: () => DAMM_V2_PROGRAM_ID,
+  DAMM_V2_SWAP_DISCRIMINATOR: () => DAMM_V2_SWAP_DISCRIMINATOR,
+  DLMM_PROGRAM_ID: () => DLMM_PROGRAM_ID,
+  DLMM_SWAP_DISCRIMINATOR: () => DLMM_SWAP_DISCRIMINATOR,
+  JUP_V6_PROGRAM_ID: () => JUP_V6_PROGRAM_ID,
+  MEMO_PROGRAM_ID: () => MEMO_PROGRAM_ID,
+  ZAP_PROGRAM_ID: () => ZAP_PROGRAM_ID,
+  Zap: () => Zap,
+  convertAccountTypeToNumber: () => convertAccountTypeToNumber,
+  createDammV2SwapPayload: () => createDammV2SwapPayload,
+  createDlmmSwapPayload: () => createDlmmSwapPayload,
+  deriveDammV2EventAuthority: () => deriveDammV2EventAuthority,
+  getBinArrayBitmapExtension: () => getBinArrayBitmapExtension,
+  getBitFromBinArrayIndexInBitmapExtension: () => getBitFromBinArrayIndexInBitmapExtension,
+  getDammV2Pool: () => getDammV2Pool,
+  getDammV2RemainingAccounts: () => getDammV2RemainingAccounts,
+  getDlmmRemainingAccounts: () => getDlmmRemainingAccounts,
+  getExtraAccountMetasForTransferHook: () => getExtraAccountMetasForTransferHook,
+  getJupiterQuote: () => getJupiterQuote,
+  getJupiterSwapInstruction: () => getJupiterSwapInstruction,
+  getLbPairState: () => getLbPairState,
+  getNextBinArrayIndexWithLiquidity: () => getNextBinArrayIndexWithLiquidity,
+  getOrCreateATAInstruction: () => getOrCreateATAInstruction,
+  getTokenProgramFromMint: () => getTokenProgramFromMint,
+  unwrapSOLInstruction: () => unwrapSOLInstruction,
+  wrapSOLInstruction: () => wrapSOLInstruction
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/zap.ts
+var import_web37 = require("@solana/web3.js");
+var import_anchor = require("@coral-xyz/anchor");
+
+// src/idl/zap/idl.json
+var idl_default = {
+  address: "zapvX9M3uf5pvy4wRPAbQgdQsM1xmuiFnkfHKPvwMiz",
+  metadata: {
+    name: "zap",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Created with Anchor"
+  },
+  instructions: [
+    {
+      name: "zap_out",
+      discriminator: [
+        155,
+        108,
+        185,
+        112,
+        104,
+        210,
+        161,
+        64
+      ],
+      accounts: [
+        {
+          name: "user_token_in_account",
+          writable: true
+        },
+        {
+          name: "amm_program"
+        }
+      ],
+      args: [
+        {
+          name: "params",
+          type: {
+            defined: {
+              name: "ZapOutParameters"
+            }
+          }
+        }
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "MathOverflow",
+      msg: "Math operation overflow"
+    },
+    {
+      code: 6001,
+      name: "InvalidOffset",
+      msg: "Invalid offset"
+    },
+    {
+      code: 6002,
+      name: "InvalidZapOutParameters",
+      msg: "Math operation overflow"
+    },
+    {
+      code: 6003,
+      name: "TypeCastFailed",
+      msg: "Type cast error"
+    },
+    {
+      code: 6004,
+      name: "AmmIsNotSupported",
+      msg: "Amm program is not supported"
+    }
+  ],
+  types: [
+    {
+      name: "ZapOutParameters",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "percentage",
+            type: "u8"
+          },
+          {
+            name: "offset_amount_in",
+            type: "u16"
+          },
+          {
+            name: "pre_user_token_balance",
+            type: "u64"
+          },
+          {
+            name: "max_swap_amount",
+            type: "u64"
+          },
+          {
+            name: "payload_data",
+            type: "bytes"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/helpers/jupiter.ts
+function getJupiterQuote(inputMint, outputMint, amount, maxAccounts, slippageBps, onlyDirectRoutes, restrictIntermediateTokens, apiUrl = "https://lite-api.jup.ag", apiKey) {
+  return __async(this, null, function* () {
+    const params = new URLSearchParams({
+      inputMint: inputMint.toString(),
+      outputMint: outputMint.toString(),
+      amount: amount.toString(),
+      slippageBps: slippageBps.toString(),
+      maxAccounts: maxAccounts.toString(),
+      onlyDirectRoutes: onlyDirectRoutes.toString(),
+      restrictIntermediateTokens: restrictIntermediateTokens.toString()
+    });
+    const url = `${apiUrl}/swap/v1/quote?${params.toString()}`;
+    console.log(url);
+    const response = yield fetch(url, {
+      method: "GET",
+      headers: __spreadValues({
+        Accept: "application/json"
+      }, apiKey ? { "x-api-key": apiKey } : {})
+    });
+    if (!response.ok) {
+      const errorText = yield response.text();
+      throw new Error(`Jupiter quote failed (${response.status}): ${errorText}`);
+    }
+    const result = yield response.json();
+    return result;
+  });
+}
+function getJupiterSwapInstruction(userPublicKey, quoteResponse, apiUrl = "https://lite-api.jup.ag", apiKey) {
+  return __async(this, null, function* () {
+    const url = `${apiUrl}/swap/v1/swap-instructions`;
+    const requestBody = {
+      userPublicKey: userPublicKey.toString(),
+      quoteResponse
+    };
+    const response = yield fetch(url, {
+      method: "POST",
+      headers: __spreadValues({
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }, apiKey ? { "x-api-key": apiKey } : {}),
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = yield response.text();
+      throw new Error(
+        `Jupiter swap instruction failed (${response.status}): ${errorText}`
+      );
+    }
+    const result = yield response.json();
+    return result;
+  });
+}
+
+// src/helpers/dammV2.ts
+var import_spl_token = require("@solana/spl-token");
+
+// src/constants.ts
+var import_web3 = require("@solana/web3.js");
+var import_bn = __toESM(require("bn.js"));
+var import_dlmm = require("@meteora-ag/dlmm");
+var ZAP_PROGRAM_ID = new import_web3.PublicKey(idl_default.address);
+var JUP_V6_PROGRAM_ID = new import_web3.PublicKey(
+  "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"
+);
+var DAMM_V2_PROGRAM_ID = new import_web3.PublicKey(
+  "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
+);
+var DLMM_PROGRAM_ID = new import_web3.PublicKey(
+  "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo"
+);
+var MEMO_PROGRAM_ID = new import_web3.PublicKey(
+  "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
+);
+var BIN_ARRAY_INDEX_BOUND = [
+  import_dlmm.BIN_ARRAY_BITMAP_SIZE.mul(
+    import_dlmm.EXTENSION_BINARRAY_BITMAP_SIZE.add(new import_bn.default(1))
+  ).neg(),
+  import_dlmm.BIN_ARRAY_BITMAP_SIZE.mul(import_dlmm.EXTENSION_BINARRAY_BITMAP_SIZE.add(new import_bn.default(1))).sub(
+    new import_bn.default(1)
+  )
+];
+var AccountsType = {
+  TransferHookX: {
+    transferHookX: {}
+  },
+  TransferHookY: {
+    transferHookY: {}
+  },
+  TransferHookReward: {
+    transferHookReward: {}
+  }
+};
+var DLMM_SWAP_DISCRIMINATOR = [65, 75, 63, 76, 235, 91, 91, 136];
+var AMOUNT_IN_DLMM_OFFSET = 8;
+var AMOUNT_IN_JUP_V6_REVERSE_OFFSET = 19;
+var AMOUNT_IN_DAMM_V2_OFFSET = 8;
+var DAMM_V2_SWAP_DISCRIMINATOR = [
+  248,
+  198,
+  158,
+  145,
+  225,
+  117,
+  135,
+  200
+];
+
+// src/helpers/dammV2.ts
+var import_cp_amm_sdk = require("@meteora-ag/cp-amm-sdk");
+
+// src/helpers/pda.ts
+var import_web32 = require("@solana/web3.js");
+function deriveDammV2EventAuthority() {
+  return import_web32.PublicKey.findProgramAddressSync(
+    [Buffer.from("__event_authority")],
+    DAMM_V2_PROGRAM_ID
+  )[0];
+}
+
+// src/helpers/dammV2.ts
+function getDammV2Pool(connection, poolAddress) {
+  return __async(this, null, function* () {
+    const cpAmmClient = new import_cp_amm_sdk.CpAmm(connection);
+    return yield cpAmmClient.fetchPoolState(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) {
+    const remainingAccounts = [
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: (0, import_cp_amm_sdk.derivePoolAuthority)()
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: poolAddress
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: userInputTokenAccount
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: userTokenOutAccount
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: poolState.tokenAVault
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: poolState.tokenBVault
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: poolState.tokenAMint
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: poolState.tokenBMint
+      },
+      {
+        isSigner: true,
+        isWritable: false,
+        pubkey: user
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenAProgram
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenBProgram
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: DAMM_V2_PROGRAM_ID
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: deriveDammV2EventAuthority()
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: DAMM_V2_PROGRAM_ID
+      }
+    ];
+    return remainingAccounts;
+  });
+}
+function createDammV2SwapPayload(amountIn, minimumSwapAmountOut) {
+  return Buffer.concat([
+    Buffer.from(DAMM_V2_SWAP_DISCRIMINATOR),
+    amountIn.toArrayLike(Buffer, "le", 8),
+    minimumSwapAmountOut.toArrayLike(Buffer, "le", 8)
+  ]);
+}
+
+// src/helpers/common.ts
+var import_spl_token2 = require("@solana/spl-token");
+var import_web33 = require("@solana/web3.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;
+    }
+    try {
+      const mintInfo = yield connection.getAccountInfo(mint);
+      if (!mintInfo) {
+        throw new Error(`Mint account not found: ${mint.toString()}`);
+      }
+      if (mintInfo.owner.equals(
+        new import_web33.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
+      )) {
+        return new import_web33.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+      } else {
+        return import_spl_token2.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;
+    }
+  });
+}
+
+// src/helpers/token.ts
+var import_spl_token3 = require("@solana/spl-token");
+var import_web34 = 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
+  );
+  try {
+    yield (0, import_spl_token3.getAccount)(connection, toAccount);
+    return { ataPubkey: toAccount, ix: void 0 };
+  } catch (e) {
+    if (e instanceof import_spl_token3.TokenAccountNotFoundError || e instanceof import_spl_token3.TokenInvalidAccountOwnerError) {
+      const ix = (0, import_spl_token3.createAssociatedTokenAccountIdempotentInstruction)(
+        payer,
+        toAccount,
+        owner,
+        tokenMint,
+        tokenProgram
+      );
+      return { ataPubkey: toAccount, ix };
+    } else {
+      console.error("Error::getOrCreateATAInstruction", e);
+      throw e;
+    }
+  }
+});
+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 wrapSOLInstruction(from, to, amount, tokenProgram = import_spl_token3.TOKEN_PROGRAM_ID) {
+  return [
+    import_web34.SystemProgram.transfer({
+      fromPubkey: from,
+      toPubkey: to,
+      lamports: amount
+    }),
+    new import_web34.TransactionInstruction({
+      keys: [
+        {
+          pubkey: to,
+          isSigner: false,
+          isWritable: true
+        }
+      ],
+      data: Buffer.from(new Uint8Array([17])),
+      programId: tokenProgram
+    })
+  ];
+}
+
+// src/helpers/dlmm.ts
+var import_web36 = require("@solana/web3.js");
+var import_bn2 = __toESM(require("bn.js"));
+var import_dlmm2 = __toESM(require("@meteora-ag/dlmm"));
+
+// src/helpers/token2022.ts
+var import_spl_token4 = require("@solana/spl-token");
+var import_web35 = require("@solana/web3.js");
+function getExtraAccountMetasForTransferHook(connection, mint) {
+  return __async(this, null, function* () {
+    const info = yield connection.getAccountInfo(mint);
+    if (!info) {
+      return [];
+    }
+    if (info.owner.equals(import_spl_token4.TOKEN_PROGRAM_ID)) {
+      return [];
+    }
+    const accountInfoWithBuffer = __spreadProps(__spreadValues({}, info), {
+      data: Buffer.from(info.data)
+    });
+    const mintInfo = (0, import_spl_token4.unpackMint)(
+      mint,
+      accountInfoWithBuffer,
+      import_spl_token4.TOKEN_2022_PROGRAM_ID
+    );
+    const transferHook = (0, import_spl_token4.getTransferHook)(mintInfo);
+    if (!transferHook) {
+      return [];
+    } else {
+      const transferWithHookIx = (0, import_spl_token4.createTransferCheckedWithTransferHookInstruction)(
+        connection,
+        import_web35.PublicKey.default,
+        mint,
+        import_web35.PublicKey.default,
+        import_web35.PublicKey.default,
+        BigInt(0),
+        mintInfo.decimals,
+        [],
+        "confirmed",
+        import_spl_token4.TOKEN_2022_PROGRAM_ID
+      );
+      return (yield transferWithHookIx).keys.slice(4);
+    }
+  });
+}
+
+// src/helpers/dlmm.ts
+function getLbPairState(connection, lbPair) {
+  return __async(this, null, function* () {
+    const dlmmClient = yield import_dlmm2.default.create(connection, lbPair, {
+      cluster: "mainnet-beta",
+      programId: new import_web36.PublicKey(DLMM_PROGRAM_ID)
+    });
+    return dlmmClient.lbPair;
+  });
+}
+function getBinArrayBitmapExtension(connection, binArray) {
+  return __async(this, null, function* () {
+    const program = (0, import_dlmm2.createProgram)(connection);
+    const account = yield connection.getAccountInfo(binArray);
+    if (!account) {
+      return null;
+    }
+    return program.coder.accounts.decode(
+      "binArrayBitmapExtension",
+      Buffer.from(account.data)
+    );
+  });
+}
+function getBitFromBinArrayIndexInBitmapExtension(binArrayIndex, state) {
+  const idx = binArrayIndex.isNeg() ? binArrayIndex.add(new import_bn2.default(1)).abs().sub(import_dlmm2.BIN_ARRAY_BITMAP_SIZE) : binArrayIndex.sub(import_dlmm2.BIN_ARRAY_BITMAP_SIZE);
+  const bitmapOffset = idx.div(import_dlmm2.BIN_ARRAY_BITMAP_SIZE);
+  const bitmap = binArrayIndex.isNeg() ? state.negativeBinArrayBitmap[bitmapOffset.toNumber()] : state.positiveBinArrayBitmap[bitmapOffset.toNumber()];
+  const { div: offsetToU64InBitmap, mod: offsetToBit } = idx.divmod(new import_bn2.default(64));
+  const { mod: offsetToU64InChunkBitmap } = offsetToU64InBitmap.divmod(
+    new import_bn2.default(8)
+  );
+  if (!bitmap) {
+    console.log(binArrayIndex.toString());
+    console.log(bitmapOffset.toString());
+  }
+  const chunkedBitmap = bitmap[offsetToU64InChunkBitmap.toNumber()];
+  return chunkedBitmap.testn(offsetToBit.toNumber());
+}
+function getNextBinArrayIndexWithLiquidity(binArrayIndex, pairState, swapForY, state) {
+  const [minBinArrayIndex, maxBinArrayIndex] = BIN_ARRAY_INDEX_BOUND;
+  const step = swapForY ? new import_bn2.default(-1) : new import_bn2.default(1);
+  while (true) {
+    if ((0, import_dlmm2.isOverflowDefaultBinArrayBitmap)(binArrayIndex)) {
+      if (state) {
+        const isBitSet = getBitFromBinArrayIndexInBitmapExtension(
+          binArrayIndex,
+          state
+        );
+        if (isBitSet) {
+          return binArrayIndex;
+        }
+      } else {
+        break;
+      }
+    } else {
+      const actualIdx = binArrayIndex.add(import_dlmm2.BIN_ARRAY_BITMAP_SIZE);
+      let { div: offsetInFullBitmap, mod: index } = actualIdx.divmod(
+        new import_bn2.default(64)
+      );
+      if (pairState.binArrayBitmap[offsetInFullBitmap.toNumber()].testn(
+        index.toNumber()
+      )) {
+        return binArrayIndex;
+      }
+    }
+    binArrayIndex = binArrayIndex.add(step);
+    if (binArrayIndex.gt(maxBinArrayIndex) || binArrayIndex.lt(minBinArrayIndex)) {
+      break;
+    }
+  }
+  return null;
+}
+function getDlmmRemainingAccounts(connection, lbPair, user, userInputTokenAccount, userTokenOutAccount, tokenXProgram, tokenYProgram, lbPairState) {
+  return __async(this, null, function* () {
+    let [binArrayBitmapExtension] = (0, import_dlmm2.deriveBinArrayBitmapExtension)(
+      lbPair,
+      DLMM_PROGRAM_ID
+    );
+    const binArrayBitmapExtensionState = yield connection.getAccountInfo(
+      binArrayBitmapExtension
+    );
+    if (!binArrayBitmapExtensionState) {
+      binArrayBitmapExtension = new import_web36.PublicKey(DLMM_PROGRAM_ID);
+    }
+    const transferHookXAccounts = yield getExtraAccountMetasForTransferHook(
+      connection,
+      lbPairState.tokenXMint
+    );
+    const transferHookYAccounts = yield getExtraAccountMetasForTransferHook(
+      connection,
+      lbPairState.tokenYMint
+    );
+    let remainingAccountsInfo = { slices: [] };
+    if (transferHookXAccounts.length > 0) {
+      remainingAccountsInfo.slices.push({
+        accountsType: AccountsType.TransferHookX,
+        length: transferHookXAccounts.length
+      });
+    }
+    if (transferHookYAccounts.length > 0) {
+      remainingAccountsInfo.slices.push({
+        accountsType: AccountsType.TransferHookY,
+        length: transferHookYAccounts.length
+      });
+    }
+    const [oracle] = (0, import_dlmm2.deriveOracle)(lbPair, DLMM_PROGRAM_ID);
+    const [eventAuthority] = (0, import_dlmm2.deriveEventAuthority)(DLMM_PROGRAM_ID);
+    const remainingAccounts = [
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: lbPair
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: binArrayBitmapExtension
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: lbPairState.reserveX
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: lbPairState.reserveY
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: userInputTokenAccount
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: userTokenOutAccount
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: lbPairState.tokenXMint
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: lbPairState.tokenYMint
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: oracle
+      },
+      {
+        isSigner: false,
+        isWritable: true,
+        pubkey: new import_web36.PublicKey(DLMM_PROGRAM_ID)
+        // host fee option
+      },
+      {
+        isSigner: true,
+        isWritable: false,
+        pubkey: user
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenXProgram
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: tokenYProgram
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: MEMO_PROGRAM_ID
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: eventAuthority
+      },
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: DLMM_PROGRAM_ID
+      }
+    ];
+    const dlmmClient = yield import_dlmm2.default.create(connection, lbPair, {
+      cluster: "mainnet-beta",
+      programId: new import_web36.PublicKey(DLMM_PROGRAM_ID)
+    });
+    const binArrays = yield dlmmClient.getBinArrayForSwap(true, 5);
+    const binArraysAccountMeta = binArrays.map((binArray) => {
+      return {
+        isSigner: false,
+        isWritable: true,
+        pubkey: binArray.publicKey
+      };
+    });
+    remainingAccounts.push(
+      ...[...transferHookXAccounts, ...transferHookYAccounts]
+    );
+    remainingAccounts.push(...binArraysAccountMeta);
+    return {
+      remainingAccounts,
+      remainingAccountsInfo
+    };
+  });
+}
+function convertAccountTypeToNumber(accountType) {
+  if (JSON.stringify(accountType) === JSON.stringify({ transferHookX: {} })) {
+    return 0;
+  }
+  if (JSON.stringify(accountType) === JSON.stringify({ transferHookY: {} })) {
+    return 1;
+  }
+  if (JSON.stringify(accountType) === JSON.stringify({ transferHookReward: {} })) {
+    return 2;
+  }
+  throw new Error(`Unknown account type: ${JSON.stringify(accountType)}`);
+}
+function createDlmmSwapPayload(amountIn, minimumSwapAmountOut, remainingAccountsInfo) {
+  const sliceCount = Buffer.alloc(4);
+  sliceCount.writeUInt32LE(remainingAccountsInfo.slices.length, 0);
+  const slicesData = Buffer.concat(
+    remainingAccountsInfo.slices.map((slice) => {
+      const sliceBuffer = Buffer.alloc(2);
+      sliceBuffer.writeUInt8(convertAccountTypeToNumber(slice.accountsType), 0);
+      sliceBuffer.writeUInt8(slice.length, 1);
+      return sliceBuffer;
+    })
+  );
+  return Buffer.concat([
+    Buffer.from(DLMM_SWAP_DISCRIMINATOR),
+    amountIn.toArrayLike(Buffer, "le", 8),
+    minimumSwapAmountOut.toArrayLike(Buffer, "le", 8),
+    sliceCount,
+    slicesData
+  ]);
+}
+
+// src/zap.ts
+var import_cp_amm_sdk2 = require("@meteora-ag/cp-amm-sdk");
+var Zap = class {
+  constructor(connection) {
+    this.connection = connection;
+    this.zapProgram = new import_anchor.Program(idl_default, { connection });
+  }
+  /////// ZAPOUT PROGRAM ///////
+  /**
+   * Executes a generic zap out operation with custom parameters.
+   *
+   * @param params - Zap out operation parameters
+   * @param params.userTokenInAccount - Token ledger account to zap out from
+   * @param params.zapOutParams - Zap out parameters
+   * @param params.remainingAccounts - Additional accounts needed for the operation
+   * @param params.ammProgram - AMM program ID to interact with
+   * @param params.preInstructions - Instructions to run before the zap out
+   * @param params.postInstructions - Instructions to run after the zap out
+   * @returns builder transaction
+   */
+  zapOut(params) {
+    return __async(this, null, function* () {
+      const {
+        zapOutParams,
+        userTokenInAccount,
+        remainingAccounts,
+        ammProgram,
+        preInstructions,
+        postInstructions
+      } = params;
+      return this.zapProgram.methods.zapOut(zapOutParams).accountsPartial({
+        userTokenInAccount,
+        ammProgram
+      }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    });
+  }
+  /**
+   * Performs a token swap using Jupiter V6 protocol as part of a zap out operation.
+   * Swaps tokens from the input token ledger to the user's output token account.
+   *
+   * @param params - Jupiter V6 swap parameters from Jupiter API
+   * @param params.user - Public key of the user performing the swap
+   * @param params.inputMint - Token mint being swapped from
+   * @param params.outputMint - Token mint being swapped to
+   * @param params.jupiterSwapResponse - Jupiter swap instruction response
+   * @param params.inputTokenProgram - Token program for the input token (defaults to SPL Token)
+   * @param params.outputTokenProgram - Token program for the output token (defaults to SPL Token)
+   * @param params.maxSwapAmount - Maximum amount of input token to swap
+   * @param params.percentageToZapOut - Percentage of input token to zap out
+   * @returns built transaction
+   */
+  zapOutThroughJupiter(params) {
+    return __async(this, null, function* () {
+      const {
+        inputTokenAccount,
+        jupiterSwapResponse,
+        maxSwapAmount,
+        percentageToZapOut,
+        preInstructions,
+        postInstructions
+      } = params;
+      const preUserTokenBalance = (yield this.connection.getTokenAccountBalance(inputTokenAccount)).value.amount;
+      const remainingAccounts = jupiterSwapResponse.swapInstruction.accounts.map(
+        (account) => {
+          let pubkey = typeof account.pubkey === "string" ? new import_web37.PublicKey(account.pubkey) : account.pubkey;
+          return {
+            pubkey,
+            isSigner: account.isSigner,
+            isWritable: account.isWritable
+          };
+        }
+      );
+      const payloadData = Buffer.from(
+        jupiterSwapResponse.swapInstruction.data,
+        "base64"
+      );
+      const offsetAmountIn = payloadData.length - AMOUNT_IN_JUP_V6_REVERSE_OFFSET;
+      return yield this.zapOut({
+        userTokenInAccount: inputTokenAccount,
+        zapOutParams: {
+          percentage: percentageToZapOut,
+          offsetAmountIn,
+          preUserTokenBalance: new import_anchor.BN(preUserTokenBalance),
+          maxSwapAmount,
+          payloadData
+        },
+        remainingAccounts,
+        ammProgram: JUP_V6_PROGRAM_ID,
+        preInstructions: preInstructions || [],
+        postInstructions: postInstructions || []
+      });
+    });
+  }
+  /**
+   * Performs a token swap using Damms V2 protocol as part of a zap out operation.
+   * Swaps tokens from the input token ledger to the user's output token account.
+   *
+   * @param params - Damms V2 swap parameters
+   * @param params.user - Public key of the user performing the swap
+   * @param params.poolAddress - Address of the pool to swap through
+   * @param params.inputMint - Token mint being swapped from
+   * @param params.inputTokenProgram - Token program for the input token (defaults to SPL Token)
+   * @param params.amountIn - Amount of input token to swap
+   * @param params.minimumSwapAmountOut - Minimum amount of output token to receive
+   * @param params.maxSwapAmount - Maximum amount of input token to swap
+   * @param params.percentageToZapOut - Percentage of input token to zap out
+   */
+  zapOutThroughDammV2(params) {
+    return __async(this, null, function* () {
+      const {
+        user,
+        poolAddress,
+        inputTokenAccount,
+        outputTokenAccount,
+        amountIn,
+        minimumSwapAmountOut,
+        maxSwapAmount,
+        percentageToZapOut,
+        preInstructions,
+        postInstructions
+      } = params;
+      const poolState = yield getDammV2Pool(this.connection, poolAddress);
+      const preUserTokenBalance = (yield this.connection.getTokenAccountBalance(inputTokenAccount)).value.amount;
+      const remainingAccounts = yield getDammV2RemainingAccounts(
+        poolAddress,
+        user,
+        inputTokenAccount,
+        outputTokenAccount,
+        (0, import_cp_amm_sdk2.getTokenProgram)(poolState.tokenAFlag),
+        (0, import_cp_amm_sdk2.getTokenProgram)(poolState.tokenBFlag),
+        poolState
+      );
+      const payloadData = createDammV2SwapPayload(amountIn, minimumSwapAmountOut);
+      const offsetAmountIn = AMOUNT_IN_DAMM_V2_OFFSET;
+      return yield this.zapOut({
+        userTokenInAccount: inputTokenAccount,
+        zapOutParams: {
+          percentage: percentageToZapOut,
+          offsetAmountIn,
+          preUserTokenBalance: new import_anchor.BN(preUserTokenBalance),
+          maxSwapAmount,
+          payloadData
+        },
+        remainingAccounts,
+        ammProgram: DAMM_V2_PROGRAM_ID,
+        preInstructions: preInstructions || [],
+        postInstructions: postInstructions || []
+      });
+    });
+  }
+  /**
+   * Performs a token swap using Dlmm protocol as part of a zap out operation.
+   * Swaps tokens from the input token ledger to the user's output token account.
+   *
+   * @param params - Dlmm swap parameters
+   * @param params.user - Public key of the user performing the swap
+   * @param params.lbPairAddress - Address of the lbPair to swap through
+   * @param params.inputMint - Token mint being swapped from
+   * @param params.inputTokenProgram - Token program for the input token (defaults to SPL Token)
+   * @param params.amountIn - Amount of input token to swap
+   * @param params.minimumSwapAmountOut - Minimum amount of output token to receive
+   * @param params.maxSwapAmount - Maximum amount of input token to swap
+   * @param params.percentageToZapOut - Percentage of input token to zap out
+   */
+  zapOutThroughDlmm(params) {
+    return __async(this, null, function* () {
+      const {
+        user,
+        lbPairAddress,
+        inputTokenAccount,
+        outputTokenAccount,
+        amountIn,
+        minimumSwapAmountOut,
+        maxSwapAmount,
+        percentageToZapOut,
+        preInstructions,
+        postInstructions
+      } = params;
+      const lbPairState = yield getLbPairState(this.connection, lbPairAddress);
+      const preUserTokenBalance = (yield this.connection.getTokenAccountBalance(inputTokenAccount)).value.amount;
+      const { remainingAccounts, remainingAccountsInfo } = yield getDlmmRemainingAccounts(
+        this.connection,
+        lbPairAddress,
+        user,
+        inputTokenAccount,
+        outputTokenAccount,
+        (0, import_cp_amm_sdk2.getTokenProgram)(lbPairState.tokenMintXProgramFlag),
+        (0, import_cp_amm_sdk2.getTokenProgram)(lbPairState.tokenMintYProgramFlag),
+        lbPairState
+      );
+      const payloadData = createDlmmSwapPayload(
+        amountIn,
+        minimumSwapAmountOut,
+        remainingAccountsInfo
+      );
+      return yield this.zapOut({
+        userTokenInAccount: inputTokenAccount,
+        zapOutParams: {
+          percentage: percentageToZapOut,
+          offsetAmountIn: AMOUNT_IN_DLMM_OFFSET,
+          preUserTokenBalance: new import_anchor.BN(preUserTokenBalance),
+          maxSwapAmount,
+          payloadData
+        },
+        remainingAccounts,
+        ammProgram: DLMM_PROGRAM_ID,
+        preInstructions: preInstructions || [],
+        postInstructions: postInstructions || []
+      });
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AMOUNT_IN_DAMM_V2_OFFSET,
+  AMOUNT_IN_DLMM_OFFSET,
+  AMOUNT_IN_JUP_V6_REVERSE_OFFSET,
+  AccountsType,
+  BIN_ARRAY_INDEX_BOUND,
+  DAMM_V2_PROGRAM_ID,
+  DAMM_V2_SWAP_DISCRIMINATOR,
+  DLMM_PROGRAM_ID,
+  DLMM_SWAP_DISCRIMINATOR,
+  JUP_V6_PROGRAM_ID,
+  MEMO_PROGRAM_ID,
+  ZAP_PROGRAM_ID,
+  Zap,
+  convertAccountTypeToNumber,
+  createDammV2SwapPayload,
+  createDlmmSwapPayload,
+  deriveDammV2EventAuthority,
+  getBinArrayBitmapExtension,
+  getBitFromBinArrayIndexInBitmapExtension,
+  getDammV2Pool,
+  getDammV2RemainingAccounts,
+  getDlmmRemainingAccounts,
+  getExtraAccountMetasForTransferHook,
+  getJupiterQuote,
+  getJupiterSwapInstruction,
+  getLbPairState,
+  getNextBinArrayIndexWithLiquidity,
+  getOrCreateATAInstruction,
+  getTokenProgramFromMint,
+  unwrapSOLInstruction,
+  wrapSOLInstruction
+});