@meteora-ag/zap-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1022 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __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/zap.ts
+import { PublicKey as PublicKey7 } from "@solana/web3.js";
+import { BN as BN3, Program } from "@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
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+
+// src/constants.ts
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import {
+  BIN_ARRAY_BITMAP_SIZE,
+  EXTENSION_BINARRAY_BITMAP_SIZE
+} from "@meteora-ag/dlmm";
+var ZAP_PROGRAM_ID = new PublicKey(idl_default.address);
+var JUP_V6_PROGRAM_ID = new PublicKey(
+  "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"
+);
+var DAMM_V2_PROGRAM_ID = new PublicKey(
+  "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
+);
+var DLMM_PROGRAM_ID = new PublicKey(
+  "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo"
+);
+var MEMO_PROGRAM_ID = new PublicKey(
+  "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
+);
+var BIN_ARRAY_INDEX_BOUND = [
+  BIN_ARRAY_BITMAP_SIZE.mul(
+    EXTENSION_BINARRAY_BITMAP_SIZE.add(new BN(1))
+  ).neg(),
+  BIN_ARRAY_BITMAP_SIZE.mul(EXTENSION_BINARRAY_BITMAP_SIZE.add(new BN(1))).sub(
+    new BN(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
+import { CpAmm, derivePoolAuthority } from "@meteora-ag/cp-amm-sdk";
+
+// src/helpers/pda.ts
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+function deriveDammV2EventAuthority() {
+  return PublicKey2.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 CpAmm(connection);
+    return yield cpAmmClient.fetchPoolState(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) {
+    const remainingAccounts = [
+      {
+        isSigner: false,
+        isWritable: false,
+        pubkey: 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
+import {
+  NATIVE_MINT,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2
+} from "@solana/spl-token";
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+function getTokenProgramFromMint(connection, mint) {
+  return __async(this, null, function* () {
+    if (mint.equals(NATIVE_MINT)) {
+      return TOKEN_PROGRAM_ID2;
+    }
+    try {
+      const mintInfo = yield connection.getAccountInfo(mint);
+      if (!mintInfo) {
+        throw new Error(`Mint account not found: ${mint.toString()}`);
+      }
+      if (mintInfo.owner.equals(
+        new PublicKey3("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb")
+      )) {
+        return new PublicKey3("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+      } else {
+        return TOKEN_PROGRAM_ID2;
+      }
+    } catch (error) {
+      console.warn(
+        `Failed to determine token program for ${mint.toString()}, defaulting to TOKEN_PROGRAM_ID:`,
+        error
+      );
+      return TOKEN_PROGRAM_ID2;
+    }
+  });
+}
+
+// src/helpers/token.ts
+import {
+  createAssociatedTokenAccountIdempotentInstruction,
+  createCloseAccountInstruction,
+  getAccount,
+  getAssociatedTokenAddressSync,
+  NATIVE_MINT as NATIVE_MINT2,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3,
+  TokenAccountNotFoundError,
+  TokenInvalidAccountOwnerError
+} 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
+  );
+  try {
+    yield getAccount(connection, toAccount);
+    return { ataPubkey: toAccount, ix: void 0 };
+  } catch (e) {
+    if (e instanceof TokenAccountNotFoundError || e instanceof TokenInvalidAccountOwnerError) {
+      const ix = 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 = getAssociatedTokenAddressSync(
+    NATIVE_MINT2,
+    owner,
+    allowOwnerOffCurve
+  );
+  if (wSolATAAccount) {
+    const closedWrappedSolInstruction = createCloseAccountInstruction(
+      wSolATAAccount,
+      receiver,
+      owner,
+      [],
+      TOKEN_PROGRAM_ID3
+    );
+    return closedWrappedSolInstruction;
+  }
+  return null;
+}
+function wrapSOLInstruction(from, to, amount, tokenProgram = TOKEN_PROGRAM_ID3) {
+  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
+    })
+  ];
+}
+
+// src/helpers/dlmm.ts
+import { PublicKey as PublicKey6 } from "@solana/web3.js";
+import BN2 from "bn.js";
+import DLMM, {
+  isOverflowDefaultBinArrayBitmap,
+  BIN_ARRAY_BITMAP_SIZE as BIN_ARRAY_BITMAP_SIZE2,
+  createProgram,
+  deriveBinArrayBitmapExtension,
+  deriveOracle,
+  deriveEventAuthority
+} from "@meteora-ag/dlmm";
+
+// src/helpers/token2022.ts
+import {
+  createTransferCheckedWithTransferHookInstruction,
+  getTransferHook,
+  TOKEN_2022_PROGRAM_ID as TOKEN_2022_PROGRAM_ID2,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4,
+  unpackMint
+} from "@solana/spl-token";
+import { PublicKey as PublicKey5 } from "@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(TOKEN_PROGRAM_ID4)) {
+      return [];
+    }
+    const accountInfoWithBuffer = __spreadProps(__spreadValues({}, info), {
+      data: Buffer.from(info.data)
+    });
+    const mintInfo = unpackMint(
+      mint,
+      accountInfoWithBuffer,
+      TOKEN_2022_PROGRAM_ID2
+    );
+    const transferHook = getTransferHook(mintInfo);
+    if (!transferHook) {
+      return [];
+    } else {
+      const transferWithHookIx = createTransferCheckedWithTransferHookInstruction(
+        connection,
+        PublicKey5.default,
+        mint,
+        PublicKey5.default,
+        PublicKey5.default,
+        BigInt(0),
+        mintInfo.decimals,
+        [],
+        "confirmed",
+        TOKEN_2022_PROGRAM_ID2
+      );
+      return (yield transferWithHookIx).keys.slice(4);
+    }
+  });
+}
+
+// src/helpers/dlmm.ts
+function getLbPairState(connection, lbPair) {
+  return __async(this, null, function* () {
+    const dlmmClient = yield DLMM.create(connection, lbPair, {
+      cluster: "mainnet-beta",
+      programId: new PublicKey6(DLMM_PROGRAM_ID)
+    });
+    return dlmmClient.lbPair;
+  });
+}
+function getBinArrayBitmapExtension(connection, binArray) {
+  return __async(this, null, function* () {
+    const program = 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 BN2(1)).abs().sub(BIN_ARRAY_BITMAP_SIZE2) : binArrayIndex.sub(BIN_ARRAY_BITMAP_SIZE2);
+  const bitmapOffset = idx.div(BIN_ARRAY_BITMAP_SIZE2);
+  const bitmap = binArrayIndex.isNeg() ? state.negativeBinArrayBitmap[bitmapOffset.toNumber()] : state.positiveBinArrayBitmap[bitmapOffset.toNumber()];
+  const { div: offsetToU64InBitmap, mod: offsetToBit } = idx.divmod(new BN2(64));
+  const { mod: offsetToU64InChunkBitmap } = offsetToU64InBitmap.divmod(
+    new BN2(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 BN2(-1) : new BN2(1);
+  while (true) {
+    if (isOverflowDefaultBinArrayBitmap(binArrayIndex)) {
+      if (state) {
+        const isBitSet = getBitFromBinArrayIndexInBitmapExtension(
+          binArrayIndex,
+          state
+        );
+        if (isBitSet) {
+          return binArrayIndex;
+        }
+      } else {
+        break;
+      }
+    } else {
+      const actualIdx = binArrayIndex.add(BIN_ARRAY_BITMAP_SIZE2);
+      let { div: offsetInFullBitmap, mod: index } = actualIdx.divmod(
+        new BN2(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] = deriveBinArrayBitmapExtension(
+      lbPair,
+      DLMM_PROGRAM_ID
+    );
+    const binArrayBitmapExtensionState = yield connection.getAccountInfo(
+      binArrayBitmapExtension
+    );
+    if (!binArrayBitmapExtensionState) {
+      binArrayBitmapExtension = new PublicKey6(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] = deriveOracle(lbPair, DLMM_PROGRAM_ID);
+    const [eventAuthority] = 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 PublicKey6(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 DLMM.create(connection, lbPair, {
+      cluster: "mainnet-beta",
+      programId: new PublicKey6(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
+import { getTokenProgram } from "@meteora-ag/cp-amm-sdk";
+var Zap = class {
+  constructor(connection) {
+    this.connection = connection;
+    this.zapProgram = new 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 PublicKey7(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 BN3(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,
+        getTokenProgram(poolState.tokenAFlag),
+        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 BN3(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,
+        getTokenProgram(lbPairState.tokenMintXProgramFlag),
+        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 BN3(preUserTokenBalance),
+          maxSwapAmount,
+          payloadData
+        },
+        remainingAccounts,
+        ammProgram: DLMM_PROGRAM_ID,
+        preInstructions: preInstructions || [],
+        postInstructions: postInstructions || []
+      });
+    });
+  }
+};
+export {
+  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
+};