@hawksightco/hawk-sdk 1.3.265 → 1.3.266

package/dist/meteora.d.ts

@@ -0,0 +1,669 @@
+import DLMM, { ClmmProgram, LbPosition, PositionV2, Position, LbPair } from '@meteora-ag/dlmm';
+import BN from "bn.js";
+import * as web3 from "@solana/web3.js";
+import { LabeledInstruction, MeteoraToHawksightFn, MeteoraToHawksightFnLabeled, StrategyType, TokenType } from './types';
+import { SimpleIxGenerator } from './classes/SimpleIxGenerator';
+export declare class MeteoraDLMM {
+    readonly dlmm: DLMM;
+    readonly ix: SimpleIxGenerator;
+    private constructor();
+    readonly pubkey: web3.PublicKey;
+    private static _program;
+    private static _instance;
+    private static _poolAddress;
+    private static _connection;
+    static create(connection: web3.Connection, poolAddress: web3.PublicKey, ix: SimpleIxGenerator): Promise<MeteoraDLMM>;
+    /**
+     * Meteora DLMM Program
+     *
+     * @param connection
+     */
+    static program(connection: web3.Connection): Promise<ClmmProgram>;
+    getXYAmountDistribution(distribution: "SPOT" | "CURVE" | "BID-ASK", activeBin: {
+        binId: number;
+        price: string;
+    }, lowerRange: number, upperRange: number): {
+        binId: number;
+        xAmountBpsOfTotal: BN;
+        yAmountBpsOfTotal: BN;
+    }[];
+    getActiveBin(): Promise<import("@meteora-ag/dlmm").BinLiquidity>;
+    getPositionsByUserAndLbPair(userPubKey: web3.PublicKey): Promise<{
+        activeBin: import("@meteora-ag/dlmm").BinLiquidity;
+        userPositions: Array<LbPosition>;
+    }>;
+    /**
+     * Initializes a position and adds liquidity to the specified strategy, with various steps including
+     * handling wrapped SOL tokens, depositing tokens, adding liquidity, and handling dust withdrawals.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for initializing the position and adding liquidity.
+     * @param {web3.PublicKey} params.positionPubKey - The public key of the position to be initialized.
+     * @param {BN} params.totalXAmount - The total amount of X tokens to be used for liquidity.
+     * @param {BN} params.totalYAmount - The total amount of Y tokens to be used for liquidity.
+     * @param {Object} params.strategy - The strategy details for adding liquidity.
+     * @param {number} params.strategy.maxBinId - The maximum bin ID for the strategy.
+     * @param {number} params.strategy.minBinId - The minimum bin ID for the strategy.
+     * @param {StrategyType} params.strategy.strategyType - The type of strategy to be applied.
+     * @param {web3.PublicKey} params.user - The public key of the user executing the transaction.
+     * @param {number} [params.slippage] - Optional slippage tolerance for the transaction.
+     *
+     * @returns {Promise<web3.TransactionInstruction[]>} - A promise that resolves to an array of transaction instructions.
+     *
+     * @throws {Error} - Throws an error if input token(s) do not exist on the blockchain.
+     */
+    initializePositionAndAddLiquidityByStrategy(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        positionPubKey: web3.PublicKey;
+        totalXAmount: BN;
+        totalYAmount: BN;
+        strategy: {
+            maxBinId: number;
+            minBinId: number;
+            strategyType: StrategyType;
+        };
+        user: web3.PublicKey;
+        slippage?: number;
+        skipInputTokenCheck?: boolean;
+        opt?: {
+            pdaTokenType?: TokenType;
+            withAmount?: {
+                userTokenXAmount: BN | null;
+                userTokenYAmount: BN | null;
+            };
+            fuelAccount?: boolean;
+        };
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<InitializePositionAndAddLiquidityByStrategyBuilder>;
+    /**
+     * Initializes a position and adds liquidity to the specified strategy, with various steps including
+     * handling wrapped SOL tokens, depositing tokens, adding liquidity, and handling dust withdrawals.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for initializing the position and adding liquidity.
+     * @param {web3.PublicKey} params.positionPubKey - The public key of the position to be initialized.
+     * @param {BN} params.totalXAmount - The total amount of X tokens to be used for liquidity.
+     * @param {BN} params.totalYAmount - The total amount of Y tokens to be used for liquidity.
+     * @param {Object} params.strategy - The strategy details for adding liquidity.
+     * @param {number} params.strategy.maxBinId - The maximum bin ID for the strategy.
+     * @param {number} params.strategy.minBinId - The minimum bin ID for the strategy.
+     * @param {StrategyType} params.strategy.strategyType - The type of strategy to be applied.
+     * @param {web3.PublicKey} params.user - The public key of the user executing the transaction.
+     * @param {number} [params.slippage] - Optional slippage tolerance for the transaction.
+     *
+     * @returns {Promise<web3.TransactionInstruction[]>} - A promise that resolves to an array of transaction instructions.
+     *
+     * @throws {Error} - Throws an error if input token(s) do not exist on the blockchain.
+     */
+    initializePositionAndAddLiquidityByStrategyLabeled(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        positionPubKey: web3.PublicKey;
+        totalXAmount: BN;
+        totalYAmount: BN;
+        strategy: {
+            maxBinId: number;
+            minBinId: number;
+            strategyType: StrategyType;
+        };
+        user: web3.PublicKey;
+        slippage?: number;
+        skipInputTokenCheck?: boolean;
+        opt?: {
+            pdaTokenType?: TokenType;
+            withAmount?: {
+                userTokenXAmount: BN | null;
+                userTokenYAmount: BN | null;
+            };
+            fuelAccount?: boolean;
+        };
+    }, meteoraToHawksight: MeteoraToHawksightFnLabeled): Promise<InitializePositionAndAddLiquidityByStrategyBuilderLabeled>;
+    /**
+     * Initializes a position and adds liquidity to the specified strategy, with various steps including
+     * handling wrapped SOL tokens, depositing tokens, adding liquidity, and handling dust withdrawals.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for initializing the position and adding liquidity.
+     * @param {web3.PublicKey} params.positionPubKey - The public key of the position to be initialized.
+     * @param {BN} params.totalXAmount - The total amount of X tokens to be used for liquidity.
+     * @param {BN} params.totalYAmount - The total amount of Y tokens to be used for liquidity.
+     * @param {Object} params.strategy - The strategy details for adding liquidity.
+     * @param {number} params.strategy.maxBinId - The maximum bin ID for the strategy.
+     * @param {number} params.strategy.minBinId - The minimum bin ID for the strategy.
+     * @param {StrategyType} params.strategy.strategyType - The type of strategy to be applied.
+     * @param {web3.PublicKey} params.user - The public key of the user executing the transaction.
+     * @param {number} [params.slippage] - Optional slippage tolerance for the transaction.
+     *
+     * @returns {Promise<web3.TransactionInstruction[]>} - A promise that resolves to an array of transaction instructions.
+     *
+     * @throws {Error} - Throws an error if input token(s) do not exist on the blockchain.
+     */
+    initializePositionAndAddLiquidityByStrategyPda(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        positionPubKey: web3.PublicKey;
+        totalXAmount: BN;
+        totalYAmount: BN;
+        strategy: {
+            maxBinId: number;
+            minBinId: number;
+            strategyType: StrategyType;
+        };
+        user: web3.PublicKey;
+        slippage?: number;
+        skipInputTokenCheck?: boolean;
+        pdaTokenType?: TokenType;
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<InitializePositionAndAddLiquidityByStrategyPdaBuilder>;
+    /**
+     * Adds liquidity to an existing position according to a specified strategy.
+     *
+     * This method involves multiple steps including checking for token existence, handling wrapped SOL (wSOL), depositing tokens,
+     * adding liquidity, and handling dust withdrawals. It ensures that all necessary preparations and operations are performed
+     * to add liquidity based on the provided strategy.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for adding liquidity to the position.
+     * @param {web3.PublicKey} params.positionPubKey - The public key of the position to add liquidity to.
+     * @param {BN} params.totalXAmount - The total amount of X tokens to be used for liquidity.
+     * @param {BN} params.totalYAmount - The total amount of Y tokens to be used for liquidity.
+     * @param {Object} params.strategy - The strategy details for adding liquidity.
+     * @param {number} params.strategy.maxBinId - The maximum bin ID for the strategy.
+     * @param {number} params.strategy.minBinId - The minimum bin ID for the strategy.
+     * @param {StrategyType} params.strategy.strategyType - The type of strategy to be applied.
+     * @param {web3.PublicKey} params.user - The public key of the user executing the transaction.
+     *
+     * @returns {Promise<web3.TransactionInstruction[]>} - A promise that resolves to an array of transaction instructions.
+     *
+     * @throws {Error} - Throws an error if input token(s) do not exist on the blockchain.
+     */
+    addLiquidityByStrategy(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        positionPubKey: web3.PublicKey;
+        totalXAmount: BN;
+        totalYAmount: BN;
+        strategy: {
+            maxBinId: number;
+            minBinId: number;
+            strategyType: StrategyType;
+        };
+        user: web3.PublicKey;
+        slippage?: number;
+        skipInputTokenCheck: boolean;
+        pdaTokenType?: TokenType;
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<AddLiquidityByStrategyBuilder>;
+    /**
+     * Removes liquidity from an existing position.
+     *
+     * This method communicates with the DLMM (Dynamic Liquidity Market Maker) to remove liquidity
+     * from a specified trading position. It filters the transaction instructions to include only those
+     * relevant to the Meteora DLMM program.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for removing liquidity from the position.
+     * @param {web3.PublicKey} params.user - The public key of the user executing the transaction.
+     * @param {web3.PublicKey} params.position - The public key of the position from which liquidity is being removed.
+     * @param {number[]} params.binIds - An array of bin IDs indicating which bins to remove liquidity from.
+     * @param {BN} params.bps - The basis points (in BN) indicating the proportion of liquidity to remove.
+     * @param {boolean} [params.shouldClaimAndClose] - Optional flag to indicate whether the position should be claimed and closed after removing liquidity.
+     *
+     * @returns {Promise<web3.TransactionInstruction[]>} - A promise that resolves to an array of transaction instructions relevant to the Meteora DLMM program.
+     */
+    removeLiquidity(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        user: web3.PublicKey;
+        position: web3.PublicKey;
+        fromBinId: number;
+        toBinId: number;
+        bps: BN;
+        shouldClaimAndClose?: boolean;
+        pdaTokenType?: TokenType;
+        fuelAccount?: boolean;
+        rewardClaimMode?: 'default' | 'automation';
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<RemoveLiquidityBuilder>;
+    /**
+     * Removes liquidity from an existing position to the user pda.
+     *
+     * This method communicates with the DLMM (Dynamic Liquidity Market Maker) to remove liquidity
+     * from a specified trading position. It filters the transaction instructions to include only those
+     * relevant to the Meteora DLMM program.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for removing liquidity from the position.
+     * @param {web3.PublicKey} params.user - The public key of the user executing the transaction.
+     * @param {web3.PublicKey} params.position - The public key of the position from which liquidity is being removed.
+     * @param {number[]} params.binIds - An array of bin IDs indicating which bins to remove liquidity from.
+     * @param {BN} params.bps - The basis points (in BN) indicating the proportion of liquidity to remove.
+     * @param {boolean} [params.shouldClaimAndClose] - Optional flag to indicate whether the position should be claimed and closed after removing liquidity.
+     *
+     * @returns {Promise<web3.TransactionInstruction[]>} - A promise that resolves to an array of transaction instructions relevant to the Meteora DLMM program.
+     */
+    removeLiquidityPda(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        user: web3.PublicKey;
+        position: web3.PublicKey;
+        fromBinId: number;
+        toBinId: number;
+        bps: BN;
+        shouldClaimAndClose?: boolean;
+        pdaTokenType?: TokenType;
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<RemoveLiquidityPdaBuilder>;
+    /**
+     * Claims all rewards for a specified position.
+     *
+     * This method communicates with the DLMM (Dynamic Liquidity Market Maker) to claim all rewards
+     * for a given position. It filters the transaction instructions to include only those relevant
+     * to the Meteora DLMM program. The method returns a `ClaimAllRewardsByPositionBuilder` object
+     * which provides a structured way to build the necessary transaction instructions for the reward
+     * claiming process.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for claiming rewards.
+     * @param {web3.PublicKey} params.owner - The public key of the owner of the position.
+     * @param {LbPosition} params.position - The position object representing the liquidity position.
+     * @param {Function} meteoraToHawksight - A function to convert Meteora instructions to Hawksight instructions.
+     *
+     * @returns {Promise<ClaimAllRewardsByPositionBuilder>} - A promise that resolves to a `ClaimAllRewardsByPositionBuilder` object.
+     */
+    claimAllRewardsByPosition(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        owner: web3.PublicKey;
+        position: LbPosition;
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<ClaimAllRewardsByPositionBuilder>;
+    /**
+     * Closes a specified liquidity position.
+     *
+     * This method communicates with the DLMM (Dynamic Liquidity Market Maker) to close a given liquidity
+     * position. It filters the transaction instructions to include only those relevant to the Meteora DLMM program.
+     *
+     * @param {Object} params - The parameters for closing the position.
+     * @param {web3.PublicKey} params.owner - The public key of the owner of the position.
+     * @param {LbPosition} params.position - The position object representing the liquidity position.
+     *
+     * @returns {Promise<web3.TransactionInstruction[]>} - A promise that resolves to an array of transaction instructions relevant to the Meteora DLMM program.
+     */
+    closePosition(userWallet: web3.PublicKey, params: {
+        owner: web3.PublicKey;
+        position: LbPosition;
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<web3.TransactionInstruction[]>;
+}
+/**
+ * Meteora functions / transaction generators that we re-written for performance improvement purposes
+ */
+export declare class MeteoraFunctions {
+    private readonly ix;
+    constructor(ix: SimpleIxGenerator);
+    /**
+     * Position cache (v1)
+     */
+    readonly positions_v1: Record<string, Position>;
+    /**
+     * Position cache (v2)
+     */
+    readonly positions_v2: Record<string, PositionV2>;
+    /**
+     * Pool cache
+     */
+    readonly pools: Record<string, LbPair>;
+    /**
+     * Claims all rewards for a specified position.
+     *
+     * This method communicates with the DLMM (Dynamic Liquidity Market Maker) to claim all rewards
+     * for a given position. It filters the transaction instructions to include only those relevant
+     * to the Meteora DLMM program. The method returns a `ClaimAllRewardsByPositionBuilder` object
+     * which provides a structured way to build the necessary transaction instructions for the reward
+     * claiming process.
+     *
+     * @param {web3.PublicKey} userWallet - The public key of the user's wallet executing the transaction.
+     * @param {web3.PublicKey} payer - The public key of the transaction payer.
+     * @param {Object} params - The parameters for claiming rewards.
+     * @param {web3.PublicKey} params.owner - The public key of the owner of the position.
+     * @param {LbPosition} params.position - The position object representing the liquidity position.
+     * @param {Function} meteoraToHawksight - A function to convert Meteora instructions to Hawksight instructions.
+     *
+     * @returns {Promise<ClaimAllRewardsByPositionBuilder>} - A promise that resolves to a `ClaimAllRewardsByPositionBuilder` object.
+     */
+    claimAllRewardsByPosition(connection: web3.Connection, userWallet: web3.PublicKey, payer: web3.PublicKey, params: {
+        owner: web3.PublicKey;
+        lbPair: web3.PublicKey;
+        position: web3.PublicKey;
+        pdaTokenType: TokenType;
+    }, meteoraToHawksight: MeteoraToHawksightFn): Promise<ClaimAllRewardsByPositionBuilder>;
+    constants(program: ClmmProgram): {
+        MAX_BIN_ARRAY_SIZE: BN;
+        MAX_BIN_PER_POSITION: BN;
+        BIN_ARRAY_BITMAP_SIZE: BN;
+        EXTENSION_BINARRAY_BITMAP_SIZE: BN;
+    };
+    static findMeteoraTickArrayIndices(minBinId: number, maxBinId: number): BN[];
+    static findMeteoraTickArrays(lbPair: web3.PublicKey, minBinId: number, maxBinId: number): web3.PublicKey[];
+    deriveReserve(token: web3.PublicKey, lbPair: web3.PublicKey): web3.PublicKey;
+    static deriveBinArray(lbPair: web3.PublicKey, index: BN): web3.PublicKey;
+    static binIdToBinArrayIndex(MAX_BIN_ARRAY_SIZE: BN, binId: BN): BN;
+    getPositionAndLbPair(connection: web3.Connection, lbPair: web3.PublicKey, position: web3.PublicKey): Promise<{
+        lbPairAccount: any;
+        positionAccount: any;
+        constants: any;
+    }>;
+    /**
+     * Returns all position of user
+     *
+     * @param connection
+     * @param userPda
+     */
+    getAllUserPosition(connection: web3.Connection, userPda: web3.PublicKey): Promise<web3.PublicKey[]>;
+    getPositions(dlmm: DLMM, positions: web3.PublicKey[]): Promise<[{
+        lbPair: web3.PublicKey;
+        owner: web3.PublicKey;
+        liquidityShares: BN[];
+        rewardInfos: {
+            rewardPerTokenCompletes: BN[];
+            rewardPendings: BN[];
+        }[];
+        feeInfos: {
+            feeXPerTokenComplete: BN;
+            feeYPerTokenComplete: BN;
+            feeXPending: BN;
+            feeYPending: BN;
+        }[];
+        lowerBinId: number;
+        upperBinId: number;
+        lastUpdatedAt: BN;
+        totalClaimedFeeXAmount: BN;
+        totalClaimedFeeYAmount: BN;
+        totalClaimedRewards: BN[];
+        operator: web3.PublicKey;
+        lockReleasePoint: BN;
+        padding0: number;
+        feeOwner: web3.PublicKey;
+        reserved: number[];
+    }, LbPosition][]>;
+    /**
+     * Generate instruction that claims all fees and rewards by user
+     *
+     * @param connection
+     * @param lbPair
+     * @param positions
+     * @param userPda
+     * @returns
+     */
+    claimFeeAndRewardIxs2(connection: web3.Connection, positions: web3.PublicKey[], userWallet: web3.PublicKey, userPda: web3.PublicKey, meteoraToHawksight: MeteoraToHawksightFn, lbPair?: web3.PublicKey): Promise<ClaimAllRewardsByPositionBuilder>;
+    claimFee2AndReward2Ixs(connection: web3.Connection, lbPair: web3.PublicKey, position: web3.PublicKey, userPda: web3.PublicKey, tokenProgramX: web3.PublicKey, tokenProgramY: web3.PublicKey): Promise<web3.TransactionInstruction[]>;
+    claimFee2Ix(lbPair: web3.PublicKey, position: web3.PublicKey, userPda: web3.PublicKey, tokenProgramX: web3.PublicKey, tokenProgramY: web3.PublicKey, getPositionAndLbPairResult: {
+        lbPairAccount: any;
+        positionAccount: any;
+        constants: any;
+    }): web3.TransactionInstruction;
+    claimReward2Ixs(lbPair: web3.PublicKey, position: web3.PublicKey, userPda: web3.PublicKey, getPositionAndLbPairResult: {
+        lbPairAccount: any;
+        positionAccount: any;
+        constants: any;
+    }): web3.TransactionInstruction[];
+}
+/**
+ * A builder class for constructing transaction instructions to claim all rewards by position.
+ *
+ * This class provides a structured way to build the necessary transaction instructions for claiming
+ * rewards, removing liquidity, and managing wrapped SOL (wSOL) accounts.
+ */
+export declare class ClaimAllRewardsByPositionBuilder {
+    readonly createAtaIxs: web3.TransactionInstruction[];
+    readonly mainIxs: web3.TransactionInstruction[];
+    readonly withdrawMultipleTokenIx: web3.TransactionInstruction;
+    readonly unwrapWsolIxs: web3.TransactionInstruction[];
+    /**
+     * Constructs an instance of the ClaimAllRewardsByPositionBuilder class.
+     *
+     * @param {web3.TransactionInstruction[]} createAtaIxs - Instructions to create associated token accounts (ATAs) prior to withdrawal.
+     * @param {web3.TransactionInstruction[]} mainIxs - Main instructions for claiming fees and/or rewards.
+     * @param {web3.TransactionInstruction} withdrawMultipleTokenIx - Instruction to withdraw multiple tokens to the user wallet.
+     * @param {web3.TransactionInstruction[]} unwrapWsolIxs - Instructions to close wSOL accounts, if any.
+     */
+    constructor(createAtaIxs: web3.TransactionInstruction[], mainIxs: web3.TransactionInstruction[], withdrawMultipleTokenIx: web3.TransactionInstruction, unwrapWsolIxs: web3.TransactionInstruction[]);
+    /**
+     * Builds the default sequence of transaction instructions for claiming all rewards by position.
+     *
+     * This method returns an array of transaction instructions that includes:
+     * - Initializing ATAs prior to withdrawal
+     * - Claiming fees and/or rewards
+     * - Withdrawing tokens to the user wallet
+     * - Closing wSOL accounts, if any
+     *
+     * @returns {web3.TransactionInstruction[]} - An array of transaction instructions in the required order.
+     */
+    default(): web3.TransactionInstruction[];
+    /**
+     * Replaces claim fee token ixs into storage token account
+     */
+    replaceClaimFeeTokenToSTA(): void;
+    /**
+     * Replaces reward token into storage token account for ALL reward claim instructions.
+     * DLMM pools can have up to 2 reward farms, so we need to handle multiple reward claims.
+     */
+    replaceClaimRewardToSTA(): void;
+}
+/**
+ * A builder class for constructing transaction instructions to add liquidity according to a specified strategy.
+ *
+ * This class provides a structured way to build the necessary transaction instructions for adding liquidity to a position
+ * based on a strategy, handling operations such as wrapping SOL, depositing tokens, adding liquidity, refunding dust, and
+ * managing wrapped SOL (wSOL) accounts.
+ */
+export declare class AddLiquidityByStrategyBuilder {
+    readonly wrapSolIxs: web3.TransactionInstruction[];
+    readonly depositToPdaIxs: web3.TransactionInstruction;
+    readonly mainIxs: web3.TransactionInstruction[];
+    readonly refundDustIxs: web3.TransactionInstruction;
+    readonly unwrapWsolIxs: web3.TransactionInstruction[];
+    /**
+     * Constructs an instance of the AddLiquidityByStrategyBuilder class.
+     *
+     * @param {web3.TransactionInstruction[]} wrapSolIxs - Instructions to wrap SOL to wSOL if needed.
+     * @param {web3.TransactionInstruction} depositToPdaIxs - Instruction to deposit X and Y tokens to the UserPDA.
+     * @param {web3.TransactionInstruction[]} mainIxs - Main instructions for adding liquidity by strategy.
+     * @param {web3.TransactionInstruction} refundDustIxs - Instruction to refund dust tokens to the user wallet.
+     * @param {web3.TransactionInstruction[]} unwrapWsolIxs - Instructions to unwrap wSOL to SOL if any.
+     */
+    constructor(wrapSolIxs: web3.TransactionInstruction[], depositToPdaIxs: web3.TransactionInstruction, mainIxs: web3.TransactionInstruction[], refundDustIxs: web3.TransactionInstruction, unwrapWsolIxs: web3.TransactionInstruction[]);
+    /**
+     * Builds the default sequence of transaction instructions for adding liquidity by strategy.
+     *
+     * This method returns an array of transaction instructions that includes:
+     * - Initializing wSOL token accounts if needed
+     * - Depositing X and Y tokens to the UserPDA
+     * - Adding liquidity according to the strategy
+     * - Refunding dust tokens to the user wallet
+     * - Closing wSOL accounts if any
+     *
+     * @returns {web3.TransactionInstruction[]} - An array of transaction instructions in the required order.
+     */
+    default(): web3.TransactionInstruction[];
+}
+/**
+ * A builder class for constructing transaction instructions to remove liquidity from a position.
+ *
+ * This class provides a structured way to build the necessary transaction instructions for removing liquidity
+ * from a position, handling operations such as creating associated token accounts (ATAs), claiming rewards,
+ * withdrawing tokens, and managing wrapped SOL (wSOL) accounts.
+ */
+export declare class RemoveLiquidityBuilder {
+    readonly createAtaIxs: web3.TransactionInstruction[];
+    readonly mainIxs: web3.TransactionInstruction[];
+    readonly withdrawMultipleTokenIx: web3.TransactionInstruction;
+    readonly unwrapWsolIxs: web3.TransactionInstruction[];
+    /**
+     * Constructs an instance of the RemoveLiquidityBuilder class.
+     *
+     * @param {web3.TransactionInstruction[]} createAtaIxs - Instructions to create associated token accounts (ATAs) prior to withdrawal.
+     * @param {web3.TransactionInstruction[]} mainIxs - Main instructions for claiming fees/rewards, removing liquidity, and possibly closing the position.
+     * @param {web3.TransactionInstruction} withdrawMultipleTokenIx - Instruction to withdraw multiple tokens to the user wallet.
+     * @param {web3.TransactionInstruction[]} unwrapWsolIxs - Instructions to close wSOL accounts, if any.
+     */
+    constructor(createAtaIxs: web3.TransactionInstruction[], mainIxs: web3.TransactionInstruction[], withdrawMultipleTokenIx: web3.TransactionInstruction, unwrapWsolIxs: web3.TransactionInstruction[]);
+    /**
+     * Builds the default sequence of transaction instructions for removing liquidity from a position.
+     *
+     * This method returns an array of transaction instructions that includes:
+     * - Initializing associated token accounts (ATAs) prior to withdrawal
+     * - Claiming fees and/or rewards, removing liquidity, and possibly closing the position
+     * - Withdrawing tokens to the user wallet
+     * - Closing wSOL accounts, if any
+     *
+     * @returns {web3.TransactionInstruction[]} - An array of transaction instructions in the required order.
+     */
+    default(): web3.TransactionInstruction[];
+    /**
+     * Replaces claim fee token ixs into storage token account
+     */
+    replaceClaimFeeTokenToSTA(): void;
+    /**
+     * Replaces reward token into storage token account for ALL reward claim instructions.
+     * DLMM pools can have up to 2 reward farms, so we need to handle multiple reward claims.
+     */
+    replaceClaimRewardToSTA(): void;
+    /**
+     * Replaces claim fee token ixs into associated token account
+     */
+    replaceClaimFeeTokenToATA(): void;
+    /**
+     * Replaces reward token into associated token account for ALL reward claim instructions.
+     * DLMM pools can have up to 2 reward farms, so we need to handle multiple reward claims.
+     */
+    replaceClaimRewardToATA(): void;
+}
+/**
+ * A builder class for constructing transaction instructions to remove liquidity from a position to the pda.
+ *
+ * This class provides a structured way to build the necessary transaction instructions for removing liquidity
+ * from a position, handling operations such as creating associated token accounts (ATAs), claiming rewards,
+ * withdrawing tokens, and managing wrapped SOL (wSOL) accounts.
+ */
+export declare class RemoveLiquidityPdaBuilder {
+    readonly mainIxs: web3.TransactionInstruction[];
+    /**
+     * Constructs an instance of the RemoveLiquidityBuilder class.
+     *
+     * @param {web3.TransactionInstruction[]} createAtaIxs - Instructions to create associated token accounts (ATAs) prior to withdrawal.
+     * @param {web3.TransactionInstruction[]} mainIxs - Main instructions for claiming fees/rewards, removing liquidity, and possibly closing the position.
+     * @param {web3.TransactionInstruction[]} unwrapWsolIxs - Instructions to close wSOL accounts, if any.
+     */
+    constructor(mainIxs: web3.TransactionInstruction[]);
+    /**
+     * Builds the default sequence of transaction instructions for removing liquidity from a position.
+     *
+     * This method returns an array of transaction instructions that includes:
+     * - Initializing associated token accounts (ATAs) prior to withdrawal
+     * - Claiming fees and/or rewards, removing liquidity, and possibly closing the position
+     * - Withdrawing tokens to the user wallet
+     * - Closing wSOL accounts, if any
+     *
+     * @returns {web3.TransactionInstruction[]} - An array of transaction instructions in the required order.
+     */
+    default(): web3.TransactionInstruction[];
+    /**
+     * Replaces claim fee token ixs into storage token account
+     */
+    replaceClaimFeeTokenToSTA(): void;
+    /**
+     * Replaces reward token into storage token account for ALL reward claim instructions.
+     * DLMM pools can have up to 2 reward farms, so we need to handle multiple reward claims.
+     */
+    replaceClaimRewardToSTA(): void;
+}
+/**
+ * A builder class for constructing transaction instructions to remove liquidity from a position.
+ *
+ * This class provides a structured way to build the necessary transaction instructions for removing liquidity
+ * from a position, handling operations such as creating associated token accounts (ATAs), claiming rewards,
+ * withdrawing tokens, and managing wrapped SOL (wSOL) accounts.
+ */
+export declare class InitializePositionAndAddLiquidityByStrategyBuilder {
+    readonly wrapSolIxs: web3.TransactionInstruction[];
+    readonly depositToPdaIxs: web3.TransactionInstruction;
+    readonly mainIxs: web3.TransactionInstruction[];
+    readonly refundDustIxs: web3.TransactionInstruction;
+    readonly unwrapWsolIxs: web3.TransactionInstruction[];
+    /**
+     * Constructs an instance of the InitializePositionAndAddLiquidityByStrategyBuilder class.
+     *
+     * @param {web3.TransactionInstruction[]} wrapSolIxs - Instructions to wrap SOL to wSOL if needed.
+     * @param {web3.TransactionInstruction} depositToPdaIxs - Instruction to deposit X and Y tokens to the UserPDA.
+     * @param {web3.TransactionInstruction[]} mainIxs - Main instructions for adding liquidity by strategy.
+     * @param {web3.TransactionInstruction} refundDustIxs - Instruction to refund dust tokens to the user wallet.
+     * @param {web3.TransactionInstruction[]} unwrapWsolIxs - Instructions to unwrap wSOL to SOL if any.
+     */
+    constructor(wrapSolIxs: web3.TransactionInstruction[], depositToPdaIxs: web3.TransactionInstruction, mainIxs: web3.TransactionInstruction[], refundDustIxs: web3.TransactionInstruction, unwrapWsolIxs: web3.TransactionInstruction[]);
+    /**
+     * Builds the default sequence of transaction instructions for removing liquidity from a position.
+     *
+     * This method returns an array of transaction instructions that includes:
+     * - Initializing associated token accounts (ATAs) prior to withdrawal
+     * - Claiming fees and/or rewards, removing liquidity, and possibly closing the position
+     * - Withdrawing tokens to the user wallet
+     * - Closing wSOL accounts, if any
+     *
+     * @returns {web3.TransactionInstruction[]} - An array of transaction instructions in the required order.
+     */
+    default(): web3.TransactionInstruction[];
+}
+/**
+ * A builder class for constructing transaction instructions to remove liquidity from a position.
+ *
+ * This class provides a structured way to build the necessary transaction instructions for removing liquidity
+ * from a position, handling operations such as creating associated token accounts (ATAs), claiming rewards,
+ * withdrawing tokens, and managing wrapped SOL (wSOL) accounts.
+ */
+export declare class InitializePositionAndAddLiquidityByStrategyBuilderLabeled {
+    readonly wrapSolIxs: LabeledInstruction[];
+    readonly depositToPdaIxs: LabeledInstruction;
+    readonly mainIxs: LabeledInstruction[];
+    readonly refundDustIxs: LabeledInstruction;
+    readonly unwrapWsolIxs: LabeledInstruction[];
+    /**
+     * Constructs an instance of the InitializePositionAndAddLiquidityByStrategyBuilderLabeled class.
+     *
+     * @param {LabeledInstruction[]} wrapSolIxs - Instructions to wrap SOL to wSOL if needed.
+     * @param {LabeledInstruction} depositToPdaIxs - Instruction to deposit X and Y tokens to the UserPDA.
+     * @param {LabeledInstruction[]} mainIxs - Main instructions for adding liquidity by strategy.
+     * @param {LabeledInstruction} refundDustIxs - Instruction to refund dust tokens to the user wallet.
+     * @param {LabeledInstruction[]} unwrapWsolIxs - Instructions to unwrap wSOL to SOL if any.
+     */
+    constructor(wrapSolIxs: LabeledInstruction[], depositToPdaIxs: LabeledInstruction, mainIxs: LabeledInstruction[], refundDustIxs: LabeledInstruction, unwrapWsolIxs: LabeledInstruction[]);
+    /**
+     * Builds the default sequence of transaction instructions for removing liquidity from a position.
+     *
+     * This method returns an array of transaction instructions that includes:
+     * - Initializing associated token accounts (ATAs) prior to withdrawal
+     * - Claiming fees and/or rewards, removing liquidity, and possibly closing the position
+     * - Withdrawing tokens to the user wallet
+     * - Closing wSOL accounts, if any
+     *
+     * @returns {LabeledInstruction[]} - An array of transaction instructions in the required order.
+     */
+    default(): LabeledInstruction[];
+}
+/**
+ * A builder class for constructing transaction instructions to remove liquidity from a position.
+ *
+ * This class provides a structured way to build the necessary transaction instructions for removing liquidity
+ * from a position, handling operations such as creating associated token accounts (ATAs), claiming rewards,
+ * withdrawing tokens, and managing wrapped SOL (wSOL) accounts.
+ */
+export declare class InitializePositionAndAddLiquidityByStrategyPdaBuilder {
+    readonly mainIxs: web3.TransactionInstruction[];
+    /**
+     * Constructs an instance of the InitializePositionAndAddLiquidityByStrategyBuilder class.
+     *
+     * @param {web3.TransactionInstruction[]} mainIxs - Main instructions for adding liquidity by strategy.
+     */
+    constructor(mainIxs: web3.TransactionInstruction[]);
+    /**
+     * Builds the default sequence of transaction instructions for removing liquidity from a position.
+     *
+     * This method returns an array of transaction instructions that includes:
+     * - Initializing associated token accounts (ATAs) prior to withdrawal
+     * - Claiming fees and/or rewards, removing liquidity, and possibly closing the position
+     * - Withdrawing tokens to the user wallet
+     * - Closing wSOL accounts, if any
+     *
+     * @returns {web3.TransactionInstruction[]} - An array of transaction instructions in the required order.
+     */
+    default(): web3.TransactionInstruction[];
+}
+//# sourceMappingURL=meteora.d.ts.map