@meteora-ag/zap-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,381 @@
+import * as _solana_web3_js from '@solana/web3.js';
+import { PublicKey, AccountMeta, TransactionInstruction, Connection, Transaction } from '@solana/web3.js';
+import { IdlTypes, Program } from '@coral-xyz/anchor';
+import BN from 'bn.js';
+import { PoolState } from '@meteora-ag/cp-amm-sdk';
+import { LbPair, BinArrayBitmapExtension, RemainingAccountInfo } from '@meteora-ag/dlmm';
+
+/**
+ * Program IDL in camelCase format in order to be used in JS/TS.
+ *
+ * Note that this is only a type helper and is not the actual IDL. The original
+ * IDL can be found at `target/idl/zap.json`.
+ */
+type Zap$1 = {
+    address: "zapvX9M3uf5pvy4wRPAbQgdQsM1xmuiFnkfHKPvwMiz";
+    metadata: {
+        name: "zap";
+        version: "0.1.0";
+        spec: "0.1.0";
+        description: "Created with Anchor";
+    };
+    instructions: [
+        {
+            name: "zapOut";
+            discriminator: [155, 108, 185, 112, 104, 210, 161, 64];
+            accounts: [
+                {
+                    name: "userTokenInAccount";
+                    writable: true;
+                },
+                {
+                    name: "ammProgram";
+                }
+            ];
+            args: [
+                {
+                    name: "params";
+                    type: {
+                        defined: {
+                            name: "zapOutParameters";
+                        };
+                    };
+                }
+            ];
+        }
+    ];
+    errors: [
+        {
+            code: 6000;
+            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: "offsetAmountIn";
+                        type: "u16";
+                    },
+                    {
+                        name: "preUserTokenBalance";
+                        type: "u64";
+                    },
+                    {
+                        name: "maxSwapAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "payloadData";
+                        type: "bytes";
+                    }
+                ];
+            };
+        }
+    ];
+};
+
+type ZapProgram = Program<Zap$1>;
+type ZapOutParameters = IdlTypes<Zap$1>["zapOutParameters"];
+type ZapOutParams = {
+    userTokenInAccount: PublicKey;
+    zapOutParams: ZapOutParameters;
+    remainingAccounts: AccountMeta[];
+    ammProgram: PublicKey;
+    preInstructions: TransactionInstruction[];
+    postInstructions: TransactionInstruction[];
+};
+type ZapOutThroughDammV2Params = {
+    user: PublicKey;
+    poolAddress: PublicKey;
+    inputTokenAccount: PublicKey;
+    outputTokenAccount: PublicKey;
+    amountIn: BN;
+    minimumSwapAmountOut: BN;
+    maxSwapAmount: BN;
+    percentageToZapOut: number;
+    preInstructions?: TransactionInstruction[];
+    postInstructions?: TransactionInstruction[];
+};
+type ZapOutThroughDlmmParams = {
+    user: PublicKey;
+    lbPairAddress: PublicKey;
+    inputTokenAccount: PublicKey;
+    outputTokenAccount: PublicKey;
+    amountIn: BN;
+    minimumSwapAmountOut: BN;
+    maxSwapAmount: BN;
+    percentageToZapOut: number;
+    preInstructions?: TransactionInstruction[];
+    postInstructions?: TransactionInstruction[];
+};
+interface ZapOutThroughJupiterParams {
+    inputTokenAccount: PublicKey;
+    jupiterSwapResponse: JupiterSwapInstructionResponse;
+    maxSwapAmount: BN;
+    percentageToZapOut: number;
+    preInstructions?: TransactionInstruction[];
+    postInstructions?: TransactionInstruction[];
+}
+interface JupiterQuoteResponse {
+    inputMint: string;
+    inAmount: string;
+    outputMint: string;
+    outAmount: string;
+    otherAmountThreshold: string;
+    swapMode: string;
+    slippageBps: number;
+    platformFee: any;
+    priceImpactPct: string;
+    routePlan: JupiterRoutePlan[];
+    contextSlot: number;
+    timeTaken: number;
+    swapUsdValue: string;
+    simplerRouteUsed: boolean;
+    mostReliableAmmsQuoteReport: {
+        info: Record<string, string>;
+    };
+    useIncurredSlippageForQuoting: any;
+    otherRoutePlans: any;
+    aggregatorVersion: any;
+}
+interface JupiterRoutePlan {
+    swapInfo: any;
+    percent: number;
+    bps: number;
+}
+interface JupiterInstruction {
+    programId: string;
+    accounts: any[];
+    data: string;
+}
+interface JupiterSwapInstructionResponse {
+    tokenLedgerInstruction: JupiterInstruction | null;
+    computeBudgetInstructions: JupiterInstruction[];
+    setupInstructions: JupiterInstruction[];
+    swapInstruction: JupiterInstruction;
+    cleanupInstruction: JupiterInstruction;
+    otherInstructions: JupiterInstruction[];
+    addressLookupTableAddresses: string[];
+    prioritizationFeeLamports: number;
+    computeUnitLimit: number;
+    prioritizationType: {
+        computeBudget: {
+            microLamports: number;
+            estimatedMicroLamports: number;
+        };
+    };
+    simulationSlot: any;
+    dynamicSlippageReport: any;
+    simulationError: any;
+    addressesByLookupTableAddress: any;
+    blockhashWithMetadata: {
+        blockhash: number[];
+        lastValidBlockHeight: number;
+        fetchedAt: {
+            secs_since_epoch: number;
+            nanos_since_epoch: number;
+        };
+    };
+}
+
+declare class Zap {
+    private connection;
+    private zapProgram;
+    constructor(connection: Connection);
+    /**
+     * 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: ZapOutParams): Promise<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: ZapOutThroughJupiterParams): Promise<Transaction>;
+    /**
+     * 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: ZapOutThroughDammV2Params): Promise<Transaction>;
+    /**
+     * 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: ZapOutThroughDlmmParams): Promise<Transaction>;
+}
+
+declare function getJupiterQuote(inputMint: PublicKey, outputMint: PublicKey, amount: BN, maxAccounts: number, slippageBps: number, onlyDirectRoutes: boolean, restrictIntermediateTokens: boolean, apiUrl?: string, apiKey?: string): Promise<JupiterQuoteResponse>;
+declare function getJupiterSwapInstruction(userPublicKey: PublicKey, quoteResponse: any, apiUrl?: string, apiKey?: string): Promise<JupiterSwapInstructionResponse>;
+
+declare function getDammV2Pool(connection: Connection, poolAddress: PublicKey): Promise<PoolState>;
+declare function getDammV2RemainingAccounts(poolAddress: PublicKey, user: PublicKey, userInputTokenAccount: PublicKey, userTokenOutAccount: PublicKey, tokenAProgram: PublicKey | undefined, tokenBProgram: PublicKey | undefined, poolState: PoolState): Promise<Array<{
+    isSigner: boolean;
+    isWritable: boolean;
+    pubkey: PublicKey;
+}>>;
+/**
+ * Creates payload data for DAMM V2 swap instruction
+ * @param amountIn - The input amount for the swap
+ * @param minimumSwapAmountOut - The minimum amount out for the swap
+ * @returns Buffer containing the payload data
+ * Discriminator (8 bytes): [248, 198, 158, 145, 225, 117, 135, 200] - identifies this as a DAMM V2 swap instruction.
+ * Amount In (8 bytes): u64 little-endian - the swap amount (modified by zap program at runtime).
+ * Minimum Amount Out (8 bytes): u64 little-endian - slippage protection (static value).
+ */
+declare function createDammV2SwapPayload(amountIn: BN, minimumSwapAmountOut: BN): Buffer;
+
+declare function deriveDammV2EventAuthority(): PublicKey;
+
+declare function getTokenProgramFromMint(connection: Connection, mint: PublicKey): Promise<PublicKey>;
+
+/**
+ * Get or create a token account
+ * @param connection - Solana connection
+ * @param tokenMint - The mint of the token
+ * @param owner - The owner of the token
+ * @param payer - The payer of the token
+ * @param allowOwnerOffCurve - Whether to allow the owner to be off curve
+ * @param tokenProgram - The token program to use (defaults to TOKEN_PROGRAM_ID)
+ * @returns The token account and the instruction to create it if it doesn't exist
+ */
+declare const getOrCreateATAInstruction: (connection: Connection, tokenMint: PublicKey, owner: PublicKey, payer: PublicKey, allowOwnerOffCurve: boolean | undefined, tokenProgram: PublicKey) => Promise<{
+    ataPubkey: PublicKey;
+    ix?: TransactionInstruction;
+}>;
+/**
+ * Unwrap SOL instruction
+ * @param owner - The owner of the SOL
+ * @param receiver - The receiver of the SOL
+ * @param allowOwnerOffCurve - Whether to allow the owner to be off curve
+ * @returns The unwrap SOL instruction
+ */
+declare function unwrapSOLInstruction(owner: PublicKey, receiver: PublicKey, allowOwnerOffCurve?: boolean): TransactionInstruction | null;
+/**
+ * Wrap SOL instruction
+ * @param from - The from address
+ * @param to - The to address
+ * @param amount - The amount to wrap
+ * @param tokenProgram - The token program to use (defaults to TOKEN_PROGRAM_ID)
+ * @returns The wrap SOL instruction
+ */
+declare function wrapSOLInstruction(from: PublicKey, to: PublicKey, amount: bigint, tokenProgram?: PublicKey): TransactionInstruction[];
+
+declare function getLbPairState(connection: Connection, lbPair: PublicKey): Promise<LbPair>;
+declare function getBinArrayBitmapExtension(connection: Connection, binArray: PublicKey): Promise<BinArrayBitmapExtension | null>;
+declare function getBitFromBinArrayIndexInBitmapExtension(binArrayIndex: BN, state: BinArrayBitmapExtension): boolean;
+declare function getNextBinArrayIndexWithLiquidity(binArrayIndex: BN, pairState: LbPair, swapForY: boolean, state: BinArrayBitmapExtension | null): BN | null;
+declare function getDlmmRemainingAccounts(connection: Connection, lbPair: PublicKey, user: PublicKey, userInputTokenAccount: PublicKey, userTokenOutAccount: PublicKey, tokenXProgram: PublicKey, tokenYProgram: PublicKey, lbPairState: LbPair): Promise<{
+    remainingAccounts: AccountMeta[];
+    remainingAccountsInfo: RemainingAccountInfo;
+}>;
+declare function convertAccountTypeToNumber(accountType: object): number;
+/**
+ * Creates payload data for DLMM swap instruction
+ * @param amountIn - The input amount for the swap
+ * @param minimumSwapAmountOut - The minimum amount out for the swap
+ * @param remainingAccountsInfo - Information about remaining accounts including slices
+ * @returns Buffer containing the payload data
+ * Discriminator (8 bytes): [65, 75, 63, 76, 235, 91, 91, 136] - identifies this as a DLMM swap2 instruction.
+ * Amount In (8 bytes): u64 little-endian - the swap amount (modified by zap program at runtime).
+ * Minimum Amount Out (8 bytes): u64 little-endian - slippage protection (static value).
+ * Slice Count (4 bytes): u32 little-endian - number of account type slices.
+ * Slices Data (2 bytes per slice): Each slice contains:
+ * -> Account Type (1 byte): enum value (0=TransferHookX, 1=TransferHookY, 2=TransferHookReward).
+ * -> Length (1 byte): number of accounts in this slice.
+ */
+declare function createDlmmSwapPayload(amountIn: BN, minimumSwapAmountOut: BN, remainingAccountsInfo: RemainingAccountInfo): Buffer;
+
+declare function getExtraAccountMetasForTransferHook(connection: Connection, mint: PublicKey): Promise<_solana_web3_js.AccountMeta[]>;
+
+declare const ZAP_PROGRAM_ID: PublicKey;
+declare const JUP_V6_PROGRAM_ID: PublicKey;
+declare const DAMM_V2_PROGRAM_ID: PublicKey;
+declare const DLMM_PROGRAM_ID: PublicKey;
+declare const MEMO_PROGRAM_ID: PublicKey;
+declare const BIN_ARRAY_INDEX_BOUND: BN[];
+declare const AccountsType: {
+    TransferHookX: {
+        transferHookX: {};
+    };
+    TransferHookY: {
+        transferHookY: {};
+    };
+    TransferHookReward: {
+        transferHookReward: {};
+    };
+};
+declare const DLMM_SWAP_DISCRIMINATOR: number[];
+declare const AMOUNT_IN_DLMM_OFFSET = 8;
+declare const AMOUNT_IN_JUP_V6_REVERSE_OFFSET = 19;
+declare const AMOUNT_IN_DAMM_V2_OFFSET = 8;
+declare const DAMM_V2_SWAP_DISCRIMINATOR: number[];
+
+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, type JupiterInstruction, type JupiterQuoteResponse, type JupiterRoutePlan, type JupiterSwapInstructionResponse, MEMO_PROGRAM_ID, ZAP_PROGRAM_ID, Zap, type ZapOutParameters, type ZapOutParams, type ZapOutThroughDammV2Params, type ZapOutThroughDlmmParams, type ZapOutThroughJupiterParams, type ZapProgram, convertAccountTypeToNumber, createDammV2SwapPayload, createDlmmSwapPayload, deriveDammV2EventAuthority, getBinArrayBitmapExtension, getBitFromBinArrayIndexInBitmapExtension, getDammV2Pool, getDammV2RemainingAccounts, getDlmmRemainingAccounts, getExtraAccountMetasForTransferHook, getJupiterQuote, getJupiterSwapInstruction, getLbPairState, getNextBinArrayIndexWithLiquidity, getOrCreateATAInstruction, getTokenProgramFromMint, unwrapSOLInstruction, wrapSOLInstruction };