@meteora-ag/zap-sdk 1.1.0-rc.8 → 1.1.0

package/dist/index.d.mts

@@ -13,7 +13,7 @@ import { PoolState } from '@meteora-ag/cp-amm-sdk';
  * IDL can be found at `target/idl/zap.json`.
  */
 type Zap$1 = {
-    address: "TzaptpzVczx3Q3rwujjXdhx1HFBXLP7UApACiqWujtA";
+    address: "zapvX9M3uf5pvy4wRPAbQgdQsM1xmuiFnkfHKPvwMiz";
     metadata: {
         name: "zap";
         version: "0.2.0";
@@ -341,7 +341,7 @@ type Zap$1 = {
                     name: "position";
                     docs: [
                         "user position",
-                        "Check it is different from owner to advoid user to pass owner address wrongly"
+                        "Check it is different from owner to avoid user to pass owner address wrongly"
                     ];
                     writable: true;
                     signer: true;
@@ -516,6 +516,16 @@ type Zap$1 = {
             code: 6006;
             name: "exceededSlippage";
             msg: "Exceeded slippage tolerance";
+        },
+        {
+            code: 6007;
+            name: "invalidDlmmZapInParameters";
+            msg: "Invalid dlmm zap in parameters";
+        },
+        {
+            code: 6008;
+            name: "unsupportedFeeMode";
+            msg: "Unsupported fee mode";
         }
     ];
     types: [
@@ -1675,8 +1685,7 @@ type GetZapInDammV2DirectPoolParams = {
     inputTokenMint: PublicKey;
     amountIn: BN;
     pool: PublicKey;
-    position: PublicKey;
-    positionNftAccount: PublicKey;
+    positionNftMint: PublicKey;
     maxSqrtPriceChangeBps: number;
     maxTransferAmountExtendPercentage: number;
     maxAccounts: number;
@@ -1696,8 +1705,7 @@ type GetZapInDammV2IndirectPoolParams = {
     inputTokenMint: PublicKey;
     amountIn: BN;
     pool: PublicKey;
-    position: PublicKey;
-    positionNftAccount: PublicKey;
+    positionNftMint: PublicKey;
     maxSqrtPriceChangeBps: number;
     maxTransferAmountExtendPercentage: number;
     maxAccounts: number;
@@ -1776,7 +1784,28 @@ declare enum DlmmSingleSided {
     X = 0,
     Y = 1
 }
-interface DirectSwapEstimate {
+interface EstimateDlmmDirectSwapParams {
+    amountIn: BN;
+    inputTokenMint: PublicKey;
+    lbPair: PublicKey;
+    connection: Connection;
+    swapSlippageBps: number;
+    minDeltaId: number;
+    maxDeltaId: number;
+    strategy: StrategyType;
+    singleSided?: DlmmSingleSided;
+}
+interface DlmmDirectSwapEstimateContext {
+    amountIn: BN;
+    inputTokenMint: PublicKey;
+    lbPair: PublicKey;
+    swapSlippageBps: number;
+    minDeltaId: number;
+    maxDeltaId: number;
+    strategy: StrategyType;
+    singleSided?: DlmmSingleSided;
+}
+interface DlmmDirectEstimateResult {
     swapType: DlmmSwapType;
     swapAmount: BN;
     expectedOutput: BN;
@@ -1784,7 +1813,44 @@ interface DirectSwapEstimate {
     postSwapY: BN;
     quote: SwapQuoteResult | null;
 }
-interface IndirectSwapEstimate {
+interface DlmmDirectSwapEstimate {
+    result: DlmmDirectEstimateResult;
+    context: DlmmDirectSwapEstimateContext;
+}
+interface EstimateDlmmRebalanceSwapParams {
+    position: PublicKey;
+    lbPair: PublicKey;
+    connection: Connection;
+    minDeltaId: number;
+    maxDeltaId: number;
+    swapSlippageBps: number;
+    strategy: StrategyType;
+}
+interface DlmmDirectRebalanceEstimateContext {
+    lbPair: PublicKey;
+    position: PublicKey;
+    swapSlippageBps: number;
+    minDeltaId: number;
+    maxDeltaId: number;
+    strategy: StrategyType;
+    singleSided?: DlmmSingleSided;
+}
+interface DlmmDirectRebalanceEstimate {
+    result: DlmmDirectEstimateResult;
+    context: DlmmDirectRebalanceEstimateContext;
+}
+interface EstimateDlmmIndirectSwapParams {
+    amountIn: BN;
+    inputTokenMint: PublicKey;
+    lbPair: PublicKey;
+    connection: Connection;
+    swapSlippageBps: number;
+    minDeltaId: number;
+    maxDeltaId: number;
+    strategy: StrategyType;
+    singleSided?: DlmmSingleSided;
+}
+interface DlmmIndirectSwapEstimateResult {
     swapToX: JupiterQuoteResponse | null;
     swapToY: JupiterQuoteResponse | null;
     swapAmountToX: BN;
@@ -1792,9 +1858,23 @@ interface IndirectSwapEstimate {
     postSwapX: BN;
     postSwapY: BN;
 }
+interface DlmmIndirectSwapEstimateContext {
+    amountIn: BN;
+    inputTokenMint: PublicKey;
+    lbPair: PublicKey;
+    swapSlippageBps: number;
+    minDeltaId: number;
+    maxDeltaId: number;
+    strategy: StrategyType;
+    singleSided?: DlmmSingleSided;
+}
+interface DlmmIndirectSwapEstimate {
+    result: DlmmIndirectSwapEstimateResult;
+    context: DlmmIndirectSwapEstimateContext;
+}
 interface RebalanceDlmmPositionParams {
-    lbPairAddress: PublicKey;
-    positionAddress: PublicKey;
+    lbPair: PublicKey;
+    position: PublicKey;
     user: PublicKey;
     minDeltaId: number;
     maxDeltaId: number;
@@ -1802,7 +1882,7 @@ interface RebalanceDlmmPositionParams {
     swapSlippageBps: number;
     strategy: StrategyType;
     favorXInActiveId: boolean;
-    directSwapEstimate: DirectSwapEstimate;
+    directSwapEstimate: DlmmDirectEstimateResult;
     maxAccounts?: number;
 }
 interface RebalanceDlmmPositionResponse {
@@ -1824,12 +1904,6 @@ interface RebalanceDlmmPositionResponse {
         };
     };
 }
-interface EstimateBalancedSwapThroughJupiterAndDlmmParams {
-    lbPairAddress: PublicKey;
-    tokenXAmount: BN;
-    tokenYAmount: BN;
-    slippage: number;
-}
 interface GetZapInDlmmIndirectParams {
     user: PublicKey;
     lbPair: PublicKey;
@@ -1841,9 +1915,9 @@ interface GetZapInDlmmIndirectParams {
     strategy: StrategyType;
     favorXInActiveId: boolean;
     maxAccounts: number;
-    slippageBps: number;
+    swapSlippageBps: number;
     maxTransferAmountExtendPercentage: number;
-    indirectSwapEstimate: IndirectSwapEstimate;
+    indirectSwapEstimate: DlmmIndirectSwapEstimateResult;
     singleSided?: DlmmSingleSided;
 }
 interface GetZapInDlmmDirectParams {
@@ -1857,9 +1931,9 @@ interface GetZapInDlmmDirectParams {
     strategy: StrategyType;
     favorXInActiveId: boolean;
     maxAccounts: number;
-    slippageBps: number;
+    swapSlippageBps: number;
     maxTransferAmountExtendPercentage: number;
-    directSwapEstimate: DirectSwapEstimate;
+    directSwapEstimate: DlmmDirectEstimateResult;
     singleSided?: DlmmSingleSided;
 }
 type ZapInDlmmIndirectPoolParam = {
@@ -1929,11 +2003,146 @@ declare class Zap {
     private resetOrInitializeLedgerAccount;
     private zapInDlmmForInitializedPosition;
     private zapInDlmmForUninitializedPosition;
+    /**
+     * Get the parameters for building a DAMM v2 zap in transaction through a direct route
+     * Direct route means the input token matches either tokenA or tokenB in the pool
+     * so we can swap directly using the pool when it's the optimal route
+     *
+     * @param params.user - The user's public key
+     * @param params.pool - The pool's public key
+     * @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
+     * @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
+     * @throws if fail to get jupiter quote or jupiter swap instruction
+     */
     getZapInDammV2DirectPoolParams(params: GetZapInDammV2DirectPoolParams): Promise<ZapInDammV2DirectPoolParam>;
+    /**
+     * Get the parameters for building a DAMM v2 zap in transaction through an indirect route
+     * Indirect route means the input token does not match either tokenA or tokenB in the pool
+     * so we swap the input token to tokenA and tokenB through Jupiter
+     *
+     * @param params.user - The user's public key
+     * @param params.pool - The pool's public key
+     * @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
+     * @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
+     * @throws if fail to get jupiter quote or jupiter swap instruction
+     */
     getZapInDammV2IndirectPoolParams(params: GetZapInDammV2IndirectPoolParams): Promise<ZapInDammV2IndirectPoolParam | null>;
+    /**
+     * Build DAMM v2 zap-in transaction
+     *
+     * @param params.user - The user's public key
+     * @param params.pool - The pool's public key
+     * @param params.position - The position's public key
+     * @param params.positionNftAccount - The position NFT account's public key
+     * @param params.tokenAMint - The token A mint
+     * @param params.tokenBMint - The token B mint
+     * @param params.tokenAVault - The token A vault
+     * @param params.tokenBVault - The token B vault
+     * @param params.tokenAProgram - The token A program
+     * @param params.tokenBProgram - The token B program
+     * @param params.isDirectPool - Whether this is a direct pool route
+     * @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.swapTransactions - Swap transactions to execute
+     * @param params.cleanUpInstructions - Instructions to run after the zap in
+     * @returns Response containing transaction components
+     */
     buildZapInDammV2Transaction(params: ZapInDammV2DirectPoolParam | ZapInDammV2IndirectPoolParam): Promise<ZapInDammV2Response>;
+    /**
+     * Get the parameters for building a DLMM zap in transaction through a direct route
+     * Direct route means the input token matches either tokenX or tokenY in the pool
+     * so we can use the pool directly for swaps when it's the optimal route
+     *
+     * @param params.user - The user's public key
+     * @param params.lbPair - The DLMM pool's public key
+     * @param params.amountIn - The amount of input token
+     * @param params.inputTokenMint - The input token mint
+     * @param params.minDeltaId - The bin delta relative to the active bin for the lower bin position
+     * @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 - 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
+     * @param params.directSwapEstimate - The result from the direct swap estimate
+     * @param params.singleSided - Optional single-sided deposit mode (X or Y only) - default is non-single-sided
+     * @returns The zap-in transaction parameters for a DLMM direct pool
+     * @throws if input token mint does not match either tokenX or tokenY in the pool
+     * @throws if fail to get jupiter quote or jupiter swap instruction
+     */
     getZapInDlmmDirectParams(params: GetZapInDlmmDirectParams): Promise<ZapInDlmmDirectPoolParam>;
+    /**
+     * Get the parameters for building a DLMM zap in transaction through an indirect route
+     * Indirect route means the input token does not match either tokenX or tokenY in the pool
+     * so we swap the input token to tokenX and tokenY through Jupiter when needed
+     *
+     * @param params.user - The user's public key
+     * @param params.lbPair - The DLMM pool's public key
+     * @param params.amountIn - The amount of input token
+     * @param params.inputTokenMint - The input token mint
+     * @param params.minDeltaId - The bin delta relative to the active bin for the lower bin position
+     * @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.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
+     * @param params.singleSided - Optional single-sided deposit mode (X or Y only) - default is non-single-sided
+     * @returns The zap-in transaction parameters for a DLMM indirect pool
+     * @throws if input token mint matches either tokenX or tokenY in the pool
+     * @throws if fail to get jupiter quote or jupiter swap instruction
+     */
     getZapInDlmmIndirectParams(params: GetZapInDlmmIndirectParams): Promise<ZapInDlmmIndirectPoolParam>;
+    /**
+     * Builds a DLMM zap-in transaction
+     *
+     * @param params.user - The user's public key
+     * @param params.lbPair - The DLMM pool's public key
+     * @param params.position - The position's public key
+     * @param params.tokenXMint - The token X mint
+     * @param params.tokenYMint - The token Y mint
+     * @param params.tokenXProgram - The token X program
+     * @param params.tokenYProgram - The token Y program
+     * @param params.activeId - The active bin ID
+     * @param params.minDeltaId - The bin delta relative to the active bin for the lower bin position
+     * @param params.maxDeltaId - The bin delta relative to the active bin for the upper bin position
+     * @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.swapTransactions - Swap transactions to execute
+     * @param params.cleanUpInstructions - Instructions to run after the zap in
+     * @param params.binArrays - The bin arrays required for the position
+     * @param params.binArrayBitmapExtension - The bin array bitmap extension account if it exists
+     * @param params.isDirectRoute - Whether this is a direct route
+     * @param params.singleSided - Optional single-sided deposit mode (X or Y only) - default is non-single-sided
+     * @returns Response containing transaction components
+     */
     buildZapInDlmmTransaction(params: (ZapInDlmmIndirectPoolParam | ZapInDlmmDirectPoolParam) & {
         position: PublicKey;
     }): Promise<ZapInDlmmResponse>;
@@ -1954,6 +2163,7 @@ declare class Zap {
      * @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 Response containing transactions and estimation details
+     * @throws if fail to get jupiter quote or jupiter swap instruction
      */
     rebalanceDlmmPosition(params: RebalanceDlmmPositionParams): Promise<RebalanceDlmmPositionResponse>;
     /**
@@ -2132,53 +2342,59 @@ declare function getExtraAccountMetasForTransferHook(connection: Connection, min
  * First tries a 50:50 split (inputToken -> X and inputToken -> Y)
  * then refines using binary search if the resulting X and Y values are not balanced enough.
  *
- * @param inputTokenAmount - The amount of input token
- * @param inputTokenMint - The mint of the input token
- * @param lbPair - The LB pair address
- * @param connection - A connection to a fullnode JSON RPC endpoint
- * @param swapSlippageBps - Slippage tolerance in basis points
- * @param minDeltaId - Minimum bin delta from active bin
- * @param maxDeltaId - Maximum bin delta from active bin
- * @param strategy - Strategy type for the position
- * @param singleSided - If provided, swaps all input to the specified token (X or Y) instead of balancing
+ * @param params - Parameters for estimating indirect swap
+ * @param params.amountIn - The amount of input token
+ * @param params.inputTokenMint - The mint of the input token
+ * @param params.lbPair - The LB pair address
+ * @param params.connection - A connection to a fullnode JSON RPC endpoint
+ * @param params.swapSlippageBps - Slippage tolerance in basis points
+ * @param params.minDeltaId - Minimum bin delta from active bin
+ * @param params.maxDeltaId - Maximum bin delta from active bin
+ * @param params.strategy - Strategy type for the position
+ * @param params.singleSided - Optional single-sided deposit mode (X or Y only) - default is non-single-sided
  * @returns IndirectSwapEstimate with swap details and post-swap token amounts
+ * @throws if inputTokenMint matches any token in the DLMM pool
+ * @throws if failed to get Jupiter swap quote
  */
-declare function estimateDlmmIndirectSwap(inputTokenAmount: BN, inputTokenMint: PublicKey, lbPair: PublicKey, connection: Connection, swapSlippageBps: number, minDeltaId: number, maxDeltaId: number, strategy: StrategyType, singleSided?: DlmmSingleSided): Promise<IndirectSwapEstimate>;
+declare function estimateDlmmIndirectSwap({ amountIn, inputTokenMint, lbPair, connection, swapSlippageBps, minDeltaId, maxDeltaId, strategy, singleSided, }: EstimateDlmmIndirectSwapParams): Promise<DlmmIndirectSwapEstimate>;
 /**
  * Calculate optimal swap amount for zap-in deposits (single token input)
  *
  * For balanced deposits: Balances single token input to achieve equal value by swapping
  * For single-sided deposits: Swaps all input to the specified target token (X or Y)
  *
- * @param tokenAmount - The amount of input token
- * @param isInputTokenX - Whether the input token is tokenX (true) or tokenY (false)
- * @param lbPair - The LB pair address
- * @param connection - A connection to a fullnode JSON RPC endpoint
- * @param swapSlippageBps - Slippage tolerance in basis points
- * @param minDeltaId - Minimum bin delta from active bin
- * @param maxDeltaId - Maximum bin delta from active bin
- * @param strategy - Strategy type for the position
- * @param singleSided - If provided, swaps all input to the specified token (X or Y) instead of balancing
+ * @param params - Parameters for estimating direct swap
+ * @param params.tokenAmount - The amount of input token
+ * @param params.isInputTokenX - Whether the input token is tokenX (true) or tokenY (false)
+ * @param params.lbPair - The LB pair address
+ * @param params.connection - A connection to a fullnode JSON RPC endpoint
+ * @param params.swapSlippageBps - Slippage tolerance in basis points
+ * @param params.minDeltaId - Minimum bin delta from active bin
+ * @param params.maxDeltaId - Maximum bin delta from active bin
+ * @param params.strategy - Strategy type for the position
+ * @param params.singleSided - Optional single-sided deposit mode (X or Y only) - default is non-single-sided
  * @returns DirectSwapEstimate with swap details and post-swap token amounts
+ * @throws if failed to get both Jupiter and DLMM swap quotes
  */
-declare function estimateDlmmDirectSwap(tokenAmount: BN, isInputTokenX: boolean, lbPair: PublicKey, connection: Connection, swapSlippageBps: number, minDeltaId: number, maxDeltaId: number, strategy: StrategyType, singleSided?: DlmmSingleSided): Promise<DirectSwapEstimate>;
+declare function estimateDlmmDirectSwap({ amountIn, inputTokenMint, lbPair, connection, swapSlippageBps, minDeltaId, maxDeltaId, strategy, singleSided, }: EstimateDlmmDirectSwapParams): Promise<DlmmDirectSwapEstimate>;
 /**
  * Calculate optimal swap amount for rebalancing existing positions (both tokens)
  *
  * Balances existing tokenX and tokenY amounts to achieve equal value by swapping
  * excess of one token to the other using either the DLMM pool or Jupiter
  *
- * @param tokenXAmount - The amount of tokenX
- * @param tokenYAmount - The amount of tokenY
- * @param lbPair - The LB pair address
- * @param connection - A connection to a fullnode JSON RPC endpoint
- * @param swapSlippageBps - Slippage tolerance in basis points
- * @param minDeltaId - Minimum bin delta from active bin
- * @param maxDeltaId - Maximum bin delta from active bin
- * @param strategy - Strategy type for the position
+ * @param params - Parameters for estimating rebalance swap
+ * @param params.lbPair - The LB pair address
+ * @param params.position - The position address
+ * @param params.connection - A connection to a fullnode JSON RPC endpoint
+ * @param params.swapSlippageBps - Slippage tolerance in basis points
+ * @param params.minDeltaId - Minimum bin delta from active bin
+ * @param params.maxDeltaId - Maximum bin delta from active bin
+ * @param params.strategy - Strategy type for the position
  * @returns DirectSwapEstimate with swap details and post-swap token amounts
+ * @throws if failed to get both Jupiter and DLMM swap quotes
  */
-declare function estimateDlmmRebalanceSwap(tokenXAmount: BN, tokenYAmount: BN, lbPair: PublicKey, connection: Connection, swapSlippageBps: number, minDeltaId: number, maxDeltaId: number, strategy: StrategyType): Promise<DirectSwapEstimate>;
+declare function estimateDlmmRebalanceSwap({ lbPair, position, connection, swapSlippageBps, minDeltaId, maxDeltaId, strategy, }: EstimateDlmmRebalanceSwapParams): Promise<DlmmDirectRebalanceEstimate>;
 
 declare const ZAP_PROGRAM_ID: PublicKey;
 declare const JUP_V6_PROGRAM_ID: PublicKey;
@@ -2203,7 +2419,7 @@ declare const AMOUNT_IN_JUP_V6_REVERSE_OFFSET = 19;
 declare const AMOUNT_IN_DAMM_V2_OFFSET = 8;
 declare const DAMM_V2_SWAP_DISCRIMINATOR: number[];
 
-var address = "TzaptpzVczx3Q3rwujjXdhx1HFBXLP7UApACiqWujtA";
+var address = "zapvX9M3uf5pvy4wRPAbQgdQsM1xmuiFnkfHKPvwMiz";
 var metadata = {
 	name: "zap",
 	version: "0.2.0",
@@ -2626,7 +2842,7 @@ var instructions = [
 				name: "position",
 				docs: [
 					"user position",
-					"Check it is different from owner to advoid user to pass owner address wrongly"
+					"Check it is different from owner to avoid user to pass owner address wrongly"
 				],
 				writable: true,
 				signer: true
@@ -2841,6 +3057,16 @@ var errors = [
 		code: 6006,
 		name: "ExceededSlippage",
 		msg: "Exceeded slippage tolerance"
+	},
+	{
+		code: 6007,
+		name: "InvalidDlmmZapInParameters",
+		msg: "Invalid dlmm zap in parameters"
+	},
+	{
+		code: 6008,
+		name: "UnsupportedFeeMode",
+		msg: "Unsupported fee mode"
 	}
 ];
 var types = [
@@ -4073,4 +4299,4 @@ var idl = {
 	constants: constants
 };
 
-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, type DirectSwapEstimate, DlmmDirectSwapQuoteRoute, DlmmSingleSided, DlmmSwapType, type EstimateBalancedSwapThroughJupiterAndDlmmParams, type GetZapInDammV2DirectPoolParams, type GetZapInDammV2IndirectPoolParams, type GetZapInDlmmDirectParams, type GetZapInDlmmIndirectParams, type IndirectSwapEstimate, JUP_V6_PROGRAM_ID, type JupiterInstruction, type JupiterQuoteResponse, type JupiterRoutePlan, type JupiterSwapInstructionResponse, MEMO_PROGRAM_ID, type ProgramStrategyType, type RebalanceDlmmPositionParams, type RebalanceDlmmPositionResponse, SwapExternalType, type SwapQuoteResult, ZAP_PROGRAM_ID, Zap, idl as ZapIdl, type ZapInDammV2DirectPoolParam, type ZapInDammV2IndirectPoolParam, ZapInDammV2PoolSwapRoute, type ZapInDammV2Response, type ZapInDlmmDirectPoolParam, type ZapInDlmmIndirectPoolParam, type ZapInDlmmResponse, type ZapOutParameters, type ZapOutParams, type ZapOutThroughDammV2Params, type ZapOutThroughDlmmParams, type ZapOutThroughJupiterParams, type ZapProgram, type Zap$1 as ZapTypes, buildJupiterSwapTransaction, convertAccountTypeToNumber, convertLamportsToUiAmount, convertUiAmountToLamports, createDammV2SwapPayload, createDlmmSwapPayload, deriveDammV2EventAuthority, deriveDammV2PoolAuthority, deriveDlmmEventAuthority, deriveLedgerAccount, estimateDlmmDirectSwap, estimateDlmmIndirectSwap, estimateDlmmRebalanceSwap, filterOutCloseSplTokenAccountInstructions, getBinArrayBitmapExtension, getBitFromBinArrayIndexInBitmapExtension, getDammV2Pool, getDammV2RemainingAccounts, getDlmmRemainingAccounts, getExtraAccountMetasForTransferHook, getJupiterQuote, getJupiterSwapInstruction, getLbPairState, getNextBinArrayIndexWithLiquidity, getOrCreateATAInstruction, getTokenAccountBalance, getTokenProgramFromMint, toProgramStrategyType, unwrapSOLInstruction, wrapSOLInstruction };
+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, type DlmmDirectEstimateResult, type DlmmDirectRebalanceEstimate, type DlmmDirectRebalanceEstimateContext, type DlmmDirectSwapEstimate, type DlmmDirectSwapEstimateContext, DlmmDirectSwapQuoteRoute, type DlmmIndirectSwapEstimate, type DlmmIndirectSwapEstimateContext, type DlmmIndirectSwapEstimateResult, DlmmSingleSided, DlmmSwapType, type EstimateDlmmDirectSwapParams, type EstimateDlmmIndirectSwapParams, type EstimateDlmmRebalanceSwapParams, type GetZapInDammV2DirectPoolParams, type GetZapInDammV2IndirectPoolParams, type GetZapInDlmmDirectParams, type GetZapInDlmmIndirectParams, JUP_V6_PROGRAM_ID, type JupiterInstruction, type JupiterQuoteResponse, type JupiterRoutePlan, type JupiterSwapInstructionResponse, MEMO_PROGRAM_ID, type ProgramStrategyType, type RebalanceDlmmPositionParams, type RebalanceDlmmPositionResponse, SwapExternalType, type SwapQuoteResult, ZAP_PROGRAM_ID, Zap, idl as ZapIdl, type ZapInDammV2DirectPoolParam, type ZapInDammV2IndirectPoolParam, ZapInDammV2PoolSwapRoute, type ZapInDammV2Response, type ZapInDlmmDirectPoolParam, type ZapInDlmmIndirectPoolParam, type ZapInDlmmResponse, type ZapOutParameters, type ZapOutParams, type ZapOutThroughDammV2Params, type ZapOutThroughDlmmParams, type ZapOutThroughJupiterParams, type ZapProgram, type Zap$1 as ZapTypes, buildJupiterSwapTransaction, convertAccountTypeToNumber, convertLamportsToUiAmount, convertUiAmountToLamports, createDammV2SwapPayload, createDlmmSwapPayload, deriveDammV2EventAuthority, deriveDammV2PoolAuthority, deriveDlmmEventAuthority, deriveLedgerAccount, estimateDlmmDirectSwap, estimateDlmmIndirectSwap, estimateDlmmRebalanceSwap, filterOutCloseSplTokenAccountInstructions, getBinArrayBitmapExtension, getBitFromBinArrayIndexInBitmapExtension, getDammV2Pool, getDammV2RemainingAccounts, getDlmmRemainingAccounts, getExtraAccountMetasForTransferHook, getJupiterQuote, getJupiterSwapInstruction, getLbPairState, getNextBinArrayIndexWithLiquidity, getOrCreateATAInstruction, getTokenAccountBalance, getTokenProgramFromMint, toProgramStrategyType, unwrapSOLInstruction, wrapSOLInstruction };