@hawksightco/hawk-sdk 0.0.70 → 1.0.0

package/dist/src/meteora.js

@@ -0,0 +1,615 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitializePositionAndAddLiquidityByStrategyBuilder = exports.RemoveLiquidityBuilder = exports.AddLiquidityByStrategyBuilder = exports.ClaimAllRewardsByPositionBuilder = exports.MeteoraDLMM = void 0;
+const dlmm_1 = __importStar(require("@meteora-ag/dlmm"));
+const errors_1 = require("./errors");
+const addresses_1 = require("./addresses");
+const functions_1 = require("./functions");
+const hawksight_1 = require("./hawksight");
+const anchor_1 = require("./anchor");
+class MeteoraDLMM {
+    constructor(dlmm) {
+        this.dlmm = dlmm;
+        this.pubkey = this.dlmm.pubkey;
+    }
+    static create(connection, poolAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dlmm = yield dlmm_1.default.create(connection, poolAddress);
+            return new MeteoraDLMM(dlmm);
+        });
+    }
+    /**
+     * Meteora DLMM Program
+     *
+     * @param connection
+     */
+    static program(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dlmm = yield dlmm_1.default.create(connection, addresses_1.SOME_METEORA_DLMM_POOL);
+            return dlmm.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})).`);
+        }
+        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.`);
+        }
+        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(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,
+                ]);
+            }
+            // Generate InitializePosition and AddLiquidityByStrategy instruction from Meteora API
+            const txn = yield this.dlmm.initializePositionAndAddLiquidityByStrategy(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: {
+                    AddLiquidityByStrategy: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    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)
+            (0, functions_1.wrapSolIfMintIsWsol)(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 (0, hawksight_1.depositMultipleToken)({
+                payer: userWallet,
+                deposit: [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ],
+            }), 
+            // Step 3: Initialize position and add liquidity by strategy
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.user,
+                authority: userWallet,
+            }), 
+            // Step 4: Withdraw dust to user wallet
+            yield (0, hawksight_1.withdrawMultipleToken)({
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint };
+                }),
+            }), 
+            // Step 5: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints));
+        });
+    }
+    /**
+     * 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(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,
+                ]);
+            }
+            // AddLiquidityByStrategy instruction from Meteora API
+            const txn = yield this.dlmm.addLiquidityByStrategy(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: {
+                    AddLiquidityByStrategy: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [7, 8],
+                    },
+                    AddLiquidityByStrategyOneSide: {
+                        programId: addresses_1.METEORA_DLMM_PROGRAM.toBase58(),
+                        mintIndices: [5],
+                    },
+                },
+            });
+            return new AddLiquidityByStrategyBuilder(
+            // Step 1: Init wSOL token account for user wallet (if X or Y token is wSOL)
+            (0, functions_1.wrapSolIfMintIsWsol)(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 (0, hawksight_1.depositMultipleToken)({
+                payer: userWallet,
+                deposit: [
+                    { mint: this.dlmm.tokenX.publicKey, amount: params.totalXAmount },
+                    { mint: this.dlmm.tokenY.publicKey, amount: params.totalYAmount },
+                ],
+            }), 
+            // Step 3: Add liquidity by strategy
+            yield meteoraToHawksight({
+                ixs,
+                userPda: params.user,
+                authority: userWallet,
+            }), 
+            // Step 4: Withdraw dust to user wallet
+            yield (0, hawksight_1.withdrawMultipleToken)({
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint };
+                }),
+            }), 
+            // 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(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],
+                    },
+                },
+            });
+            return new RemoveLiquidityBuilder(
+            // Step 1: Init ATA prior to withdrawal
+            (0, functions_1.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,
+            }), 
+            // Step 3: Withdraw tokens to user wallet
+            yield (0, hawksight_1.withdrawMultipleToken)({
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint };
+                }),
+            }), 
+            // Step 4: Close wSOL account (if there's any)
+            (0, functions_1.unwrapSolIfMintIsWsol)(userWallet, mints));
+        });
+    }
+    /**
+     * 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(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],
+                    },
+                    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 (0, hawksight_1.withdrawMultipleToken)({
+                payer: userWallet,
+                withdraw: mints.map((mint) => {
+                    return { mint };
+                }),
+            }), 
+            // 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;
+/**
+ * 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,
+        ];
+    }
+}
+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,
+        ];
+    }
+}
+exports.RemoveLiquidityBuilder = RemoveLiquidityBuilder;
+/**
+ * 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;