@hawksightco/hawk-sdk 1.3.169 → 1.3.171

package/dist/src/classes/Transactions.js

@@ -57,6 +57,7 @@ const orca_1 = require("../orca");
 const OrcaPdaGenerator_1 = require("../pdaGenerator/OrcaPdaGenerator");
 const hsToMeteora_1 = require("../hsToMeteora");
 const meteora_1 = require("../meteora");
+const liquidityStrategy_1 = require("../meteora/liquidityStrategy");
 const anchor_1 = require("../anchor");
 const types_2 = require("../types");
 const Logging_1 = require("./Logging");
@@ -232,6 +233,43 @@ class Transactions {
             });
         });
     }
+    /**
+     * Creates meteora instruction that creates new position and deposit
+     *  - Supports larger positions
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraCreatePositionAndDeposit2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            // The logic is routed to meteoraDepositLargerPosition so that front-end no longer need
+            // to change anything in the front-end code.
+            // The only change they need to implement is the maximum number of bins allowed to
+            // initialize a position.
+            //
+            // Recommended bin range is up to 149 bins to ensure stability.
+            return yield this.meteoraDepositLargerPosition({
+                connection,
+                params: {
+                    userWallet: params.userWallet,
+                    lbPair: params.pool,
+                    position: params.position,
+                    lowerBinId: params.binRange.lowerRange,
+                    upperBinId: params.binRange.upperRange,
+                    totalXAmount: params.totalXAmount,
+                    totalYAmount: params.totalYAmount,
+                    distribution: params.distribution,
+                    slippage: params.slippage,
+                    skipInputTokenCheck: params.skipInputTokenCheck,
+                    pdaTokenType: params.pdaTokenType,
+                    initializePosition: true,
+                },
+                fetch: undefined,
+            });
+        });
+    }
     /**
      * Creates meteora instruction that creates new position and deposit.
      *
@@ -426,6 +464,49 @@ class Transactions {
             });
         });
     }
+    /**
+     * Creates meteora instruction that deposits to position.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraDeposit2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            let lbPair, maxBinId, minBinId;
+            if (params.fastGeneration !== undefined) {
+                lbPair = params.fastGeneration.pool;
+                maxBinId = params.fastGeneration.upperBinId;
+                minBinId = params.fastGeneration.lowerBinId;
+            }
+            else {
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+                maxBinId = position.upperBinId;
+                minBinId = position.lowerBinId;
+            }
+            return yield this.meteoraDepositLargerPosition({
+                connection,
+                params: {
+                    userWallet: params.userWallet,
+                    lbPair,
+                    position: params.position,
+                    lowerBinId: minBinId,
+                    upperBinId: maxBinId,
+                    totalXAmount: params.totalXAmount,
+                    totalYAmount: params.totalYAmount,
+                    distribution: params.distribution,
+                    slippage: params.slippage,
+                    skipInputTokenCheck: params.skipInputTokenCheck,
+                    pdaTokenType: params.pdaTokenType,
+                    initializePosition: false,
+                },
+                fetch: undefined,
+            });
+        });
+    }
     /**
      * Creates meteora instruction withdraws from a position.
      *
@@ -586,6 +667,135 @@ class Transactions {
             });
         });
     }
+    /**
+     * Withdraws liquidity from a Meteora DLMM position using simple instructions.
+     *
+     * Unlike meteoraWithdraw which uses Meteora SDK (that generates multiple claimFee ixs
+     * potentially bloating tx size), this method uses direct instructions:
+     * - removeLiquidityByRange2: Withdraw liquidity from the specified bin range
+     * - claimFee2: Single instruction to claim fees
+     * - claimReward2: N instructions (one per active reward)
+     * - closePositionIfEmpty: Closes position if shouldClaimAndClose is true
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params Parameters required for withdrawal
+     * @returns A ResponseWithStatus containing TransactionMetadataResponse.
+     */
+    meteoraWithdrawLargerPosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            // Determine lbPair and bin range
+            let lbPair;
+            let lowerBinId;
+            let upperBinId;
+            if (params.fastGeneration !== undefined) {
+                // Use fastGeneration data
+                lbPair = params.fastGeneration.pool;
+                lowerBinId = params.fastGeneration.lowerBinId;
+                upperBinId = params.fastGeneration.upperBinId;
+            }
+            else {
+                // Fetch position from blockchain
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+                lowerBinId = position.lowerBinId;
+                upperBinId = position.upperBinId;
+            }
+            // Get pool data for token mints and programs
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+            const lbPairState = dlmmPool.dlmm.lbPair;
+            const tokenXMint = lbPairState.tokenXMint;
+            const tokenYMint = lbPairState.tokenYMint;
+            // Get token programs for each mint
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+            const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+            const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+            // Fetch remainingAccountsInfo for Token2022 transfer hooks (if any)
+            const remainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+            const amountBps = params.shouldClaimAndClose
+                ? new bn_js_1.default(10000)
+                : params.amountBps;
+            const mainInstructions = [];
+            // 1. removeLiquidityByRange2 - withdraw liquidity
+            const removeLiquidityIx = yield this.ix.meteoraDlmm.removeLiquidityByRange2({
+                connection,
+                userWallet: params.userWallet,
+                lbPair,
+                position: params.position,
+                tokenXMint,
+                tokenYMint,
+                tokenXProgram,
+                tokenYProgram,
+                fromBinId: lowerBinId,
+                toBinId: upperBinId,
+                bpsToRemove: amountBps.toNumber(),
+                pdaTokenType: params.pdaTokenType,
+                remainingAccountsInfo,
+            });
+            mainInstructions.push(removeLiquidityIx);
+            // 2. claimFee2 - single instruction to claim fees
+            const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2(connection, {
+                userWallet: params.userWallet,
+                lbPair,
+                position: params.position,
+                tokenMintX: tokenXMint,
+                tokenMintY: tokenYMint,
+                tokenProgramX: tokenXProgram,
+                tokenProgramY: tokenYProgram,
+                lowerBinId,
+                upperBinId,
+            });
+            mainInstructions.push(claimFeeIx);
+            // 3. claimReward2 - N instructions (one per active reward)
+            // Fetch lbPair account to get reward infos
+            const lbPairInfo = yield program.account.lbPair.fetch(lbPair);
+            for (let rewardIndex = 0; rewardIndex < 2; rewardIndex++) {
+                const rewardInfo = lbPairInfo.rewardInfos[rewardIndex];
+                // Skip if reward is not initialized (mint is default/zero pubkey)
+                if (!rewardInfo || rewardInfo.mint.equals(web3.PublicKey.default)) {
+                    continue;
+                }
+                const claimRewardIx = yield this.ix.meteoraDlmm.claimReward2(connection, {
+                    userWallet: params.userWallet,
+                    lbPair,
+                    position: params.position,
+                    rewardIndex,
+                    rewardMint: rewardInfo.mint,
+                    rewardVault: rewardInfo.vault,
+                    tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                    lowerBinId,
+                    upperBinId,
+                });
+                mainInstructions.push(claimRewardIx);
+            }
+            // 4. closePositionIfEmpty - only when shouldClaimAndClose is true
+            if (params.shouldClaimAndClose) {
+                const closePositionIx = yield this.ix.meteoraDlmm.closePositionIfEmpty({
+                    connection,
+                    userWallet: params.userWallet,
+                    position: params.position,
+                });
+                mainInstructions.push(closePositionIx);
+            }
+            // Build description
+            let description;
+            if (params.shouldClaimAndClose) {
+                description = 'Full position withdrawal with claim and close from Meteora DLMM (larger position)';
+            }
+            else if (amountBps.eq(new bn_js_1.default(10000))) {
+                description = 'Full position withdrawal without close from Meteora DLMM (larger position)';
+            }
+            else {
+                description = 'Partial position withdrawal from Meteora DLMM (larger position)';
+            }
+            return (0, functions_1.createTransactionMeta)({
+                payer: params.userWallet,
+                description,
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
     /**
      * Creates meteora instruction that claims fees and rewards.
      *
@@ -1603,6 +1813,355 @@ class Transactions {
         }
         throw new Error(`Unexpected error: Cannot find "RemoveLiquidityByRange" or "RemoveLiquidityByRange2" instruction from instructions`);
     }
+    /**
+     * Creates a large position with more than 69 bins
+     *   - Known limitation: Can create a position with 1344 bins in a single transaction
+     *
+     * @param connection - Solana connection
+     * @param params - Parameters containing userWallet, lbPair, position, lowerBinId, upperBinId
+     * @returns Array of TransactionInstructions for initializing and extending the position
+     */
+    meteoraInitializeLargePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const MAX_INIT_WIDTH = 70; // Maximum bins for initialize position
+            const MAX_EXTEND_LENGTH = 91; // Maximum bins per increasePositionLength call
+            const { userWallet, lbPair, position, lowerBinId, upperBinId } = params;
+            // Calculate total bins needed
+            const totalBins = upperBinId - lowerBinId + 1;
+            // Validate bin count (max 1344 supported by Meteora)
+            if (totalBins > 1344) {
+                throw new Error(`Position size ${totalBins} bins exceeds maximum of 1344 bins`);
+            }
+            const instructions = [];
+            // Step 1: Create initialize position (from lowerBinId with max 70 bins)
+            const initWidth = Math.min(totalBins, MAX_INIT_WIDTH);
+            const initializePositionIx = yield this.ix.meteoraDlmm.initializePosition({
+                connection,
+                userWallet,
+                lbPair,
+                position,
+                lowerBinId,
+                width: initWidth,
+            });
+            instructions.push(initializePositionIx);
+            // Step 2: Extend to the right in chunks of 91 bins if needed
+            // After init, we have bins from lowerBinId to lowerBinId + initWidth - 1
+            // We need to extend up to upperBinId
+            let currentUpperBinId = lowerBinId + initWidth - 1;
+            while (currentUpperBinId < upperBinId) {
+                // Calculate how many bins to add (max 91)
+                const binsRemaining = upperBinId - currentUpperBinId;
+                const binsToAdd = Math.min(binsRemaining, MAX_EXTEND_LENGTH);
+                const extendIx = yield this.ix.meteoraDlmm.increasePositionLength({
+                    connection,
+                    userWallet,
+                    lbPair,
+                    position,
+                    lengthToAdd: binsToAdd,
+                    side: types_1.MeteoraPositionSide.Upper, // Extend to the right (upper side)
+                });
+                instructions.push(extendIx);
+                currentUpperBinId += binsToAdd;
+            }
+            return (0, functions_1.createTransactionMeta)({
+                payer: params.userWallet,
+                description: 'Initialize large Meteora DLMM Position',
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions: instructions,
+            });
+        });
+    }
+    /**
+     * Deposit liquidity to a large Meteora DLMM position using rebalanceLiquidity.
+     * Splits the deposit into multiple transactions (one per chunk of bins)
+     * to stay within Solana's account limit per transaction.
+     *
+     * @param connection - Solana connection
+     * @param params - MeteoraDepositToLargePosition parameters
+     * @returns Array of TransactionMetadataResponse, one per chunk
+     */
+    meteoraDepositToLargePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const MAX_BINS_PER_TX = 149;
+            const { userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, lowerBinId, upperBinId, totalXAmount, totalYAmount, strategyType = liquidityStrategy_1.StrategyType.SPOT, favorXInActiveId = false, pdaTokenType, } = params;
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+            const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
+            const binStep = new bn_js_1.default(dlmmPool.dlmm.lbPair.binStep);
+            console.log(`Active ID: ${activeId}, Bin Step: ${binStep.toString()}`);
+            // Calculate delta IDs relative to active bin for entire position
+            const minDeltaId = new bn_js_1.default(lowerBinId - activeId);
+            const maxDeltaId = new bn_js_1.default(upperBinId - activeId);
+            // Build strategy parameters ONCE for entire position
+            const strategyParams = (0, liquidityStrategy_1.buildStrategyParameters)(strategyType, totalXAmount, totalYAmount, minDeltaId, maxDeltaId, binStep, new bn_js_1.default(activeId), favorXInActiveId);
+            console.log(`Strategy params - x0: ${strategyParams.x0.toString()}, y0: ${strategyParams.y0.toString()}, deltaX: ${strategyParams.deltaX.toString()}, deltaY: ${strategyParams.deltaY.toString()}`);
+            // Chunk the deposit using the same strategy parameters
+            const chunks = (0, liquidityStrategy_1.chunkDepositParameters)(strategyParams, minDeltaId, maxDeltaId, new bn_js_1.default(activeId), binStep, MAX_BINS_PER_TX, favorXInActiveId);
+            console.log(`Total chunks: ${chunks.length}`);
+            const transactions = [];
+            // === TRANSACTION 1: Create LTA accounts and deposit tokens ===
+            const depositInstructions = [];
+            // Build deposit array for tokens with non-zero amounts
+            const deposits = [];
+            if (totalXAmount.gt(new bn_js_1.default(0))) {
+                deposits.push({ mint: tokenXMint, amount: totalXAmount });
+            }
+            if (totalYAmount.gt(new bn_js_1.default(0))) {
+                deposits.push({ mint: tokenYMint, amount: totalYAmount });
+            }
+            // Deposit tokens to ATA accounts
+            if (deposits.length > 0) {
+                depositInstructions.push(yield this.ix.iyfMain.depositMultipleTokenV2({
+                    connection,
+                    payer: userWallet,
+                    deposit: deposits,
+                    pdaTokenType,
+                }));
+            }
+            let depositIncluded = false;
+            // === TRANSACTIONS 2+: Chunked liquidity deposits ===
+            for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+                const chunk = chunks[chunkIndex];
+                // Convert strategy parameters to on-chain format with bitFlag for negative values
+                const onChainParams = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunk.params.x0, chunk.params.y0, chunk.params.deltaX, chunk.params.deltaY);
+                console.log(`Creating transaction ${chunkIndex + 2}/${chunks.length + 1} for bins ${chunk.lowerBinId} to ${chunk.upperBinId} -- deltaIds: ${chunk.minDeltaId.toString()} to ${chunk.maxDeltaId.toString()}, X: ${chunk.maxAmountX.toString()}, Y: ${chunk.maxAmountY.toString()}, bitFlag: ${onChainParams.bitFlag}`);
+                const instructions = [];
+                // Add deposit instruction at the beginning of the first transaction
+                if (!depositIncluded) {
+                    depositIncluded = true;
+                    instructions.push(...depositInstructions);
+                }
+                // Add initialize bin arrays instruction
+                const initBinArraysIx = yield this.ix.meteoraDlmm.meteoraDlmmInitializeBinArray({
+                    connection,
+                    userWallet,
+                    lbPair,
+                    lowerBinId: chunk.lowerBinId,
+                    upperBinId: chunk.upperBinId,
+                });
+                instructions.push(initBinArraysIx);
+                // Add liquidity via rebalanceLiquidity
+                // Note: Always use TokenType.LTA since we deposit to LTA in the first transaction
+                const depositIx = yield this.ix.meteoraDlmm.rebalanceLiquidity({
+                    connection,
+                    userWallet,
+                    position,
+                    lbPair,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
+                    activeId,
+                    pdaTokenType,
+                    // RebalanceLiquidityParams
+                    maxActiveBinSlippage: 300,
+                    shouldClaimFee: false,
+                    shouldClaimReward: false,
+                    minWithdrawXAmount: new bn_js_1.default(0),
+                    maxDepositXAmount: chunk.maxAmountX,
+                    minWithdrawYAmount: new bn_js_1.default(0),
+                    maxDepositYAmount: chunk.maxAmountY,
+                    removeLiquidityParams: [], // No removal
+                    addLiquidityParams: [{
+                            minDeltaId: chunk.minDeltaId.toNumber(),
+                            maxDeltaId: chunk.maxDeltaId.toNumber(),
+                            x0: onChainParams.x0,
+                            y0: onChainParams.y0,
+                            deltaX: onChainParams.deltaX,
+                            deltaY: onChainParams.deltaY,
+                            bitFlag: onChainParams.bitFlag,
+                            favorXInActiveId,
+                        }],
+                });
+                instructions.push(depositIx);
+                // Create transaction for this chunk
+                const txMeta = yield (0, functions_1.createTransactionMeta)({
+                    payer: userWallet,
+                    description: `Deposit to large Meteora DLMM Position (chunk ${chunkIndex + 1}/${chunks.length})`,
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: instructions,
+                });
+                transactions.push(txMeta);
+            }
+            return transactions;
+        });
+    }
+    /**
+     * Deposit liquidity to a Meteora DLMM position (up to 128 bins) with optional position initialization.
+     *
+     * This method combines:
+     * - Initialize bin arrays (meteoraDlmmInitializeBinArray) - idempotent
+     * - Optionally initialize position (if initializePosition is true):
+     *   - For <= 70 bins: uses initializePositionAndAddLiquidityByStrategy
+     *   - For > 70 bins: uses initializePosition + increasePositionLength + addLiquidityByStrategy
+     * - Add liquidity using addLiquidityByStrategy
+     *
+     * Designed for automation compatibility - all operations in a single transaction.
+     * Note: Max 128 bins supported due to CU constraints with ATA-based deposits.
+     *
+     * @param connection - Solana connection
+     * @param params - MeteoraDepositLargerPosition parameters
+     * @returns Single TransactionMetadataResponse
+     */
+    meteoraDepositLargerPosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const MAX_INIT_WIDTH = 70; // Maximum bins for initialize position (hard limit)
+            const MAX_EXTEND_LENGTH = 91; // Maximum bins per increasePositionLength call (hard limit)
+            // const MAX_TOTAL_BINS = 128;   // Maximum total bins supported in single tx (CU limitation with ATA deposit)
+            const { userWallet, lbPair, position, lowerBinId, upperBinId, totalXAmount, totalYAmount, distribution, slippage, skipInputTokenCheck, pdaTokenType, initializePosition = true, } = params;
+            // // Validate bin count
+            const totalBins = upperBinId - lowerBinId + 1;
+            // // NOTE: Max hard total bins allowed to initialize a position is 161 bins.
+            // // But the recommended is only up to 149 bins to ensure stability.
+            // const MAX_TOTAL_BINS = 161;
+            // if (totalBins > MAX_TOTAL_BINS) {
+            //   throw new Error(`Position size ${totalBins} bins exceeds maximum of ${MAX_TOTAL_BINS} bins for single transaction`);
+            // }
+            // Get pool data
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const instructions = [];
+            // Generate instructions that initializes bin arrays (but doesn't mean we will execute them)
+            const initBinArraysIxs = yield this.ix.meteoraDlmm.meteoraDlmmInitializeBinArrayDefault({
+                connection,
+                userWallet,
+                lbPair,
+                lowerBinId,
+                upperBinId,
+            });
+            // Get all bin arrays from given range
+            const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, lowerBinId, upperBinId);
+            // Check if these bin array accounts are already initialized (get multiple account info)
+            const binArrayAccounts = yield (0, functions_1.getBatchedMultipleAccountsInfo)(connection, binArrays);
+            // Loop through uninitialized bin arrays. We only inject instruction of uninitialized bin arrays.
+            for (let i = 0; i < binArrayAccounts.length; i++) {
+                if (binArrayAccounts[i] === null) {
+                    instructions.push(initBinArraysIxs[i]);
+                }
+            }
+            // Step 2: Either initialize position and add liquidity, or just add liquidity
+            if (initializePosition) {
+                if (totalBins <= MAX_INIT_WIDTH) {
+                    // Simple case: <= 70 bins - use initializePositionAndAddLiquidityByStrategy
+                    const initPositionAndAddLiquidityIxs = (yield dlmmPool.initializePositionAndAddLiquidityByStrategy(connection, userWallet, userWallet, {
+                        positionPubKey: position,
+                        totalXAmount,
+                        totalYAmount,
+                        strategy: {
+                            minBinId: lowerBinId,
+                            maxBinId: upperBinId,
+                            strategyType: types_3.StrategyTypeMap[distribution],
+                        },
+                        user: userPda,
+                        slippage,
+                        skipInputTokenCheck,
+                        opt: {
+                            pdaTokenType,
+                        },
+                    }, hsToMeteora_1.meteoraToHawksight)).default();
+                    // Filter out initializeBinArray instructions since we already initialized them above
+                    // with the correct funder (user wallet instead of user PDA)
+                    const initializeBinArraySighash = (0, functions_1.sighash)('initialize_bin_array');
+                    const filteredIxs = initPositionAndAddLiquidityIxs.filter(ix => {
+                        if (!ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM))
+                            return true;
+                        const ixSighash = ix.data.subarray(0, 8);
+                        return !Buffer.from(ixSighash).equals(Buffer.from(initializeBinArraySighash));
+                    });
+                    instructions.push(...filteredIxs);
+                }
+                else {
+                    // Complex case: > 70 bins - need to initialize position + extend + add liquidity separately
+                    // Step 2a: Initialize position with first 70 bins
+                    const initWidth = MAX_INIT_WIDTH;
+                    const initializePositionIx = yield this.ix.meteoraDlmm.initializePosition({
+                        connection,
+                        userWallet,
+                        lbPair,
+                        position,
+                        lowerBinId,
+                        width: initWidth,
+                    });
+                    instructions.push(initializePositionIx);
+                    // Step 2b: Extend position to cover all bins
+                    let currentUpperBinId = lowerBinId + initWidth - 1;
+                    while (currentUpperBinId < upperBinId) {
+                        const binsRemaining = upperBinId - currentUpperBinId;
+                        const binsToAdd = Math.min(binsRemaining, MAX_EXTEND_LENGTH);
+                        const extendIx = yield this.ix.meteoraDlmm.increasePositionLength({
+                            connection,
+                            userWallet,
+                            lbPair,
+                            position,
+                            lengthToAdd: binsToAdd,
+                            side: types_1.MeteoraPositionSide.Upper,
+                        });
+                        instructions.push(extendIx);
+                        currentUpperBinId += binsToAdd;
+                    }
+                    // Step 2c: Add liquidity to the full position
+                    const addLiquidityIxs = (yield dlmmPool.addLiquidityByStrategy(connection, userWallet, userWallet, {
+                        positionPubKey: position,
+                        totalXAmount,
+                        totalYAmount,
+                        strategy: {
+                            minBinId: lowerBinId,
+                            maxBinId: upperBinId,
+                            strategyType: types_3.StrategyTypeMap[distribution],
+                        },
+                        user: userPda,
+                        slippage,
+                        skipInputTokenCheck,
+                        pdaTokenType,
+                    }, hsToMeteora_1.meteoraToHawksight)).default();
+                    // Filter out initializeBinArray instructions since we already initialized them above
+                    // with the correct funder (user wallet instead of user PDA)
+                    const initializeBinArraySighash = (0, functions_1.sighash)('initialize_bin_array');
+                    const filteredIxs = addLiquidityIxs.filter(ix => {
+                        if (!ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM))
+                            return true;
+                        const ixSighash = ix.data.subarray(0, 8);
+                        return !Buffer.from(ixSighash).equals(Buffer.from(initializeBinArraySighash));
+                    });
+                    instructions.push(...filteredIxs);
+                }
+            }
+            else {
+                // Just add liquidity to existing position
+                const addLiquidityIxs = (yield dlmmPool.addLiquidityByStrategy(connection, userWallet, userWallet, {
+                    positionPubKey: position,
+                    totalXAmount,
+                    totalYAmount,
+                    strategy: {
+                        minBinId: lowerBinId,
+                        maxBinId: upperBinId,
+                        strategyType: types_3.StrategyTypeMap[distribution],
+                    },
+                    user: userPda,
+                    slippage,
+                    skipInputTokenCheck,
+                    pdaTokenType,
+                }, hsToMeteora_1.meteoraToHawksight)).default();
+                // Filter out initializeBinArray instructions since we already initialized them above
+                // with the correct funder (user wallet instead of user PDA)
+                const initializeBinArraySighash = (0, functions_1.sighash)('initialize_bin_array');
+                const filteredIxs = addLiquidityIxs.filter(ix => {
+                    if (!ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM))
+                        return true;
+                    const ixSighash = ix.data.subarray(0, 8);
+                    return !Buffer.from(ixSighash).equals(Buffer.from(initializeBinArraySighash));
+                });
+                instructions.push(...filteredIxs);
+            }
+            return (0, functions_1.createTransactionMeta)({
+                payer: userWallet,
+                description: initializePosition
+                    ? 'Initialize Meteora DLMM Position and deposit liquidity'
+                    : 'Deposit liquidity to Meteora DLMM Position',
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions: instructions,
+            });
+        });
+    }
     /**
      * Creates orca instruction that opens new position
      *
@@ -1636,6 +2195,7 @@ class Transactions {
                 systemProgram: web3.SystemProgram.programId,
             })
                 .instruction();
+            // @ts-ignore
             const orcaIx = yield anchor_1.Anchor.instance()
                 .iyfMain.methods.iyfExtensionExecute(extensionIx.data)
                 .accounts({