@hawksightco/hawk-sdk 1.3.265 → 1.3.266

package/dist/meteora.js

@@ -0,0 +1,1932 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializePositionAndAddLiquidityByStrategyPdaBuilder = exports.InitializePositionAndAddLiquidityByStrategyBuilderLabeled = exports.InitializePositionAndAddLiquidityByStrategyBuilder = exports.RemoveLiquidityPdaBuilder = exports.RemoveLiquidityBuilder = exports.AddLiquidityByStrategyBuilder = exports.ClaimAllRewardsByPositionBuilder = exports.MeteoraFunctions = exports.MeteoraDLMM = void 0;
+const dlmm_1 = __importStar(require("@meteora-ag/dlmm"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const web3 = __importStar(require("@solana/web3.js"));
+const errors_1 = require("./errors");
+const addresses_1 = require("./addresses");
+const functions_1 = require("./functions");
+const types_1 = require("./types");
+const anchor_1 = require("./anchor");
+const Logging_1 = require("./classes/Logging");
+const bs58_1 = __importDefault(require("bs58"));
+/**
+ * Manual implementation of getTokenProgramMapForMints using getMultipleAccounts
+ */
+function getTokenProgramMapForMintsManual(connection, mints) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (mints.length === 0) {
+            throw new Error(`No mints were passed in the parameter.`);
+        }
+        // Get multiple accounts info directly
+        const accountsInfo = yield connection.getMultipleAccountsInfo(mints);
+        let tokenProgramMap = {};
+        for (let i = 0; i < mints.length; i++) {
+            const pubkey = mints[i];
+            const accountInfo = accountsInfo[i];
+            if (!accountInfo) {
+                throw new Error(`Account info not found for mint: ${pubkey.toString()}`);
+            }
+            const tokenProgram = accountInfo.owner;
+            tokenProgramMap[pubkey.toString()] = tokenProgram;
+        }
+        return tokenProgramMap;
+    });
+}
+class MeteoraDLMM {
+    constructor(dlmm, ix) {
+        this.dlmm = dlmm;
+        this.ix = ix;
+        this.pubkey = this.dlmm.pubkey;
+    }
+    static create(connection, poolAddress, ix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this._instance == undefined || this._poolAddress !== poolAddress || ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.rpcEndpoint) !== connection.rpcEndpoint) {
+                const dlmm = yield dlmm_1.default.create(connection, poolAddress);
+                this._poolAddress = poolAddress;
+                this._connection = connection;
+                this._instance = new MeteoraDLMM(dlmm, ix);
+                this._program = dlmm.program;
+            }
+            return this._instance;
+        });
+    }
+    /**
+     * Meteora DLMM Program
+     *
+     * @param connection
+     */
+    static program(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._program == undefined) {
+                const dlmm = yield dlmm_1.default.create(connection, addresses_1.SOME_METEORA_DLMM_POOL);
+                this._program = dlmm.program;
+            }
+            return this._program;
+        });
+    }
+    getXYAmountDistribution(distribution, activeBin, lowerRange, upperRange) {
+        let xYAmountDistribution;
+        const bins = [];
+        if (lowerRange >= upperRange) {
+            throw new errors_1.AppError(`Lower range (${lowerRange}) cannot be greater than or less than upper range ((${upperRange})).`, `getXYAmountDistribution`);
+        }
+        for (let i = lowerRange; i <= upperRange; i++) {
+            bins.push(i);
+        }
+        if (distribution === "SPOT") {
+            xYAmountDistribution = (0, dlmm_1.calculateSpotDistribution)(activeBin.binId, bins);
+        }
+        else if (distribution === "CURVE") {
+            xYAmountDistribution = (0, dlmm_1.calculateNormalDistribution)(activeBin.binId, bins);
+        }
+        else if (distribution === "BID-ASK") {
+            xYAmountDistribution = (0, dlmm_1.calculateBidAskDistribution)(activeBin.binId, bins);
+        }
+        else {
+            throw new errors_1.AppError(`Invalid strategy ${distribution}. Can only be SPOT, CURVE, or BID-ASK.`, `getXYAmountDistribution`);
+        }
+        return xYAmountDistribution;
+    }
+    getActiveBin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dlmm.getActiveBin();
+        });
+    }
+    getPositionsByUserAndLbPair(userPubKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dlmm.getPositionsByUserAndLbPair(userPubKey);
+        });
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            if (!!!params.skipInputTokenCheck) {
+                // Throw error if input token(s) do not exist on blockchain
+                yield (0, functions_1.inputTokenExists)(anchor_1.Anchor.instance().connection, userWallet, [
+                    this.dlmm.tokenX.publicKey,
+                    this.dlmm.tokenY.publicKey,
+                ]);
+            }
+            let singleSidedX;
+            const [strategyType, oneSide] = types_1.StrategyTypeMap2[params.strategy.strategyType];
+            if (oneSide) {
+                if (params.totalXAmount.gt(new bn_js_1.default(0)) && params.totalYAmount.eq(new bn_js_1.default(0))) {
+                    singleSidedX = true;
+                }
+                else if (params.totalXAmount.eq(new bn_js_1.default(0)) && params.totalYAmount.gt(new bn_js_1.default(0))) {
+                    singleSidedX = false;
+                }
+                else {
+                    throw new errors_1.AppError("Total X or Y amount must be greater than 0 when adding liquidity one-sided", `initializePositionAndAddLiquidityByStrategy`);
+                }
+            }
+            const strategy = {
+                maxBinId: params.strategy.maxBinId,
+                minBinId: params.strategy.minBinId,
+                strategyType,
+                singleSidedX,
+            };
+            // Generate InitializePosition and AddLiquidityByStrategy instruction from Meteora API
+            const txn = yield this.dlmm.initializePositionAndAddLiquidityByStrategy({
+                positionPubKey: params.positionPubKey,
+                totalXAmount: params.totalXAmount,
+                totalYAmount: params.totalYAmount,
+                strategy,
+                user: params.user,
+            });
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            // Find mint from meteora instructions
+            const mints = (0, functions_1.getMintsFromInstruction)({
+                instructions: ixs,
+                find: {
+                    AddLiquidityByStrategy: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    "add_liquidity_by_strategy2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    AddLiquidityByStrategyOneSide: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [5],
+                    },
+                },
+            });
+            return new InitializePositionAndAddLiquidityByStrategyBuilder(
+            // Step 1: Init wSOL token account for user wallet (if X or Y token is wSOL)
+            // H-2106: also CreateIdempotent the non-wSOL source ATAs (see functions.ts).
+            [
+                ...(0, functions_1.wrapSolIfMintIsWsol)(userWallet, payer, [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ]),
+                ...yield (0, functions_1.createSourceAtasIdempotent)(connection, userWallet, payer, [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ]),
+            ], 
+            // Step 2: Deposit X and Y token to UserPDA
+            yield this.ix.iyfMain.depositMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                deposit: [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ],
+                pdaTokenType: (_a = params.opt) === null || _a === void 0 ? void 0 : _a.pdaTokenType,
+            }), 
+            // Step 3: Initialize position and add liquidity by strategy
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.user,
+                authority: userWallet,
+                opt: {
+                    pdaTokenType: (_b = params.opt) === null || _b === void 0 ? void 0 : _b.pdaTokenType,
+                    params: {
+                        withAmount: (_c = params.opt) === null || _c === void 0 ? void 0 : _c.withAmount,
+                        fuelAccount: (_d = params.opt) === null || _d === void 0 ? void 0 : _d.fuelAccount,
+                    },
+                },
+            }), 
+            // Step 4: Withdraw dust to user wallet
+            yield this.ix.iyfMain.withdrawMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint, amount: new bn_js_1.default(0) };
+                }),
+                pdaTokenType: (_e = params.opt) === null || _e === void 0 ? void 0 : _e.pdaTokenType,
+                hasAmount: false,
+            }), 
+            // Step 5: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints));
+        });
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            if (!!!params.skipInputTokenCheck) {
+                // Throw error if input token(s) do not exist on blockchain
+                yield (0, functions_1.inputTokenExists)(anchor_1.Anchor.instance().connection, userWallet, [
+                    this.dlmm.tokenX.publicKey,
+                    this.dlmm.tokenY.publicKey,
+                ]);
+            }
+            let singleSidedX;
+            const [strategyType, oneSide] = types_1.StrategyTypeMap2[params.strategy.strategyType];
+            if (oneSide) {
+                if (params.totalXAmount.gt(new bn_js_1.default(0)) && params.totalYAmount.eq(new bn_js_1.default(0))) {
+                    singleSidedX = true;
+                }
+                else if (params.totalXAmount.eq(new bn_js_1.default(0)) && params.totalYAmount.gt(new bn_js_1.default(0))) {
+                    singleSidedX = false;
+                }
+                else {
+                    throw new errors_1.AppError("Total X or Y amount must be greater than 0 when adding liquidity one-sided", `initializePositionAndAddLiquidityByStrategy`);
+                }
+            }
+            const strategy = {
+                maxBinId: params.strategy.maxBinId,
+                minBinId: params.strategy.minBinId,
+                strategyType,
+                singleSidedX,
+            };
+            // Generate InitializePosition and AddLiquidityByStrategy instruction from Meteora API
+            const txn = yield this.dlmm.initializePositionAndAddLiquidityByStrategy({
+                positionPubKey: params.positionPubKey,
+                totalXAmount: params.totalXAmount,
+                totalYAmount: params.totalYAmount,
+                strategy,
+                user: params.user,
+            });
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            // Find mint from meteora instructions
+            const mints = (0, functions_1.getMintsFromInstruction)({
+                instructions: ixs,
+                find: {
+                    AddLiquidityByStrategy: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    "add_liquidity_by_strategy2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    AddLiquidityByStrategyOneSide: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [5],
+                    },
+                },
+            });
+            return new InitializePositionAndAddLiquidityByStrategyBuilderLabeled(
+            // Step 1: Init wSOL token account for user wallet (if X or Y token is wSOL)
+            // H-2106: also CreateIdempotent the non-wSOL source ATAs (see functions.ts).
+            [
+                ...(0, functions_1.wrapSolIfMintIsWsolLabeled)(userWallet, payer, [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ]),
+                ...yield (0, functions_1.createSourceAtasIdempotentLabeled)(connection, userWallet, payer, [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ]),
+            ], 
+            // Step 2: Deposit X and Y token to UserPDA
+            yield this.ix.iyfMain.depositMultipleTokenWithToken2022WithLabel({
+                connection,
+                payer: userWallet,
+                deposit: [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ],
+                pdaTokenType: (_a = params.opt) === null || _a === void 0 ? void 0 : _a.pdaTokenType,
+            }), 
+            // Step 3: Initialize position and add liquidity by strategy
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.user,
+                authority: userWallet,
+                opt: {
+                    pdaTokenType: (_b = params.opt) === null || _b === void 0 ? void 0 : _b.pdaTokenType,
+                    params: {
+                        withAmount: (_c = params.opt) === null || _c === void 0 ? void 0 : _c.withAmount,
+                        fuelAccount: (_d = params.opt) === null || _d === void 0 ? void 0 : _d.fuelAccount,
+                    },
+                },
+                classification: `initializePositionAndAddLiquidityByStrategyLabelled`,
+            }), 
+            // Step 4: Withdraw dust to user wallet
+            yield this.ix.iyfMain.withdrawMultipleTokenWithToken2022WithLabel({
+                connection,
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint, amount: new bn_js_1.default(0) };
+                }),
+                pdaTokenType: (_e = params.opt) === null || _e === void 0 ? void 0 : _e.pdaTokenType,
+                hasAmount: false,
+            }), 
+            // Step 5: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsolLabeled)(userWallet, mints));
+        });
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!!!params.skipInputTokenCheck) {
+                // Throw error if input token(s) do not exist on blockchain
+                yield (0, functions_1.inputTokenExists)(anchor_1.Anchor.instance().connection, userWallet, [
+                    this.dlmm.tokenX.publicKey,
+                    this.dlmm.tokenY.publicKey,
+                ]);
+            }
+            const [strategyType, singleSidedX] = (0, functions_1.getMeteoraStrategyType)(params.strategy.strategyType, params.totalXAmount, params.totalYAmount);
+            // Generate InitializePosition and AddLiquidityByStrategy instruction from Meteora API
+            const txn = yield this.dlmm.initializePositionAndAddLiquidityByStrategy({
+                positionPubKey: params.positionPubKey,
+                totalXAmount: params.totalXAmount,
+                totalYAmount: params.totalYAmount,
+                strategy: {
+                    maxBinId: params.strategy.maxBinId,
+                    minBinId: params.strategy.minBinId,
+                    strategyType,
+                    singleSidedX,
+                },
+                user: params.user,
+            });
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            // Find mint from meteora instructions
+            const mints = (0, functions_1.getMintsFromInstruction)({
+                instructions: ixs,
+                find: {
+                    AddLiquidityByStrategy: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    "add_liquidity_by_strategy2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    AddLiquidityByStrategyOneSide: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [5],
+                    },
+                },
+            });
+            // Get token program map for mints (just for mint caching)
+            yield (0, functions_1.getTokenProgramMapForMints)(connection, mints);
+            return new InitializePositionAndAddLiquidityByStrategyPdaBuilder(
+            // Step 1: Initialize position and add liquidity by strategy
+            yield meteoraToHawksight({
+                ixs: ixs,
+                userPda: params.user,
+                authority: userWallet,
+                opt: {
+                    pdaTokenType: params.pdaTokenType,
+                },
+            }));
+        });
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!!!params.skipInputTokenCheck) {
+                // Throw error if input token(s) do not exist on blockchain
+                yield (0, functions_1.inputTokenExists)(anchor_1.Anchor.instance().connection, userWallet, [
+                    this.dlmm.tokenX.publicKey,
+                    this.dlmm.tokenY.publicKey,
+                ]);
+            }
+            const [strategyType, singleSidedX] = (0, functions_1.getMeteoraStrategyType)(params.strategy.strategyType, params.totalXAmount, params.totalYAmount);
+            // AddLiquidityByStrategy instruction from Meteora API
+            const txn = yield this.dlmm.addLiquidityByStrategy({
+                positionPubKey: params.positionPubKey,
+                totalXAmount: params.totalXAmount,
+                totalYAmount: params.totalYAmount,
+                strategy: {
+                    maxBinId: params.strategy.maxBinId,
+                    minBinId: params.strategy.minBinId,
+                    strategyType,
+                    singleSidedX,
+                },
+                user: params.user,
+                slippage: params.slippage,
+            });
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            // Find mint from meteora instructions
+            const mints = (0, functions_1.getMintsFromInstruction)({
+                instructions: ixs,
+                find: {
+                    AddLiquidityByStrategy: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    "add_liquidity_by_strategy2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    AddLiquidityByStrategyOneSide: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [5],
+                    },
+                },
+            });
+            // Populate mint cache for automation CPI
+            // Include both mints from instructions and DLMM pool mints
+            const allMints = [
+                ...mints,
+                this.dlmm.tokenX.publicKey,
+                this.dlmm.tokenY.publicKey
+            ];
+            if (allMints.length > 0) {
+                try {
+                    yield (0, functions_1.getTokenProgramMapForMints)(connection, allMints);
+                }
+                catch (error) {
+                    console.error(`Error populating cache:`, error);
+                    throw error;
+                }
+            }
+            return new AddLiquidityByStrategyBuilder(
+            // Step 1: Init wSOL token account for user wallet (if X or Y token is wSOL)
+            // H-2106: also CreateIdempotent the non-wSOL source ATAs (see functions.ts).
+            [
+                ...(0, functions_1.wrapSolIfMintIsWsol)(userWallet, payer, [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ]),
+                ...yield (0, functions_1.createSourceAtasIdempotent)(connection, userWallet, payer, [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ]),
+            ], 
+            // Step 2: Deposit X and Y token to UserPDA
+            yield this.ix.iyfMain.depositMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                deposit: [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ],
+                pdaTokenType: params.pdaTokenType,
+            }), 
+            // Step 3: Add liquidity by strategy
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.user,
+                authority: userWallet,
+                opt: {
+                    pdaTokenType: params.pdaTokenType,
+                },
+            }), 
+            // Step 4: Withdraw dust to user wallet
+            yield this.ix.iyfMain.withdrawMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint, amount: new bn_js_1.default(0) };
+                }),
+                pdaTokenType: params.pdaTokenType,
+                hasAmount: false,
+            }), 
+            // Step 5: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints));
+        });
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Claim fees and/or rewards, remove liquidity, and possibly close position from Meteora API (if set)
+            const txn = yield this.dlmm.removeLiquidity(params);
+            const lbPair = this.dlmm.pubkey;
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            // BUG FIX: Meteora SDK's removeLiquidity doesn't include claimReward instructions for LM farms.
+            // We need to manually generate claimReward instructions for each active reward farm
+            // and insert them before closePosition to prevent "NonEmptyPosition" error (6030).
+            // These are generated as IYF-wrapped instructions and added after transformation.
+            const claimRewardIxs = [];
+            const rewardMints = [];
+            if (params.shouldClaimAndClose) {
+                let rewardIndex = -1;
+                for (const reward of this.dlmm.rewards) {
+                    rewardIndex++;
+                    if (reward && !reward.mint.address.equals(web3.SystemProgram.programId)) {
+                        const claimRewardIx = params.rewardClaimMode === 'automation'
+                            ? yield this.ix.meteoraDlmm.claimReward2Automation(connection, {
+                                userWallet,
+                                lbPair,
+                                position: params.position,
+                                rewardIndex,
+                                rewardMint: reward.mint.address,
+                                rewardVault: reward.reserve,
+                                tokenProgram: reward.owner,
+                                lowerBinId: params.fromBinId,
+                                upperBinId: params.toBinId,
+                                pdaTokenType: (_a = params.pdaTokenType) !== null && _a !== void 0 ? _a : types_1.TokenType.ATA,
+                                remainingAccountsInfo: yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, reward.mint.address, reward.owner),
+                            })
+                            : yield this.ix.meteoraDlmm.claimReward2(connection, {
+                                userWallet,
+                                lbPair,
+                                position: params.position,
+                                rewardIndex,
+                                rewardMint: reward.mint.address,
+                                rewardVault: reward.reserve,
+                                tokenProgram: reward.owner,
+                                lowerBinId: params.fromBinId,
+                                upperBinId: params.toBinId,
+                            });
+                        claimRewardIxs.push(claimRewardIx);
+                        rewardMints.push(reward.mint.address);
+                    }
+                }
+            }
+            // Find mint from meteora instructions
+            const mintsFromIxs = (0, functions_1.getMintsFromInstruction)({
+                instructions: ixs,
+                find: {
+                    RemoveLiquidity: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    "remove_liquidity2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    RemoveLiquidityByRange: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    "remove_liquidity_by_range2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    ClaimFee: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [9, 10],
+                    },
+                    "claim_fee2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    ClaimReward: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [6],
+                    },
+                    "claim_reward2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [4],
+                        manualSnakeCase: true,
+                    },
+                },
+            });
+            // Combine mints from instructions with manually tracked reward mints
+            // (claimReward2 instructions generated above are wrapped in IYF Extension, so we track reward mints separately)
+            const mints = [...mintsFromIxs, ...rewardMints];
+            // TODO: take out redundant call
+            // Get token program map for mints (just for mint caching)
+            yield (0, functions_1.getTokenProgramMapForMints)(connection, mints);
+            // Get token mints (for caching) - manual implementation
+            const tokenProgramMap = yield getTokenProgramMapForMintsManual(connection, mints);
+            const ataIxs = (0, functions_1.createAtaIdempotentIxs)({
+                accounts: mints.map((mint) => {
+                    return { owner: params.user, payer, mint, programId: tokenProgramMap[mint.toString()] };
+                }),
+            });
+            let mainIx = yield meteoraToHawksight({
+                ixs,
+                userPda: params.user,
+                authority: userWallet,
+                opt: {
+                    pdaTokenType: params.pdaTokenType,
+                    params: {
+                        fuelAccount: params.fuelAccount,
+                        lbPair: lbPair,
+                    },
+                },
+            });
+            // Insert claimReward instructions before closePosition in mainIx
+            if (claimRewardIxs.length > 0) {
+                // Find closePosition index in transformed instructions
+                // ClosePosition instructions have sighash matching "MeteoraDlmmClosePosition2" or similar
+                const closePositionIndex = mainIx.findIndex((ix) => {
+                    const dataWithoutIyfExtensionExecute = ix.data.subarray(12);
+                    return (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClosePosition2') ||
+                        (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClosePosition2Automation');
+                });
+                if (closePositionIndex !== -1) {
+                    // Insert claimReward instructions before closePosition
+                    mainIx = [
+                        ...mainIx.slice(0, closePositionIndex),
+                        ...claimRewardIxs,
+                        ...mainIx.slice(closePositionIndex),
+                    ];
+                }
+                else {
+                    // No closePosition found, append claimReward instructions
+                    mainIx = [...mainIx, ...claimRewardIxs];
+                }
+            }
+            const withdrawIx = yield this.ix.iyfMain.withdrawMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint, amount: new bn_js_1.default(0) };
+                }),
+                pdaTokenType: params.pdaTokenType,
+                hasAmount: false,
+            });
+            const unwrapIxs = (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints);
+            return new RemoveLiquidityBuilder(
+            // Step 1: Init ATA prior to withdrawal
+            ataIxs, 
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            mainIx, 
+            // Step 3: Withdraw tokens to user wallet
+            withdrawIx, 
+            // Step 4: Close wSOL account (if there's any)
+            unwrapIxs);
+        });
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Claim fees and/or rewards, remove liquidity, and possibly close position from Meteora API (if set)
+            const txn = yield this.dlmm.removeLiquidity(params);
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            // Find mint from meteora instructions
+            const mints = (0, functions_1.getMintsFromInstruction)({
+                instructions: ixs,
+                find: {
+                    RemoveLiquidity: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    RemoveLiquidityByRange: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    ClaimFee: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [9, 10],
+                    },
+                    ClaimReward: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [6],
+                    },
+                },
+            });
+            const allMints = [
+                ...mints,
+                this.dlmm.tokenX.publicKey,
+                this.dlmm.tokenY.publicKey
+            ];
+            if (allMints.length > 0) {
+                try {
+                    yield (0, functions_1.getTokenProgramMapForMints)(connection, allMints);
+                }
+                catch (error) {
+                    console.error(`Error populating cache:`, error);
+                    throw error;
+                }
+            }
+            return new RemoveLiquidityPdaBuilder(
+            // Step 1: Init ATA prior to withdrawal
+            // createAtaIdempotentIxs({
+            //   accounts: mints.map((mint) => {
+            //     return { owner: params.user, payer, mint };
+            //   }),
+            // }),
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.user,
+                authority: userWallet,
+                opt: {
+                    pdaTokenType: params.pdaTokenType,
+                },
+            }));
+        });
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Claim all fees and rewards instruction from Meteora API
+            const txn = yield this.dlmm.claimAllRewardsByPosition(params);
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            // Find mint from meteora instructions
+            const mints = (0, functions_1.getMintsFromInstruction)({
+                instructions: ixs,
+                find: {
+                    ClaimFee: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [9, 10],
+                    },
+                    "claim_fee2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                        manualSnakeCase: true,
+                    },
+                    "claim_reward2": {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [4],
+                        manualSnakeCase: true,
+                    },
+                    ClaimReward: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [6],
+                    },
+                },
+            });
+            return new ClaimAllRewardsByPositionBuilder(
+            // Step 1: Init ATA prior to withdrawal
+            (0, functions_1.createAtaIdempotentIxs)({
+                accounts: mints.map((mint) => {
+                    return { owner: params.owner, payer, mint };
+                }),
+            }), 
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.owner,
+                authority: userWallet,
+            }), 
+            // Step 3: Withdraw tokens to user wallet
+            yield this.ix.iyfMain.withdrawMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint, amount: new bn_js_1.default(0) };
+                }),
+                pdaTokenType: types_1.TokenType.ATA,
+                hasAmount: false,
+            }), 
+            // Step 4: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints));
+        });
+    }
+    /**
+     * 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, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Close position from Meteora API
+            const txn = yield this.dlmm.closePosition(params);
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_1.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            return [
+                // Step 1: Close meteora position
+                ...(yield meteoraToHawksight({
+                    ixs,
+                    userPda: params.owner,
+                    authority: userWallet,
+                })),
+            ];
+            return ixs;
+        });
+    }
+}
+exports.MeteoraDLMM = MeteoraDLMM;
+/**
+ * Meteora functions / transaction generators that we re-written for performance improvement purposes
+ */
+class MeteoraFunctions {
+    constructor(ix) {
+        this.ix = ix;
+        /**
+         * Position cache (v1)
+         */
+        this.positions_v1 = {};
+        /**
+         * Position cache (v2)
+         */
+        this.positions_v2 = {};
+        /**
+         * Pool cache
+         */
+        this.pools = {};
+    }
+    /**
+     * 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, userWallet, payer, params, meteoraToHawksight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create DLMM instance
+            const dlmm = yield dlmm_1.default.create(connection, params.lbPair);
+            // Generate claim fee and reward instruction (fast generator)
+            let [ixs, position] = yield Promise.all([
+                this.claimFee2AndReward2Ixs(connection, params.lbPair, params.position, params.owner, dlmm.tokenX.owner, dlmm.tokenY.owner),
+                dlmm.getPosition(params.position),
+            ]);
+            // Get tokenX and tokenY mints
+            const mints = [
+                dlmm.tokenX.mint.address,
+                dlmm.tokenY.mint.address,
+            ];
+            // Get reward mints
+            dlmm.rewards.forEach((reward) => {
+                if (reward) {
+                    mints.push(reward.mint.address);
+                }
+            });
+            // Get token program map for mints
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, mints);
+            // Check if any of the mints has token2022 program id
+            const hasToken2022 = mints.some((mint) => {
+                return tokenProgramMap[mint.toString()].equals(addresses_1.TOKEN_2022_PROGRAM_ID);
+            });
+            if (hasToken2022) {
+                const userPda = (0, functions_1.generateUserPda)(userWallet);
+                const txn = yield dlmm.claimAllRewards({
+                    owner: userPda,
+                    positions: [
+                        position,
+                    ]
+                });
+                const _ixs = [];
+                for (const tx of txn) {
+                    _ixs.push(...tx.instructions);
+                }
+                const claimIxs = [];
+                for (const ix of _ixs) {
+                    const isMeteoraInstruction = ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM);
+                    const isClaimFee2Ix = (0, functions_1.sighashMatch)(ix.data, (0, functions_1.sighash)('claim_fee2', undefined, true), undefined, undefined, true);
+                    const isClaimReward2Ix = (0, functions_1.sighashMatch)(ix.data, (0, functions_1.sighash)('claim_reward2', undefined, true), undefined, undefined, true);
+                    if (isMeteoraInstruction && (isClaimFee2Ix || isClaimReward2Ix)) {
+                        claimIxs.push(ix);
+                    }
+                }
+                ixs = claimIxs;
+            }
+            return new ClaimAllRewardsByPositionBuilder(
+            // Step 1: Init ATA prior to withdrawal
+            params.pdaTokenType === types_1.TokenType.STA ? yield this.ix.iyfMain.initializeStorageTokenAccounts(connection, { userWallet, mints }) : (0, functions_1.createAtaIdempotentIxs)({
+                accounts: mints.map((mint) => {
+                    return { owner: params.owner, payer, mint, programId: tokenProgramMap[mint.toString()] };
+                }),
+            }), 
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.owner,
+                authority: userWallet,
+                opt: {
+                    pdaTokenType: params.pdaTokenType === types_1.TokenType.STA ? types_1.TokenType.STA : types_1.TokenType.ATA,
+                },
+            }), 
+            // Step 3: Withdraw tokens to user wallet
+            yield this.ix.iyfMain.withdrawMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint, amount: new bn_js_1.default(0) };
+                }),
+                pdaTokenType: params.pdaTokenType === types_1.TokenType.STA ? types_1.TokenType.STA : types_1.TokenType.ATA,
+                hasAmount: false,
+            }), 
+            // Step 4: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints));
+        });
+    }
+    constants(program) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const CONSTANTS = Object.entries(program.idl.constants);
+        const MAX_BIN_ARRAY_SIZE = new bn_js_1.default((_b = ((_a = CONSTANTS.find(([k, v]) => v.name == "MAX_BIN_PER_ARRAY")) === null || _a === void 0 ? void 0 : _a[1]).value) !== null && _b !== void 0 ? _b : 0);
+        const MAX_BIN_PER_POSITION = new bn_js_1.default((_d = ((_c = CONSTANTS.find(([k, v]) => v.name == "MAX_BIN_PER_POSITION")) === null || _c === void 0 ? void 0 : _c[1]).value) !== null && _d !== void 0 ? _d : 0);
+        const BIN_ARRAY_BITMAP_SIZE = new bn_js_1.default((_f = ((_e = CONSTANTS.find(([k, v]) => v.name == "BIN_ARRAY_BITMAP_SIZE")) === null || _e === void 0 ? void 0 : _e[1]).value) !== null && _f !== void 0 ? _f : 0);
+        const EXTENSION_BINARRAY_BITMAP_SIZE = new bn_js_1.default((_h = ((_g = CONSTANTS.find(([k, v]) => v.name == "EXTENSION_BINARRAY_BITMAP_SIZE")) === null || _g === void 0 ? void 0 : _g[1])
+            .value) !== null && _h !== void 0 ? _h : 0);
+        return {
+            MAX_BIN_ARRAY_SIZE,
+            MAX_BIN_PER_POSITION,
+            BIN_ARRAY_BITMAP_SIZE,
+            EXTENSION_BINARRAY_BITMAP_SIZE,
+        };
+    }
+    static findMeteoraTickArrayIndices(minBinId, maxBinId) {
+        const MAX_BIN_ARRAY_SIZE = new bn_js_1.default(anchor_1.Anchor.instance().meteoraProgram.idl.constants[1].value);
+        const binIdStrings = {};
+        for (let binId = minBinId; binId <= maxBinId; binId++) {
+            binIdStrings[MeteoraFunctions.binIdToBinArrayIndex(MAX_BIN_ARRAY_SIZE, new bn_js_1.default(binId)).toString()] = 1;
+        }
+        const binIds = Object.keys(binIdStrings).map(v => new bn_js_1.default(v)).sort((a, b) => a.toNumber() - b.toNumber());
+        return binIds;
+    }
+    static findMeteoraTickArrays(lbPair, minBinId, maxBinId) {
+        const binIds = MeteoraFunctions.findMeteoraTickArrayIndices(minBinId, maxBinId);
+        const tickArrays = binIds.map(binId => MeteoraFunctions.deriveBinArray(lbPair, binId));
+        const tickArrayUpperIndex = binIds[binIds.length - 1].add(new bn_js_1.default(1));
+        const tickArrayUpper = MeteoraFunctions.deriveBinArray(lbPair, tickArrayUpperIndex);
+        tickArrays.push(tickArrayUpper);
+        return tickArrays;
+    }
+    deriveReserve(token, lbPair) {
+        const [reserve] = web3.PublicKey.findProgramAddressSync([
+            lbPair.toBuffer(),
+            token.toBuffer(),
+        ], addresses_1.METEORA_DLMM_PROGRAM);
+        return reserve;
+    }
+    static deriveBinArray(lbPair, index) {
+        let binArrayBytes;
+        if (index.isNeg()) {
+            binArrayBytes = new Uint8Array(index.toTwos(64).toArrayLike(Buffer, "le", 8));
+        }
+        else {
+            binArrayBytes = new Uint8Array(index.toArrayLike(Buffer, "le", 8));
+        }
+        const [binArray] = web3.PublicKey.findProgramAddressSync([Buffer.from("bin_array"), lbPair.toBytes(), binArrayBytes], addresses_1.METEORA_DLMM_PROGRAM);
+        return binArray;
+    }
+    static binIdToBinArrayIndex(MAX_BIN_ARRAY_SIZE, binId) {
+        const { div: idx, mod } = binId.divmod(MAX_BIN_ARRAY_SIZE);
+        return binId.isNeg() && !mod.isZero() ? idx.sub(new bn_js_1.default(1)) : idx;
+    }
+    getPositionAndLbPair(connection, lbPair, position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const program = yield MeteoraDLMM.program(connection);
+            // const constants = this.constants(program);
+            const constants = {
+                MAX_BIN_ARRAY_SIZE: new bn_js_1.default(70),
+                MAX_BIN_PER_POSITION: new bn_js_1.default(70),
+                BIN_ARRAY_BITMAP_SIZE: new bn_js_1.default(512),
+                EXTENSION_BINARRAY_BITMAP_SIZE: new bn_js_1.default(12),
+            };
+            const [lbPairInfo, positionInfo] = yield connection.getMultipleAccountsInfo([lbPair, position]);
+            const lbPairAccount = program.coder.accounts.decode('lbPair', lbPairInfo.data);
+            const positionAccount = program.coder.accounts.decode('positionV2', positionInfo.data);
+            return {
+                lbPairAccount,
+                positionAccount,
+                constants,
+            };
+        });
+    }
+    /**
+     * Returns all position of user
+     *
+     * @param connection
+     * @param userPda
+     */
+    getAllUserPosition(connection, userPda) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const program = yield MeteoraDLMM.program(connection);
+            // Returns all position owned by user.
+            // What is not sure is whether these positions are closed already.
+            const promiseResult = yield Promise.all([
+                userPda && program.account.position.all([
+                    {
+                        memcmp: {
+                            bytes: bs58_1.default.encode(userPda.toBuffer()),
+                            offset: 8 + 32
+                        }
+                    }
+                ]),
+                userPda && program.account.positionV2.all([
+                    {
+                        memcmp: {
+                            bytes: bs58_1.default.encode(userPda.toBuffer()),
+                            offset: 8 + 32
+                        }
+                    }
+                ])
+            ]);
+            const [_positions, _positionsV2] = promiseResult;
+            const positions = [..._positions, ..._positionsV2];
+            // Remember v1 positions
+            for (const position of _positions) {
+                this.positions_v1[position.publicKey.toString()] = position.account;
+            }
+            // Remember v2 positions
+            for (const position of _positionsV2) {
+                this.positions_v2[position.publicKey.toString()] = position.account;
+            }
+            // Get all pools (lbPair)
+            const temp = positions.map(position => position.account.lbPair);
+            const pools = [];
+            // Trim repeat pool (ensure that pools are unique)
+            const unique = {};
+            for (const pool of temp) {
+                if (unique[pool.toString()] === undefined) {
+                    pools.push(pool);
+                    unique[pool.toString()] = pool;
+                }
+            }
+            // Download all pools and update cache
+            const lbPairs = yield program.account.lbPair.fetchMultiple(pools);
+            lbPairs.map((lbPair, index) => {
+                const key = pools[index].toString();
+                if (lbPair !== undefined && lbPair !== null) {
+                    this.pools[key] = lbPair;
+                }
+            });
+            return positions.map(position => position.publicKey);
+        });
+    }
+    getPositions(dlmm, positions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            for (const position of positions) {
+                promises.push(Promise.all([
+                    dlmm.program.account.positionV2.fetch(position),
+                    dlmm.getPosition(position),
+                ]));
+            }
+            const results = yield Promise.all(promises);
+            return results;
+        });
+    }
+    /**
+     * Generate instruction that claims all fees and rewards by user
+     *
+     * @param connection
+     * @param lbPair
+     * @param positions
+     * @param userPda
+     * @returns
+     */
+    claimFeeAndRewardIxs2(connection, positions, userWallet, userPda, meteoraToHawksight, lbPair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const result = await this.getPositionAndLbPair(connection, lbPair, position);
+            // const result = await this.getPositionAndLbPair(connection, SOME_METEORA_DLMM_POOL, positions[0]);
+            const dlmm = yield dlmm_1.default.create(connection, lbPair !== null && lbPair !== void 0 ? lbPair : addresses_1.SOME_METEORA_DLMM_POOL);
+            // const program = await MeteoraDLMM.program(connection);
+            // const constants = result.constants;
+            // const constants = this.constants(program);
+            // const constants = {
+            //   MAX_BIN_ARRAY_SIZE: new BN(70),
+            //   MAX_BIN_PER_POSITION: new BN(70),
+            //   BIN_ARRAY_BITMAP_SIZE: new BN(512),
+            //   EXTENSION_BINARRAY_BITMAP_SIZE: new BN(12),
+            // };
+            // await this.getAllUserPosition(connection, userPda);
+            const ixs = [];
+            const _positions = yield this.getPositions(dlmm, positions);
+            const pairMints = [];
+            const rewardMints = [];
+            const claimFeeIxs = [];
+            const claimRewardIxs = [];
+            for (const position of _positions) {
+                const positionAccount = position[0];
+                const positionData = position[1];
+                let txn = [];
+                const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2(connection, {
+                    userWallet,
+                    lbPair: positionAccount.lbPair,
+                    position: positionData.publicKey,
+                    tokenMintX: dlmm.tokenX.mint.address,
+                    tokenMintY: dlmm.tokenY.mint.address,
+                    tokenProgramX: dlmm.tokenX.owner,
+                    tokenProgramY: dlmm.tokenY.owner,
+                    lowerBinId: positionData.positionData.lowerBinId,
+                    upperBinId: positionData.positionData.upperBinId,
+                });
+                claimFeeIxs.push(claimFeeIx);
+                pairMints.push(dlmm.tokenX.mint.address);
+                pairMints.push(dlmm.tokenY.mint.address);
+                let rewardIndex = -1;
+                for (const reward of dlmm.rewards) {
+                    rewardIndex++;
+                    if (reward && !reward.mint.address.equals(web3.SystemProgram.programId)) {
+                        const claimRewardIx = yield this.ix.meteoraDlmm.claimReward2(connection, {
+                            userWallet,
+                            lbPair: positionAccount.lbPair,
+                            position: positionData.publicKey,
+                            rewardIndex,
+                            rewardMint: reward.mint.address,
+                            rewardVault: reward.reserve,
+                            tokenProgram: reward.owner,
+                            lowerBinId: positionData.positionData.lowerBinId,
+                            upperBinId: positionData.positionData.upperBinId,
+                        });
+                        claimRewardIxs.push(claimRewardIx);
+                        rewardMints.push(reward.mint.address);
+                    }
+                }
+            }
+            // Find mint from meteora instructions
+            const mints = (() => {
+                const mints = [...pairMints, ...rewardMints];
+                // Remove duplicates
+                const set = new Set(mints.map(mint => mint.toString()));
+                const unique = Array.from(set).map(mint => new web3.PublicKey(mint));
+                return unique;
+            })();
+            // Get token program map for mints
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, mints);
+            return new ClaimAllRewardsByPositionBuilder(
+            // Step 1: Init ATA prior to withdrawal
+            (0, functions_1.createAtaIdempotentIxs)({
+                accounts: mints.map((mint) => {
+                    return { owner: userPda, payer: userWallet, mint, programId: tokenProgramMap[mint.toString()] };
+                }),
+            }), 
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            [...claimFeeIxs, ...claimRewardIxs], 
+            // Step 3: Withdraw tokens to user wallet
+            yield this.ix.iyfMain.withdrawMultipleTokenWithToken2022({
+                connection,
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint, amount: new bn_js_1.default(0) };
+                }),
+                pdaTokenType: types_1.TokenType.ATA,
+                hasAmount: false,
+            }), 
+            // Step 4: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints));
+        });
+    }
+    claimFee2AndReward2Ixs(connection, lbPair, position, userPda, tokenProgramX, tokenProgramY) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.getPositionAndLbPair(connection, lbPair, position);
+            // Populate cache with reward mints to prevent "Reward mint not found in cache" errors
+            const rewardMints = [];
+            for (let i = 0; i < 2; i++) {
+                const rewardInfo = result.lbPairAccount.rewardInfos[i];
+                if (rewardInfo && !rewardInfo.mint.equals(web3.PublicKey.default)) {
+                    rewardMints.push(rewardInfo.mint);
+                }
+            }
+            if (rewardMints.length > 0) {
+                yield (0, functions_1.getTokenProgramMapForMints)(connection, rewardMints);
+            }
+            const claimFeeIx = this.claimFee2Ix(lbPair, position, userPda, tokenProgramX, tokenProgramY, result);
+            const claimRewardIxs = this.claimReward2Ixs(lbPair, position, userPda, result);
+            return [
+                claimFeeIx,
+                ...claimRewardIxs
+            ];
+        });
+    }
+    claimFee2Ix(lbPair, position, userPda, tokenProgramX, tokenProgramY, getPositionAndLbPairResult) {
+        const tokenMintX = getPositionAndLbPairResult.lbPairAccount.tokenXMint;
+        const tokenMintY = getPositionAndLbPairResult.lbPairAccount.tokenYMint;
+        const { lowerBinId, upperBinId } = getPositionAndLbPairResult.positionAccount;
+        const binArrays = this.ix.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+        const userTokenX = (0, functions_1.generateAta)(userPda, tokenMintX);
+        const userTokenY = (0, functions_1.generateAta)(userPda, tokenMintY);
+        const reserveX = this.deriveReserve(tokenMintX, lbPair);
+        const reserveY = this.deriveReserve(tokenMintY, lbPair);
+        const ix = new web3.TransactionInstruction({
+            programId: addresses_1.METEORA_DLMM_PROGRAM,
+            keys: [
+                { pubkey: lbPair, isSigner: false, isWritable: true },
+                { pubkey: position, isSigner: false, isWritable: true },
+                { pubkey: userPda, isSigner: false, isWritable: false },
+                { pubkey: reserveX, isSigner: false, isWritable: true },
+                { pubkey: reserveY, isSigner: false, isWritable: true },
+                { pubkey: userTokenX, isSigner: false, isWritable: true },
+                { pubkey: userTokenY, isSigner: false, isWritable: true },
+                { pubkey: tokenMintX, isSigner: false, isWritable: false },
+                { pubkey: tokenMintY, isSigner: false, isWritable: false },
+                { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+                { pubkey: tokenProgramY, isSigner: false, isWritable: false },
+                { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                { pubkey: addresses_1.METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+                { pubkey: addresses_1.METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                ...binArrays.map(binArray => ({ pubkey: binArray, isSigner: false, isWritable: true })),
+            ],
+            data: Buffer.concat([
+                new Uint8Array((0, functions_1.sighash)('claim_fee2', undefined, true)),
+                new Uint8Array(new bn_js_1.default(lowerBinId).toTwos(32).toArrayLike(Buffer, 'le', 4)),
+                new Uint8Array(new bn_js_1.default(upperBinId).toTwos(32).toArrayLike(Buffer, 'le', 4)),
+                new Uint8Array([0x00, 0x00, 0x00, 0x00]),
+            ]),
+        });
+        return ix;
+    }
+    claimReward2Ixs(lbPair, position, userPda, getPositionAndLbPairResult) {
+        const { lowerBinId, upperBinId } = getPositionAndLbPairResult.positionAccount; // serve as minBinId and maxBinId as well
+        const binArrays = this.ix.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+        const ixs = [];
+        for (let i = 0; i < 2; i++) {
+            const rewardInfo = getPositionAndLbPairResult.lbPairAccount.rewardInfos[i];
+            if (!rewardInfo || rewardInfo.mint.equals(web3.PublicKey.default))
+                continue;
+            const userTokenAccount = (0, functions_1.generateAta)(userPda, rewardInfo.mint);
+            const ix = new web3.TransactionInstruction({
+                programId: addresses_1.METEORA_DLMM_PROGRAM,
+                keys: [
+                    { pubkey: lbPair, isSigner: false, isWritable: true },
+                    { pubkey: position, isSigner: false, isWritable: true },
+                    { pubkey: userPda, isSigner: false, isWritable: false },
+                    { pubkey: rewardInfo.vault, isSigner: false, isWritable: true },
+                    { pubkey: rewardInfo.mint, isSigner: false, isWritable: true },
+                    { pubkey: userTokenAccount, isSigner: false, isWritable: true },
+                    { pubkey: addresses_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+                    { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                    { pubkey: addresses_1.METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+                    { pubkey: addresses_1.METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                    ...binArrays.map(binArray => ({ pubkey: binArray, isSigner: false, isWritable: true })),
+                ],
+                data: Buffer.concat([
+                    new Uint8Array((0, functions_1.sighash)('claim_reward2', undefined, true)),
+                    new Uint8Array((new bn_js_1.default(i)).toArrayLike(Buffer, 'le', 8)),
+                    new Uint8Array(new bn_js_1.default(lowerBinId).toTwos(32).toArrayLike(Buffer, 'le', 4)),
+                    new Uint8Array(new bn_js_1.default(upperBinId).toTwos(32).toArrayLike(Buffer, 'le', 4)),
+                    new Uint8Array([0x00, 0x00, 0x00, 0x00]),
+                ]),
+            });
+            ixs.push(ix);
+        }
+        (0, Logging_1.Log)(`Reward ixs count: ` + ixs.length);
+        return ixs;
+    }
+}
+exports.MeteoraFunctions = MeteoraFunctions;
+/**
+ * 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.
+ */
+class ClaimAllRewardsByPositionBuilder {
+    /**
+     * 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, mainIxs, withdrawMultipleTokenIx, unwrapWsolIxs) {
+        this.createAtaIxs = createAtaIxs;
+        this.mainIxs = mainIxs;
+        this.withdrawMultipleTokenIx = withdrawMultipleTokenIx;
+        this.unwrapWsolIxs = unwrapWsolIxs;
+    }
+    /**
+     * 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() {
+        return [
+            // Step 1: Init ATA prior to withdrawal
+            ...this.createAtaIxs,
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            ...this.mainIxs,
+            // Step 3: Withdraw tokens to user wallet
+            this.withdrawMultipleTokenIx,
+            // Step 4: Close wSOL account (if there's any)
+            ...this.unwrapWsolIxs,
+        ];
+    }
+    /**
+     * Replaces claim fee token ixs into storage token account
+     */
+    replaceClaimFeeTokenToSTA() {
+        const index = this.mainIxs.findIndex(mainIx => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            return (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, "MeteoraDlmmClaimFee2Automation");
+        });
+        // Should never be empty
+        if (index === -1) {
+            // Throw error instead?
+            console.warn(`Warn: claim fee instruction not found! This should not happen.`);
+            return;
+        }
+        const userPda = this.mainIxs[index].keys[0].pubkey;
+        const tokenXMint = this.mainIxs[index].keys[9].pubkey;
+        const tokenYMint = this.mainIxs[index].keys[10].pubkey;
+        const staTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+        const staTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+        this.mainIxs[index].keys[7].pubkey = staTokenX;
+        this.mainIxs[index].keys[8].pubkey = staTokenY;
+    }
+    /**
+     * 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() {
+        let foundAny = false;
+        this.mainIxs.forEach((mainIx, index) => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            if ((0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2Automation') ||
+                (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2')) {
+                foundAny = true;
+                const userPda = this.mainIxs[index].keys[0].pubkey;
+                const tokenMint = this.mainIxs[index].keys[6].pubkey;
+                const staToken = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenMint);
+                this.mainIxs[index].keys[7].pubkey = staToken;
+            }
+        });
+        if (!foundAny) {
+            console.warn('Warn: Reward instruction not found! This may happen if pool has no rewards');
+        }
+    }
+}
+exports.ClaimAllRewardsByPositionBuilder = ClaimAllRewardsByPositionBuilder;
+/**
+ * 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.
+ */
+class AddLiquidityByStrategyBuilder {
+    /**
+     * 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, depositToPdaIxs, mainIxs, refundDustIxs, unwrapWsolIxs) {
+        this.wrapSolIxs = wrapSolIxs;
+        this.depositToPdaIxs = depositToPdaIxs;
+        this.mainIxs = mainIxs;
+        this.refundDustIxs = refundDustIxs;
+        this.unwrapWsolIxs = unwrapWsolIxs;
+    }
+    /**
+     * 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() {
+        return [
+            // Step 1: Init wSOL token account for user wallet (if X or Y token is wSOL)
+            ...this.wrapSolIxs,
+            // Step 2: Deposit X and Y token to UserPDA
+            this.depositToPdaIxs,
+            // Step 3: Add liquidity by strategy
+            ...this.mainIxs,
+            // Step 4: Refund dust to user wallet
+            this.refundDustIxs,
+            // Step 5: Close wSOL account (if there's any)
+            ...this.unwrapWsolIxs,
+        ];
+    }
+}
+exports.AddLiquidityByStrategyBuilder = AddLiquidityByStrategyBuilder;
+/**
+ * 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.
+ */
+class RemoveLiquidityBuilder {
+    /**
+     * 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, mainIxs, withdrawMultipleTokenIx, unwrapWsolIxs) {
+        this.createAtaIxs = createAtaIxs;
+        this.mainIxs = mainIxs;
+        this.withdrawMultipleTokenIx = withdrawMultipleTokenIx;
+        this.unwrapWsolIxs = unwrapWsolIxs;
+    }
+    /**
+     * 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() {
+        return [
+            // Step 1: Init ATA prior to withdrawal
+            ...this.createAtaIxs,
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            ...this.mainIxs,
+            // Step 3: Withdraw tokens to user wallet
+            this.withdrawMultipleTokenIx,
+            // Step 4: Close wSOL account (if there's any)
+            ...this.unwrapWsolIxs,
+        ];
+    }
+    /**
+     * Replaces claim fee token ixs into storage token account
+     */
+    replaceClaimFeeTokenToSTA() {
+        const index = this.mainIxs.findIndex(mainIx => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            return (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, "MeteoraDlmmClaimFee2Automation");
+        });
+        if (index === -1) {
+            console.warn(`Warn: claim fee instruction not found! This should not happen if \`shouldClaimAndClose\` is set to true.`);
+            return;
+        }
+        const userPda = this.mainIxs[index].keys[0].pubkey;
+        const tokenXMint = this.mainIxs[index].keys[9].pubkey;
+        const tokenYMint = this.mainIxs[index].keys[10].pubkey;
+        const staTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+        const staTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+        this.mainIxs[index].keys[7].pubkey = staTokenX;
+        this.mainIxs[index].keys[8].pubkey = staTokenY;
+    }
+    /**
+     * 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() {
+        let foundAny = false;
+        this.mainIxs.forEach((mainIx, index) => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            if ((0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2Automation') ||
+                (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2')) {
+                foundAny = true;
+                const userPda = this.mainIxs[index].keys[0].pubkey;
+                const tokenMint = this.mainIxs[index].keys[6].pubkey;
+                const staToken = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenMint);
+                this.mainIxs[index].keys[7].pubkey = staToken;
+            }
+        });
+        if (!foundAny) {
+            console.warn('Warn: Reward instruction not found! This may happen if pool has no rewards');
+        }
+    }
+    /**
+     * Replaces claim fee token ixs into associated token account
+     */
+    replaceClaimFeeTokenToATA() {
+        const index = this.mainIxs.findIndex(mainIx => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            return (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, "MeteoraDlmmClaimFee2Automation");
+        });
+        if (index === -1) {
+            console.warn(`Warn: claim fee instruction not found! This should not happen if \`shouldClaimAndClose\` is set to true.`);
+            return;
+        }
+        const userPda = this.mainIxs[index].keys[0].pubkey;
+        const tokenXMint = this.mainIxs[index].keys[9].pubkey;
+        const tokenYMint = this.mainIxs[index].keys[10].pubkey;
+        const staTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+        const staTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+        this.mainIxs[index].keys[7].pubkey = staTokenX;
+        this.mainIxs[index].keys[8].pubkey = staTokenY;
+    }
+    /**
+     * 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() {
+        let foundAny = false;
+        this.mainIxs.forEach((mainIx, index) => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            if ((0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2Automation') ||
+                (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2')) {
+                foundAny = true;
+                const userPda = this.mainIxs[index].keys[0].pubkey;
+                const tokenMint = this.mainIxs[index].keys[6].pubkey;
+                const ataToken = (0, functions_1.generateAta)(userPda, tokenMint);
+                this.mainIxs[index].keys[7].pubkey = ataToken;
+            }
+        });
+        if (!foundAny) {
+            console.warn('Warn: Reward instruction not found! This may happen if pool has no rewards');
+        }
+    }
+}
+exports.RemoveLiquidityBuilder = RemoveLiquidityBuilder;
+/**
+ * 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.
+ */
+class RemoveLiquidityPdaBuilder {
+    /**
+     * 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(
+    // readonly createAtaIxs: web3.TransactionInstruction[],
+    mainIxs) {
+        this.mainIxs = mainIxs;
+    }
+    /**
+     * 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() {
+        return [
+            // Step 1: Init ATA prior to withdrawal
+            // ...this.createAtaIxs,
+            // Step 2: Claim fees and/or rewards, remove liquidity, and possibly close position (if set)
+            ...this.mainIxs,
+            // // Step 3: Withdraw tokens to user wallet
+            // this.withdrawMultipleTokenIx,
+            // // Step 4: Close wSOL account (if there's any)
+            // ...this.unwrapWsolIxs,
+        ];
+    }
+    /**
+     * Replaces claim fee token ixs into storage token account
+     */
+    replaceClaimFeeTokenToSTA() {
+        const index = this.mainIxs.findIndex(mainIx => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            return (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, "MeteoraDlmmClaimFee");
+        });
+        if (index === -1) {
+            console.warn(`Warn: claim fee instruction not found! This should not happen if \`shouldClaimAndClose\` is set to true.`);
+            return;
+        }
+        const userPda = this.mainIxs[index].keys[1].pubkey;
+        const tokenXMint = this.mainIxs[index].keys[13].pubkey;
+        const tokenYMint = this.mainIxs[index].keys[14].pubkey;
+        const staTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+        const staTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+        this.mainIxs[index].keys[11].pubkey = staTokenX;
+        this.mainIxs[index].keys[12].pubkey = staTokenY;
+    }
+    /**
+     * 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() {
+        let foundAny = false;
+        this.mainIxs.forEach((mainIx, index) => {
+            const dataWithoutIyfExtensionExecute = mainIx.data.subarray(12);
+            if ((0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2Automation') ||
+                (0, functions_1.sighashMatch)(dataWithoutIyfExtensionExecute, 'MeteoraDlmmClaimReward2')) {
+                foundAny = true;
+                const userPda = this.mainIxs[index].keys[0].pubkey;
+                const tokenMint = this.mainIxs[index].keys[6].pubkey;
+                const staToken = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenMint);
+                this.mainIxs[index].keys[7].pubkey = staToken;
+            }
+        });
+        if (!foundAny) {
+            console.warn('Warn: Reward instruction not found! This may happen if pool has no rewards');
+        }
+    }
+}
+exports.RemoveLiquidityPdaBuilder = RemoveLiquidityPdaBuilder;
+/**
+ * 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.
+ */
+class InitializePositionAndAddLiquidityByStrategyBuilder {
+    /**
+     * 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, depositToPdaIxs, mainIxs, refundDustIxs, unwrapWsolIxs) {
+        this.wrapSolIxs = wrapSolIxs;
+        this.depositToPdaIxs = depositToPdaIxs;
+        this.mainIxs = mainIxs;
+        this.refundDustIxs = refundDustIxs;
+        this.unwrapWsolIxs = unwrapWsolIxs;
+    }
+    /**
+     * 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() {
+        return [
+            // // Step 1: Init wSOL token account for user wallet (if X or Y token is wSOL)
+            ...this.wrapSolIxs,
+            // Step 2: Deposit X and Y token to UserPDA
+            this.depositToPdaIxs,
+            // Step 3: Add liquidity by strategy
+            ...this.mainIxs,
+            // // Step 4: Refund dust to user wallet
+            // this.refundDustIxs,
+            // // Step 5: Close wSOL account (if there's any)
+            ...this.unwrapWsolIxs,
+        ];
+    }
+}
+exports.InitializePositionAndAddLiquidityByStrategyBuilder = InitializePositionAndAddLiquidityByStrategyBuilder;
+/**
+ * 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.
+ */
+class InitializePositionAndAddLiquidityByStrategyBuilderLabeled {
+    /**
+     * 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, depositToPdaIxs, mainIxs, refundDustIxs, unwrapWsolIxs) {
+        this.wrapSolIxs = wrapSolIxs;
+        this.depositToPdaIxs = depositToPdaIxs;
+        this.mainIxs = mainIxs;
+        this.refundDustIxs = refundDustIxs;
+        this.unwrapWsolIxs = unwrapWsolIxs;
+    }
+    /**
+     * 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() {
+        return [
+            // // Step 1: Init wSOL token account for user wallet (if X or Y token is wSOL)
+            ...this.wrapSolIxs,
+            // Step 2: Deposit X and Y token to UserPDA
+            this.depositToPdaIxs,
+            // Step 3: Add liquidity by strategy
+            ...this.mainIxs,
+            // // Step 4: Refund dust to user wallet
+            // this.refundDustIxs,
+            // // Step 5: Close wSOL account (if there's any)
+            ...this.unwrapWsolIxs,
+        ];
+    }
+}
+exports.InitializePositionAndAddLiquidityByStrategyBuilderLabeled = InitializePositionAndAddLiquidityByStrategyBuilderLabeled;
+/**
+ * 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.
+ */
+class InitializePositionAndAddLiquidityByStrategyPdaBuilder {
+    /**
+     * Constructs an instance of the InitializePositionAndAddLiquidityByStrategyBuilder class.
+     *
+     * @param {web3.TransactionInstruction[]} mainIxs - Main instructions for adding liquidity by strategy.
+     */
+    constructor(mainIxs) {
+        this.mainIxs = mainIxs;
+    }
+    /**
+     * 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() {
+        return [
+            // Step 1: Init Position and add liquidity via pda
+            ...this.mainIxs,
+        ];
+    }
+}
+exports.InitializePositionAndAddLiquidityByStrategyPdaBuilder = InitializePositionAndAddLiquidityByStrategyPdaBuilder;