@hawksightco/hawk-sdk 1.3.200 → 1.3.202

package/dist/src/classes/Transactions.js

@@ -200,6 +200,8 @@ class Transactions {
     /**
      * Creates meteora instruction that creates new position and deposit.
      *
+     * @deprecated Use meteoraCreatePositionAndDepositToLargePosition instead.
+     *
      * @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
@@ -237,6 +239,8 @@ class Transactions {
      * Creates meteora instruction that creates new position and deposit
      *  - Supports larger positions
      *
+     * @deprecated Use meteoraCreatePositionAndDepositToLargePosition instead.
+     *
      * @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
@@ -420,6 +424,8 @@ class Transactions {
     /**
      * Creates meteora instruction that deposits to position.
      *
+     * @deprecated Use meteoraDepositToLargePosition instead
+     *
      * @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
@@ -467,6 +473,8 @@ class Transactions {
     /**
      * Creates meteora instruction that deposits to position.
      *
+     * @deprecated Use meteoraDepositToLargePosition instead
+     *
      * @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
@@ -510,6 +518,8 @@ class Transactions {
     /**
      * Creates meteora instruction withdraws from a position.
      *
+     * @deprecated Use meteoraWithdrawLargePosition instead
+     *
      * @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
@@ -670,6 +680,8 @@ class Transactions {
     /**
      * Withdraws liquidity from a Meteora DLMM position using simple instructions.
      *
+     * @deprecated Use meteoraWithdrawLargePosition instead
+     *
      * 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
@@ -682,118 +694,219 @@ class Transactions {
      * @returns A ResponseWithStatus containing TransactionMetadataResponse.
      */
     meteoraWithdrawLargerPosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, fetch, }) {
+            const mainInstructions = yield this._meteoraWithdrawLargerPosition({ connection, params, fetch });
+            // Build description
+            let description;
+            if (params.shouldClaimAndClose) {
+                description = 'Full position withdrawal with claim and close from Meteora DLMM (larger position)';
+            }
+            else if (params.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,
+            });
+        });
+    }
+    /**
+     * Withdraw liquidity from a large Meteora DLMM position (up to 1400 bins).
+     *
+     * - For ≤149 bins: delegates to meteoraWithdrawLargerPosition (single tx)
+     * - For ≥150 bins: resolves pool data once, chunks into ≤149-bin ranges,
+     *   calls _buildWithdrawInstructions per chunk. Only the last chunk sets
+     *   shouldClaimAndClose (if requested).
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params MeteoraWithdrawLargerPosition parameters
+     * @returns Array of TransactionMetadataResponse, one per chunk
+     */
+    meteoraWithdrawLargePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            // Determine lbPair and bin range
+            let lbPair;
+            let lowerBinId;
+            let upperBinId;
+            if (params.fastGeneration !== undefined) {
+                lbPair = params.fastGeneration.pool;
+                lowerBinId = params.fastGeneration.lowerBinId;
+                upperBinId = params.fastGeneration.upperBinId;
+            }
+            else {
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+                lowerBinId = position.lowerBinId;
+                upperBinId = position.upperBinId;
+            }
+            const totalBins = upperBinId - lowerBinId + 1;
+            // ≤149 bins: single-tx path
+            if (totalBins <= 149) {
+                const result = yield this.meteoraWithdrawLargerPosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return [result];
+            }
+            // ≥150 bins: multi-tx chunked withdraw
+            const resolved = yield this._resolveWithdrawPoolData({ connection, lbPair });
+            const amountBps = params.shouldClaimAndClose ? new bn_js_1.default(10000) : params.amountBps;
+            // Chunk into ≤149-bin ranges
+            const CHUNK_SIZE = 149;
+            const chunks = [];
+            for (let binStart = lowerBinId; binStart <= upperBinId; binStart += CHUNK_SIZE) {
+                const chunkUpper = Math.min(binStart + CHUNK_SIZE - 1, upperBinId);
+                chunks.push({ chunkLower: binStart, chunkUpper });
+            }
+            const transactions = [];
+            for (let i = 0; i < chunks.length; i++) {
+                const { chunkLower, chunkUpper } = chunks[i];
+                const isLastChunk = i === chunks.length - 1;
+                const instructions = yield this._buildWithdrawInstructions(Object.assign({ connection, userWallet: params.userWallet, position: params.position, lbPair, lowerBinId: chunkLower, upperBinId: chunkUpper, amountBps, shouldClaimAndClose: isLastChunk && params.shouldClaimAndClose, pdaTokenType: params.pdaTokenType }, resolved));
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: `Withdraw from large Meteora DLMM Position (chunk ${i + 1}/${chunks.length})`,
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: instructions,
+                }));
+            }
+            return 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 program = yield meteora_1.MeteoraDLMM.program(connection);
                 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
+            // Resolve pool data
+            const resolved = yield this._resolveWithdrawPoolData({ connection, lbPair });
+            return this._buildWithdrawInstructions(Object.assign({ connection, userWallet: params.userWallet, position: params.position, lbPair,
+                lowerBinId,
+                upperBinId, amountBps: params.shouldClaimAndClose ? new bn_js_1.default(10000) : params.amountBps, shouldClaimAndClose: params.shouldClaimAndClose, pdaTokenType: params.pdaTokenType }, resolved));
+        });
+    }
+    /**
+     * Resolves pool data needed for withdraw instructions.
+     * Call once, then pass the result to _buildWithdrawInstructions for each chunk.
+     */
+    _resolveWithdrawPoolData(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, lbPair }) {
+            // Create DLMM pool first — this also initializes MeteoraDLMM._program
+            // so we don't need a separate MeteoraDLMM.program() call (which fetches a dummy pool).
             const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+            const program = dlmmPool.dlmm.program;
             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 lbPairInfo = yield program.account.lbPair.fetch(lbPair);
+            return { tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, remainingAccountsInfo, lbPairInfo };
+        });
+    }
+    /**
+     * Builds withdraw instructions for a single bin range chunk.
+     * Requires pre-resolved pool data (from _resolveWithdrawPoolData).
+     */
+    _buildWithdrawInstructions(params) {
+        return __awaiter(this, void 0, void 0, function* () {
             const mainInstructions = [];
             // 1. removeLiquidityByRange2 - withdraw liquidity
             const removeLiquidityIx = yield this.ix.meteoraDlmm.removeLiquidityByRange2({
-                connection,
+                connection: params.connection,
                 userWallet: params.userWallet,
-                lbPair,
+                lbPair: params.lbPair,
                 position: params.position,
-                tokenXMint,
-                tokenYMint,
-                tokenXProgram,
-                tokenYProgram,
-                fromBinId: lowerBinId,
-                toBinId: upperBinId,
-                bpsToRemove: amountBps.toNumber(),
+                tokenXMint: params.tokenXMint,
+                tokenYMint: params.tokenYMint,
+                tokenXProgram: params.tokenXProgram,
+                tokenYProgram: params.tokenYProgram,
+                fromBinId: params.lowerBinId,
+                toBinId: params.upperBinId,
+                bpsToRemove: params.amountBps.toNumber(),
                 pdaTokenType: params.pdaTokenType,
-                remainingAccountsInfo,
+                remainingAccountsInfo: params.remainingAccountsInfo,
             });
             mainInstructions.push(removeLiquidityIx);
             // 2. claimFee2 - single instruction to claim fees
-            const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2(connection, {
+            const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2(params.connection, {
                 userWallet: params.userWallet,
-                lbPair,
+                lbPair: params.lbPair,
                 position: params.position,
-                tokenMintX: tokenXMint,
-                tokenMintY: tokenYMint,
-                tokenProgramX: tokenXProgram,
-                tokenProgramY: tokenYProgram,
-                lowerBinId,
-                upperBinId,
+                tokenMintX: params.tokenXMint,
+                tokenMintY: params.tokenYMint,
+                tokenProgramX: params.tokenXProgram,
+                tokenProgramY: params.tokenYProgram,
+                lowerBinId: params.lowerBinId,
+                upperBinId: params.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];
+                const rewardInfo = params.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, {
+                const claimRewardIx = yield this.ix.meteoraDlmm.claimReward2(params.connection, {
                     userWallet: params.userWallet,
-                    lbPair,
+                    lbPair: params.lbPair,
                     position: params.position,
                     rewardIndex,
                     rewardMint: rewardInfo.mint,
                     rewardVault: rewardInfo.vault,
                     tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
-                    lowerBinId,
-                    upperBinId,
+                    lowerBinId: params.lowerBinId,
+                    upperBinId: params.upperBinId,
                 });
                 mainInstructions.push(claimRewardIx);
             }
             // 4. closePositionIfEmpty - only when shouldClaimAndClose is true
             if (params.shouldClaimAndClose) {
                 const closePositionIx = yield this.ix.meteoraDlmm.closePositionIfEmpty({
-                    connection,
+                    connection: params.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,
-            });
+            return mainInstructions;
         });
     }
     /**
@@ -827,6 +940,99 @@ class Transactions {
             return txMeta;
         });
     }
+    /**
+     * Claim fees and rewards from a large Meteora DLMM position (up to 1400 bins).
+     *
+     * For ≤149 bins, delegates to the single-TX meteoraClaim.
+     * For ≥150 bins, chunks the bin range into ≤149-bin pieces and builds
+     * claimFee2 + claimReward2 per chunk, returning multiple TXs.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params MeteoraClaim parameters (userWallet, position, fastGeneration)
+     * @returns Array of TransactionMetadataResponse, one per chunk
+     */
+    meteoraClaimLargePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            // Determine lbPair and bin range
+            let lbPair;
+            let lowerBinId;
+            let upperBinId;
+            if (params.fastGeneration !== undefined) {
+                lbPair = params.fastGeneration.pool;
+                // fastGeneration for MeteoraClaim doesn't include bin IDs, so we must fetch
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const position = yield program.account.positionV2.fetch(params.position);
+                lowerBinId = position.lowerBinId;
+                upperBinId = position.upperBinId;
+            }
+            else {
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+                lowerBinId = position.lowerBinId;
+                upperBinId = position.upperBinId;
+            }
+            const totalBins = upperBinId - lowerBinId + 1;
+            // ≤149 bins: single-tx path
+            if (totalBins <= 149) {
+                const result = yield this.meteoraClaim({ connection, params, fetch: undefined });
+                return [result];
+            }
+            // ≥150 bins: multi-tx chunked claim
+            const resolved = yield this._resolveWithdrawPoolData({ connection, lbPair });
+            // Chunk into ≤149-bin ranges
+            const CHUNK_SIZE = 149;
+            const chunks = [];
+            for (let binStart = lowerBinId; binStart <= upperBinId; binStart += CHUNK_SIZE) {
+                const chunkUpper = Math.min(binStart + CHUNK_SIZE - 1, upperBinId);
+                chunks.push({ chunkLower: binStart, chunkUpper });
+            }
+            const transactions = [];
+            for (let i = 0; i < chunks.length; i++) {
+                const { chunkLower, chunkUpper } = chunks[i];
+                const instructions = [];
+                // claimFee2 for this chunk
+                const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2(connection, {
+                    userWallet: params.userWallet,
+                    lbPair,
+                    position: params.position,
+                    tokenMintX: resolved.tokenXMint,
+                    tokenMintY: resolved.tokenYMint,
+                    tokenProgramX: resolved.tokenXProgram,
+                    tokenProgramY: resolved.tokenYProgram,
+                    lowerBinId: chunkLower,
+                    upperBinId: chunkUpper,
+                });
+                instructions.push(claimFeeIx);
+                // claimReward2 per chunk for each active reward
+                for (let rewardIndex = 0; rewardIndex < 2; rewardIndex++) {
+                    const rewardInfo = resolved.lbPairInfo.rewardInfos[rewardIndex];
+                    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: chunkLower,
+                        upperBinId: chunkUpper,
+                    });
+                    instructions.push(claimRewardIx);
+                }
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: `Claim from large Meteora DLMM Position (chunk ${i + 1}/${chunks.length})`,
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: instructions,
+                }));
+            }
+            return transactions;
+        });
+    }
     /**
      * Claim all meteora fees and rewards by list of pools owned by given user
      *
@@ -982,6 +1188,9 @@ class Transactions {
             });
         });
     }
+    /**
+     * @deprecated Use compoundFromLargePositionAutomationIx instead
+     */
     compoundAutomationIx(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             var _b;
@@ -1138,119 +1347,363 @@ class Transactions {
             }
         });
     }
+    /**
+     * @deprecated Use claimFromLargePositionAutomationIx instead
+     *
+     * @param param0
+     * @returns
+     */
     claimAutomationIx(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
-            try {
-                console.log('=== CLAIM AUTOMATION IX START ===');
-                console.log('Params:', {
-                    userWallet: params.userWallet.toString(),
-                    position: params.position.toString(),
-                });
-                const program = yield meteora_1.MeteoraDLMM.program(connection);
-                console.log('Program fetched successfully');
-                const position = yield program.account.positionV2.fetch(params.position);
-                console.log('Position fetched:', {
-                    lbPair: position.lbPair.toString(),
-                    owner: position.owner.toString(),
-                    lowerBinId: position.lowerBinId.toString(),
-                    upperBinId: position.upperBinId.toString(),
-                });
-                const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, position.lbPair, this.ix);
-                console.log('DLMM pool created successfully');
-                const userPda = (0, functions_1.generateUserPda)(params.userWallet);
-                console.log('User PDA generated:', userPda.toString());
-                const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
-                console.log('User positions fetched, count:', userPositions.length);
-                const userPosition = userPositions.find(userPosition => userPosition.publicKey.equals(params.position));
-                if (userPosition === undefined) {
-                    throw new Error(`Position: ${params.position} does not exist.`);
-                }
-                console.log('User position found');
-                // Claim fee and claim reward ixs
-                console.log('Creating MeteoraFunctions...');
-                const fn = new meteora_1.MeteoraFunctions(this.ix);
-                console.log('Calling claimAllRewardsByPosition...');
-                const claimBuilder = yield fn.claimAllRewardsByPosition(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
-                    owner: userPda,
-                    position: params.position,
-                    lbPair: position.lbPair,
-                    pdaTokenType: types_1.TokenType.STA,
-                }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
-                console.log('Claim builder created successfully');
-                const mainInstructions = [
-                    ...claimBuilder.mainIxs,
-                ];
-                console.log('=== CLAIM AUTOMATION IX SUCCESS ===');
-                try {
-                    console.log('Creating transaction metadata...');
-                    const result = (0, functions_1.createTransactionMeta)({
-                        payer: params.userWallet,
-                        description: 'Automation IX: Meteora Auto-claim instructions (claim fee, reward)',
-                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                        mainInstructions,
-                    });
-                    console.log('Transaction metadata created successfully');
-                    return result;
-                }
-                catch (metadataError) {
-                    console.error('=== TRANSACTION METADATA ERROR ===');
-                    console.error('Error creating transaction metadata:', metadataError);
-                    console.error('Main instructions count:', mainInstructions.length);
-                    console.error('Main instructions:', mainInstructions.map(ix => ({
-                        programId: ix.programId.toString(),
-                        keysCount: ix.keys.length,
-                        dataLength: ix.data.length,
-                    })));
-                    console.error('=== END METADATA ERROR LOG ===');
-                    throw metadataError;
-                }
-            }
-            catch (error) {
-                console.error('=== CLAIM AUTOMATION IX ERROR ===');
-                console.error('Error type:', error instanceof Error ? error.constructor.name : typeof error);
-                console.error('Error message:', error instanceof Error ? error.message : String(error));
-                console.error('Error stack:', error instanceof Error ? error.stack : 'No stack trace');
-                console.error('Full error object:', error);
-                console.error('=== END CLAIM AUTOMATION ERROR LOG ===');
-                throw error;
-            }
-        });
-    }
-    rebalanceAutomationIx(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             const program = yield meteora_1.MeteoraDLMM.program(connection);
-            const position = yield program.account.positionV2.fetch(params.currentPosition);
+            const position = yield program.account.positionV2.fetch(params.position);
+            if (!position || !position.lbPair) {
+                throw new Error(`Invalid position data: ${params.position}`);
+            }
             const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, position.lbPair, this.ix);
             const userPda = (0, functions_1.generateUserPda)(params.userWallet);
-            // Step 1: Claim all fees/rewards, remove all liquidity and close current position
             const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
-            const userPosition = userPositions.find(userPosition => userPosition.publicKey.equals(params.currentPosition));
+            const userPosition = userPositions.find(userPosition => userPosition.publicKey.equals(params.position));
             if (userPosition === undefined) {
-                throw new Error(`Position: ${params.currentPosition} does not exist.`);
+                throw new Error(`Position: ${params.position} does not exist.`);
             }
-            const binIdsToRemove = userPosition.positionData.positionBinData.map(bin => bin.binId);
-            const removeLiquidityBuilder = yield dlmmPool.removeLiquidity(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
-                user: userPda,
-                position: params.currentPosition,
-                fromBinId: position.lowerBinId,
-                toBinId: position.upperBinId,
-                bps: new bn_js_1.default(10000),
-                shouldClaimAndClose: true,
+            // Claim fee and claim reward ixs
+            const fn = new meteora_1.MeteoraFunctions(this.ix);
+            const claimBuilder = yield fn.claimAllRewardsByPosition(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
+                owner: userPda,
+                position: params.position,
+                lbPair: position.lbPair,
+                pdaTokenType: types_1.TokenType.STA,
             }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
-            if (!!params.useAta) {
-                removeLiquidityBuilder.replaceClaimFeeTokenToATA();
-                removeLiquidityBuilder.replaceClaimRewardToATA();
-            }
-            else {
-                removeLiquidityBuilder.replaceClaimFeeTokenToSTA();
-                removeLiquidityBuilder.replaceClaimRewardToSTA();
-            }
-            // Re-deposit fees (TODO: How to re-deposit reward tokens that is not X or Y token?)
-            const initPositionAndAddLiquidityBuilder = yield dlmmPool.initializePositionAndAddLiquidityByStrategy(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
-                positionPubKey: params.newPosition,
-                user: userPda,
-                totalXAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
-                totalYAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+            const mainInstructions = [
+                ...claimBuilder.mainIxs,
+            ];
+            return (0, functions_1.createTransactionMeta)({
+                payer: params.userWallet,
+                description: 'Automation IX: Meteora Auto-claim instructions (claim fee, reward)',
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Claim fees and rewards from a large Meteora DLMM position (up to 1400 bins).
+     *
+     * For ≤149 bins, delegates to the single-TX claimAutomationIx.
+     * For ≥150 bins, chunks the bin range into ≤149-bin pieces and builds
+     * claimFee2Automation + claimReward2Automation per chunk, returning multiple TXs.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params Parameters required for claim (MeteoraCompound: userWallet, position)
+     * @returns Array of TransactionMetadataResponse for each transaction
+     */
+    claimFromLargePositionAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            try {
+                // Fetch position data
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const positionData = yield program.account.positionV2.fetch(params.position);
+                if (!positionData || !positionData.lbPair) {
+                    throw new Error(`Invalid position data: ${params.position.toString()}`);
+                }
+                const lbPair = positionData.lbPair;
+                const lowerBinId = positionData.lowerBinId;
+                const upperBinId = positionData.upperBinId;
+                const binCount = upperBinId - lowerBinId + 1;
+                // For ≤149 bins, delegate to existing single-TX claimAutomationIx
+                if (binCount <= 149) {
+                    const singleResult = yield this.claimAutomationIx({ connection, params, fetch: undefined });
+                    return [singleResult];
+                }
+                // ≥150 bins: chunked multi-TX approach
+                // Resolve pool data (tokens, programs, remaining accounts)
+                const resolved = yield this._resolveWithdrawPoolData({ connection, lbPair });
+                const { tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, remainingAccountsInfo, lbPairInfo } = resolved;
+                // Get reward infos from lbPair state
+                const rewardInfos = lbPairInfo.rewardInfos;
+                // Chunk [lowerBinId, upperBinId] into ≤149-bin pieces
+                const MAX_BINS_PER_CHUNK = 149;
+                const chunks = [];
+                let current = lowerBinId;
+                while (current <= upperBinId) {
+                    const upper = Math.min(current + MAX_BINS_PER_CHUNK - 1, upperBinId);
+                    chunks.push({ lower: current, upper });
+                    current = upper + 1;
+                }
+                // Pre-resolve reward info (avoid repeated RPC calls)
+                const rewardIxBuilders = [];
+                for (let rewardIndex = 0; rewardIndex < 2; rewardIndex++) {
+                    const rewardInfo = rewardInfos[rewardIndex];
+                    if (!rewardInfo || rewardInfo.mint.equals(web3.PublicKey.default)) {
+                        continue;
+                    }
+                    const rewardTokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [rewardInfo.mint]);
+                    const rewardTokenProgram = rewardTokenProgramMap[rewardInfo.mint.toString()];
+                    const rewardRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, rewardInfo.mint, rewardTokenProgram);
+                    rewardIxBuilders.push({
+                        rewardIndex,
+                        rewardMint: rewardInfo.mint,
+                        rewardVault: rewardInfo.vault,
+                        rewardTokenProgram,
+                        rewardRemainingAccountsInfo,
+                    });
+                }
+                // Build instructions per chunk
+                const transactions = [];
+                for (let i = 0; i < chunks.length; i++) {
+                    const chunk = chunks[i];
+                    const instructions = [];
+                    // claimFee2Automation for this chunk
+                    const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2Automation(connection, {
+                        userWallet: params.userWallet,
+                        lbPair,
+                        position: params.position,
+                        tokenMintX: tokenXMint,
+                        tokenMintY: tokenYMint,
+                        tokenProgramX: tokenXProgram,
+                        tokenProgramY: tokenYProgram,
+                        lowerBinId: chunk.lower,
+                        upperBinId: chunk.upper,
+                        pdaTokenType: types_1.TokenType.STA,
+                        remainingAccountsInfo,
+                    });
+                    instructions.push(claimFeeIx);
+                    // claimReward2Automation per chunk for each active reward
+                    for (const reward of rewardIxBuilders) {
+                        const claimRewardIx = yield this.ix.meteoraDlmm.claimReward2Automation(connection, {
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.position,
+                            rewardIndex: reward.rewardIndex,
+                            rewardMint: reward.rewardMint,
+                            rewardVault: reward.rewardVault,
+                            tokenProgram: reward.rewardTokenProgram,
+                            lowerBinId: chunk.lower,
+                            upperBinId: chunk.upper,
+                            pdaTokenType: types_1.TokenType.STA,
+                            remainingAccountsInfo: reward.rewardRemainingAccountsInfo,
+                        });
+                        instructions.push(claimRewardIx);
+                    }
+                    transactions.push(yield (0, functions_1.createTransactionMeta)({
+                        payer: params.userWallet,
+                        description: `Automation IX: Claim from large position (tx ${i + 1}/${chunks.length})`,
+                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                        mainInstructions: instructions,
+                    }));
+                }
+                return transactions;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Compound (claim + re-deposit) fees and rewards from a large Meteora DLMM position (up to 1400 bins).
+     *
+     * For ≤149 bins, delegates to the single-TX compoundAutomationIx.
+     * For ≥150 bins:
+     *   Phase 1: Chunked claim (claimFee2Automation + claimReward2Automation per chunk, to ATA)
+     *   Phase 2: Chunked re-deposit (rebalanceLiquidityAutomation per chunk, back into same position)
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params MeteoraCompound parameters (userWallet, position, distribution)
+     * @returns Array of TransactionMetadataResponse for each transaction
+     */
+    compoundFromLargePositionAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b, _c;
+            try {
+                // Fetch position data
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const positionData = yield program.account.positionV2.fetch(params.position);
+                if (!positionData || !positionData.lbPair) {
+                    throw new Error(`Invalid position data: ${params.position.toString()}`);
+                }
+                const lbPair = positionData.lbPair;
+                const lowerBinId = positionData.lowerBinId;
+                const upperBinId = positionData.upperBinId;
+                const binCount = upperBinId - lowerBinId + 1;
+                // For ≤149 bins, delegate to existing single-TX compoundAutomationIx
+                if (binCount <= 149) {
+                    const singleResult = yield this.compoundAutomationIx({ connection, params, fetch: undefined });
+                    return [singleResult];
+                }
+                // ≥150 bins: chunked multi-TX approach
+                const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+                // For compound, we use dummy equal amounts for deposit strategy calculation.
+                // The on-chain RebalanceLiquidity overrides totalXAmount/totalYAmount with ATA balance,
+                // so these values only affect the strategy ratio. Using equal amounts (like the single-TX
+                // compoundAutomationIx does with 100_000) ensures the strategy distributes evenly and
+                // doesn't try to transfer more of one token than is available from claimed fees.
+                const totalXAmount = new bn_js_1.default(100000);
+                const totalYAmount = new bn_js_1.default(100000);
+                const lbPairState = dlmmPool.dlmm.lbPair;
+                const tokenXMint = lbPairState.tokenXMint;
+                const tokenYMint = lbPairState.tokenYMint;
+                const rewardInfos = lbPairState.rewardInfos;
+                const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+                const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+                const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+                const remainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+                const lbPairInfo = yield (program.account.lbPair.fetch(lbPair));
+                // =========================================================================
+                // Phase 1: Chunked claim (to ATA for re-deposit)
+                // =========================================================================
+                const MAX_BINS_PER_CHUNK = 149;
+                const chunks = [];
+                let current = lowerBinId;
+                while (current <= upperBinId) {
+                    const upper = Math.min(current + MAX_BINS_PER_CHUNK - 1, upperBinId);
+                    chunks.push({ lower: current, upper });
+                    current = upper + 1;
+                }
+                // Pre-resolve reward info
+                const rewardIxBuilders = [];
+                for (let rewardIndex = 0; rewardIndex < 2; rewardIndex++) {
+                    const rewardInfo = rewardInfos[rewardIndex];
+                    if (!rewardInfo || rewardInfo.mint.equals(web3.PublicKey.default)) {
+                        continue;
+                    }
+                    const rewardTokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [rewardInfo.mint]);
+                    const rewardTokenProgram = rewardTokenProgramMap[rewardInfo.mint.toString()];
+                    const rewardRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, rewardInfo.mint, rewardTokenProgram);
+                    rewardIxBuilders.push({
+                        rewardIndex,
+                        rewardMint: rewardInfo.mint,
+                        rewardVault: rewardInfo.vault,
+                        rewardTokenProgram,
+                        rewardRemainingAccountsInfo,
+                    });
+                }
+                // Build claim instructions per chunk (to ATA for compound)
+                const claimTxs = [];
+                for (const chunk of chunks) {
+                    const instructions = [];
+                    const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2Automation(connection, {
+                        userWallet: params.userWallet,
+                        lbPair,
+                        position: params.position,
+                        tokenMintX: tokenXMint,
+                        tokenMintY: tokenYMint,
+                        tokenProgramX: tokenXProgram,
+                        tokenProgramY: tokenYProgram,
+                        lowerBinId: chunk.lower,
+                        upperBinId: chunk.upper,
+                        pdaTokenType: types_1.TokenType.ATA,
+                        remainingAccountsInfo,
+                    });
+                    instructions.push(claimFeeIx);
+                    for (const reward of rewardIxBuilders) {
+                        const claimRewardIx = yield this.ix.meteoraDlmm.claimReward2Automation(connection, {
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.position,
+                            rewardIndex: reward.rewardIndex,
+                            rewardMint: reward.rewardMint,
+                            rewardVault: reward.rewardVault,
+                            tokenProgram: reward.rewardTokenProgram,
+                            lowerBinId: chunk.lower,
+                            upperBinId: chunk.upper,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            remainingAccountsInfo: reward.rewardRemainingAccountsInfo,
+                        });
+                        instructions.push(claimRewardIx);
+                    }
+                    claimTxs.push(instructions);
+                }
+                // =========================================================================
+                // Phase 2: Chunked re-deposit back into the same position
+                // =========================================================================
+                const distributionToStrategyType = {
+                    'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
+                    'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
+                    'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
+                };
+                const strategyType = (_c = distributionToStrategyType[(_b = params.distribution) !== null && _b !== void 0 ? _b : 'SPOT-IMBALANCED']) !== null && _c !== void 0 ? _c : liquidityStrategy_1.StrategyType.SPOT;
+                const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
+                const depositTxs = yield this._meteoraDepositToLargePositionAutomation({
+                    connection,
+                    userWallet: params.userWallet,
+                    lbPair,
+                    position: params.position,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
+                    lowerBinId,
+                    upperBinId,
+                    strategyType,
+                    activeId,
+                    totalXAmount,
+                    totalYAmount,
+                });
+                // =========================================================================
+                // Phase 3: Assemble transactions
+                // =========================================================================
+                const assembled = [
+                    ...claimTxs,
+                    ...depositTxs,
+                ];
+                const transactions = [];
+                for (let i = 0; i < assembled.length; i++) {
+                    transactions.push(yield (0, functions_1.createTransactionMeta)({
+                        payer: params.userWallet,
+                        description: `Automation IX: Compound large position (tx ${i + 1}/${assembled.length})`,
+                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                        mainInstructions: assembled[i],
+                    }));
+                }
+                return transactions;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * @deprecated Use rebalanceLargerPositionAutomation instead
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params Parameters required for rebalance
+     * @returns A ResponseWithStatus containing TransactionMetadataResponse.
+     */
+    rebalanceAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            const position = yield program.account.positionV2.fetch(params.currentPosition);
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, position.lbPair, this.ix);
+            const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+            // Step 1: Claim all fees/rewards, remove all liquidity and close current position
+            const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+            const userPosition = userPositions.find(userPosition => userPosition.publicKey.equals(params.currentPosition));
+            if (userPosition === undefined) {
+                throw new Error(`Position: ${params.currentPosition} does not exist.`);
+            }
+            const binIdsToRemove = userPosition.positionData.positionBinData.map(bin => bin.binId);
+            const removeLiquidityBuilder = yield dlmmPool.removeLiquidity(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
+                user: userPda,
+                position: params.currentPosition,
+                fromBinId: position.lowerBinId,
+                toBinId: position.upperBinId,
+                bps: new bn_js_1.default(10000),
+                shouldClaimAndClose: true,
+            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
+            if (!!params.useAta) {
+                removeLiquidityBuilder.replaceClaimFeeTokenToATA();
+                removeLiquidityBuilder.replaceClaimRewardToATA();
+            }
+            else {
+                removeLiquidityBuilder.replaceClaimFeeTokenToSTA();
+                removeLiquidityBuilder.replaceClaimRewardToSTA();
+            }
+            // Re-deposit fees (TODO: How to re-deposit reward tokens that is not X or Y token?)
+            const initPositionAndAddLiquidityBuilder = yield dlmmPool.initializePositionAndAddLiquidityByStrategy(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
+                positionPubKey: params.newPosition,
+                user: userPda,
+                totalXAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                totalYAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
                 strategy: {
                     maxBinId: params.binRange.upperRange,
                     minBinId: params.binRange.lowerRange,
@@ -1274,6 +1727,13 @@ class Transactions {
             });
         });
     }
+    /**
+     * @deprecated Use rebalanceLargerPositionAutomation instaed
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params Parameters required for rebalance
+     * @returns A ResponseWithStatus containing TransactionMetadataResponse.
+     */
     rebalanceAutomationIx2(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             var _b;
@@ -1597,20 +2057,6 @@ class Transactions {
      *
      * @param connection The Solana web3 connection object for blockchain interactions.
      * @param params Parameters required for rebalance (same as MeteoraRebalance)
-     * @returns A TransactionMetadataResponse containing the transaction metadata
-     */
-    /**
-     * Rebalance a Meteora DLMM position to a new bin range (supports up to 149 bins).
-     *
-     * This method chunks the rebalance into multiple transactions:
-     * - TX 1: Remove liquidity + claim fees + claim rewards + close position
-     * - TX 2: Initialize new position + extend position (if > 70 bins)
-     * - TX 3: Initialize bin array + add liquidity (if > 70 bins)
-     *
-     * For positions <= 70 bins, TX 2 and TX 3 are combined into a single transaction.
-     *
-     * @param connection - Solana connection
-     * @param params - MeteoraRebalance parameters
      * @returns Array of TransactionMetadataResponse for each transaction
      */
     rebalanceLargerPositionAutomation(_a) {
@@ -1870,65 +2316,829 @@ class Transactions {
             }
         });
     }
-    openAutomationIx(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
-            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, params.pool, this.ix);
-            const userPda = (0, functions_1.generateUserPda)(params.userWallet);
-            // Open new position
-            const initPositionAndAddLiquidityBuilder = yield dlmmPool.initializePositionAndAddLiquidityByStrategy(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
-                positionPubKey: params.position,
-                user: userPda,
-                slippage: params.slippage,
-                totalXAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
-                totalYAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
-                strategy: {
-                    maxBinId: params.binRange.upperRange,
-                    minBinId: params.binRange.lowerRange,
-                    strategyType: types_3.StrategyTypeMap[params.distribution],
-                },
-                skipInputTokenCheck: true, // Rebalance should be independent of user wallet TA
-                opt: {
-                    pdaTokenType: params.opt.pdaTokenType,
-                    withAmount: {
-                        userTokenXAmount: params.opt.withAmount.userTokenXAmount,
-                        userTokenYAmount: params.opt.withAmount.userTokenYAmount,
-                    },
-                    fuelAccount: params.opt.fuelAccount,
-                },
-            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
-            const mainInstructions = [...initPositionAndAddLiquidityBuilder.mainIxs];
-            return (0, functions_1.createTransactionMeta)({
-                payer: params.userWallet,
-                description: 'Automation IX: Meteora Open instruction (Open position)',
-                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                mainInstructions,
-            });
-        });
-    }
-    relativeOpenAutomationIx(_a) {
+    /**
+     * Rebalance a large Meteora DLMM position (up to 1400 bins) using automation instructions.
+     *
+     * For ≤149 bins, delegates to rebalanceLargerPositionAutomation.
+     * For ≥150 bins, uses a chunked multi-TX approach:
+     *   Phase 1: Chunked withdraw from current position
+     *   Phase 2: Initialize new large position
+     *   Phase 3: Chunked deposit to new position
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params Parameters required for rebalance
+     * @returns Array of TransactionMetadataResponse for each transaction
+     */
+    rebalanceLargePositionAutomation(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
-            const { userWallet, pool, position, relativeBinRange, checkRange, distribution, targetActiveBin, fuelAccount, pdaTokenType, userTokenXAmount, userTokenYAmount } = params;
-            const openParams = {
-                userWallet,
-                lbPair: pool,
-                position,
-                relativeLowerBinId: relativeBinRange.lowerRange,
-                relativeUpperBinId: relativeBinRange.upperRange,
-                strategyType: types_3.StrategyTypeMap[distribution],
-                checkRange: {
-                    minBinId: checkRange.lowerRange,
-                    maxBinId: checkRange.upperRange,
-                },
-                targetActiveBin: targetActiveBin !== null && targetActiveBin !== void 0 ? targetActiveBin : undefined,
-                useFuelAccount: fuelAccount !== null && fuelAccount !== void 0 ? fuelAccount : false,
-                pdaTokenType,
-                userTokenXAmount,
-                userTokenYAmount,
-            };
-            const openIx = yield this.ix.meteoraDlmm.relativeOpenAutomation(connection, openParams);
-            return (0, functions_1.createTransactionMeta)({
-                payer: params.userWallet,
-                description: 'Automation IX: Meteora Open with relative bins',
+            var _b;
+            try {
+                // Fetch position to get lbPair and bin range
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const positionData = yield program.account.positionV2.fetch(params.currentPosition);
+                if (!positionData || !positionData.lbPair) {
+                    throw new Error(`Invalid position data: ${params.currentPosition.toString()}`);
+                }
+                const lbPair = positionData.lbPair;
+                const currentLowerBinId = positionData.lowerBinId;
+                const currentUpperBinId = positionData.upperBinId;
+                const currentBinCount = currentUpperBinId - currentLowerBinId + 1;
+                // For ≤149 bins, delegate to existing rebalanceLargerPositionAutomation
+                if (currentBinCount <= 149 && params.width <= 149) {
+                    return this.rebalanceLargerPositionAutomation({ connection, params, fetch: undefined });
+                }
+                // ≥150 bins: multi-TX chunked approach
+                const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+                const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+                // Get position's token amounts for deposit strategy calculation
+                const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+                const userPosition = userPositions.find(pos => pos.publicKey.equals(params.currentPosition));
+                if (!userPosition) {
+                    throw new Error(`Position ${params.currentPosition.toString()} not found`);
+                }
+                const positionBinData = userPosition.positionData.positionBinData;
+                const { totalXAmount, totalYAmount } = positionBinData.reduce((acc, bin) => ({
+                    totalXAmount: acc.totalXAmount.add(new bn_js_1.default(bin.positionXAmount)),
+                    totalYAmount: acc.totalYAmount.add(new bn_js_1.default(bin.positionYAmount)),
+                }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
+                const lbPairState = dlmmPool.dlmm.lbPair;
+                const tokenXMint = lbPairState.tokenXMint;
+                const tokenYMint = lbPairState.tokenYMint;
+                const rewardInfos = lbPairState.rewardInfos;
+                const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+                const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+                const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+                const remainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+                const lbPairInfo = yield (program.account.lbPair.fetch(lbPair));
+                // Whether to compound during rebalance, or nope.
+                const pdaTokenTypeForClaimables = params.useAta ? types_1.TokenType.ATA : types_1.TokenType.STA;
+                // =========================================================================
+                // Merged approach: withdraw + init/extend + deposit per TX (~75 bins each)
+                // =========================================================================
+                const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
+                const distributionToStrategyType = {
+                    'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
+                    'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
+                    'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
+                };
+                const strategyType = (_b = distributionToStrategyType[params.distribution]) !== null && _b !== void 0 ? _b : liquidityStrategy_1.StrategyType.SPOT;
+                const binStep = new bn_js_1.default(dlmmPool.dlmm.lbPair.binStep);
+                const assembled = yield this._buildMergedRebalanceChunks({
+                    connection,
+                    userWallet: params.userWallet,
+                    lbPair,
+                    oldPosition: params.currentPosition,
+                    oldLowerBinId: currentLowerBinId,
+                    oldUpperBinId: currentUpperBinId,
+                    newPosition: params.newPosition,
+                    relativeLowerBinId: params.relativeLowerBin,
+                    width: params.width,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
+                    remainingAccountsInfo,
+                    lbPairInfo,
+                    rewardInfos,
+                    pdaTokenTypeForClaimables,
+                    binStep,
+                    strategyType,
+                    activeId,
+                    totalXAmount,
+                    totalYAmount,
+                });
+                // Wrap each instruction array with createTransactionMeta
+                const transactions = [];
+                for (let i = 0; i < assembled.length; i++) {
+                    transactions.push(yield (0, functions_1.createTransactionMeta)({
+                        payer: params.userWallet,
+                        description: `Automation IX: Rebalance large position (tx ${i + 1}/${assembled.length})`,
+                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                        mainInstructions: assembled[i],
+                    }));
+                }
+                return transactions;
+            }
+            catch (error) {
+                console.error('=== REBALANCE LARGE POSITION AUTOMATION ERROR ===');
+                console.error('Error type:', error instanceof Error ? error.constructor.name : typeof error);
+                console.error('Error message:', error instanceof Error ? error.message : String(error));
+                console.error('Error stack:', error instanceof Error ? error.stack : 'No stack trace');
+                console.error('Full error object:', error);
+                console.error('=== END ERROR LOG ===');
+                throw error;
+            }
+        });
+    }
+    /**
+     * Generates a single rebalanceLiquidityAutomation instruction for reshaping a Meteora DLMM position.
+     *
+     * This is a low-level building block that creates ONE instruction to:
+     * - Remove liquidity from specified bins (removeLiquidityParams)
+     * - Add liquidity to new bins (addLiquidityParams)
+     *
+     * Unlike meteoraRebalanceLargePositionAutomation2 which handles full position reshaping
+     * with chunking and multiple TXs, this function returns a single instruction that can
+     * be composed into custom transaction flows.
+     *
+     * Features:
+     * - Token2022 transfer hook support
+     * - No fee/reward claiming (shouldClaimFee: false, shouldClaimReward: false)
+     * - Uses ATA token accounts
+     * - NoShrinkBoth shrink mode
+     *
+     * Note: Not part of test suite yet. For remove + add liquidity params, please fork
+     * hawk-api/src/meteora/liquidityStrategy.ts to generate the parameters.
+     *
+     * @param connection Solana web3 connection
+     * @param params Reshape parameters including position, bin ranges, and liquidity params
+     * @returns LabeledInstructions with single 'rebalance_liquidity' instruction
+     */
+    meteoraReshapePositionAutomation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b, _c;
+            // Fetch pool data
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, params.lbPair, this.ix);
+            const lbPairState = dlmmPool.dlmm.lbPair;
+            const tokenXMint = lbPairState.tokenXMint;
+            const tokenYMint = lbPairState.tokenYMint;
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+            const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+            const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+            // Fetch transfer hook accounts for token X and Y (Token2022 support)
+            const baseRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+            // Build combined remainingAccountsInfo with transfer hooks for X, Y, and rewards
+            // The slices describe: TransferHookX, TransferHookY, TransferHookMultiReward(index) for each reward
+            // IMPORTANT: Always include all slices, even with length=0, so Meteora knows the account structure
+            const combinedSlices = [];
+            const combinedAccounts = [];
+            // Always add TransferHookX and TransferHookY slices (even if length=0)
+            const xSlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookX);
+            const ySlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookY);
+            combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookX, length: (_b = xSlice === null || xSlice === void 0 ? void 0 : xSlice.length) !== null && _b !== void 0 ? _b : 0 });
+            combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookY, length: (_c = ySlice === null || ySlice === void 0 ? void 0 : ySlice.length) !== null && _c !== void 0 ? _c : 0 });
+            // Add transfer hook accounts from base (for X and Y)
+            combinedAccounts.push(...baseRemainingAccountsInfo.accounts);
+            const remainingAccountsInfo = {
+                slices: combinedSlices,
+                accounts: combinedAccounts,
+            };
+            return {
+                instructions: [yield this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
+                        connection,
+                        userWallet: params.userWallet,
+                        position: params.position,
+                        lbPair: params.lbPair,
+                        tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
+                        activeId: params.activeId,
+                        pdaTokenType: types_1.TokenType.ATA,
+                        maxActiveBinSlippage: 300,
+                        shouldClaimFee: false,
+                        shouldClaimReward: false,
+                        minWithdrawXAmount: new bn_js_1.default(0),
+                        maxDepositXAmount: new bn_js_1.default(0),
+                        minWithdrawYAmount: new bn_js_1.default(0),
+                        maxDepositYAmount: new bn_js_1.default(0),
+                        removeLiquidityParams: params.removeLiquidityParams,
+                        addLiquidityParams: params.addLiquidityParams,
+                        shrinkMode: types_3.ShrinkMode.NoShrinkBoth,
+                        remainingAccountsInfo,
+                    })],
+                labels: ['rebalance_liquidity'],
+            };
+        });
+    }
+    /**
+     * @note DO NOT USE. STILL UNDER DEVELOPMENT. Tests still failing
+     * Reshape position: withdraw from old bins and deposit to new bins on the SAME position.
+     *
+     * Uses only rebalanceLiquidityAutomation (one IX per TX):
+     *   Remove TXs: rebalanceLiquidityAutomation with removeLiquidityParams (~75 bins/TX)
+     *   Deposit TXs: rebalanceLiquidityAutomation with addLiquidityParams (~75 bins/TX)
+     *
+     * Meteora's rebalance_liquidity handles position extension and bin array
+     * initialization internally — no separate IXs needed.
+     *
+     * Key differences from rebalanceLargePositionAutomation:
+     *   - Same position (no close/create, no new position keypair needed)
+     *   - Supports positions of any size (69 to 1400+ bins)
+     */
+    meteoraRebalanceLargePositionAutomation2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b, _c, _d;
+            try {
+                const WITHDRAW_CHUNK_SIZE = 260;
+                const DEPOSIT_CHUNK_SIZE = 200;
+                const DEPOSIT_CHUNK_INITIAL_SIZE = 150;
+                // Always reserve a small portion of bins for the pivot TX to ensure
+                // withdraw + deposit happen together (prevents ReallocExceedMaxLengthPerInstruction)
+                const PIVOT_RESERVE = 160;
+                // Fetch pool data
+                const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, params.lbPair, this.ix);
+                const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+                const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
+                // Get position's token amounts for deposit strategy calculation
+                const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+                const userPosition = userPositions.find(pos => pos.publicKey.equals(params.position));
+                if (!userPosition) {
+                    throw new Error(`Position ${params.position.toString()} not found`);
+                }
+                const positionBinData = userPosition.positionData.positionBinData;
+                // Use actual liquidity range (bins with non-zero amounts) instead of padded position struct range
+                const binsWithLiquidity = positionBinData.filter(bin => !new bn_js_1.default(bin.positionXAmount).isZero() || !new bn_js_1.default(bin.positionYAmount).isZero());
+                const oldLowerBinId = binsWithLiquidity.length > 0
+                    ? binsWithLiquidity[0].binId
+                    : userPosition.positionData.lowerBinId;
+                const oldUpperBinId = binsWithLiquidity.length > 0
+                    ? binsWithLiquidity[binsWithLiquidity.length - 1].binId
+                    : userPosition.positionData.upperBinId;
+                const { totalXAmount, totalYAmount } = positionBinData.reduce((acc, bin) => ({
+                    totalXAmount: acc.totalXAmount.add(new bn_js_1.default(bin.positionXAmount)),
+                    totalYAmount: acc.totalYAmount.add(new bn_js_1.default(bin.positionYAmount)),
+                }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
+                const newLowerBinId = activeId + params.relativeLowerBin;
+                const newUpperBinId = newLowerBinId + params.width - 1;
+                console.log(`Total chunk per tx (withdraw): ${WITHDRAW_CHUNK_SIZE} bins, total chunk per tx (deposit): ${DEPOSIT_CHUNK_SIZE} bins`);
+                console.log(`old lower bin id: ${oldLowerBinId}, old upper bin id: ${oldUpperBinId}, old width: ${oldUpperBinId - oldLowerBinId + 1}`);
+                console.log(`new lower bin id: ${newLowerBinId}, new upper bin id: ${newUpperBinId}, new width: ${newUpperBinId - newLowerBinId + 1}`);
+                const lbPairState = dlmmPool.dlmm.lbPair;
+                const tokenXMint = lbPairState.tokenXMint;
+                const tokenYMint = lbPairState.tokenYMint;
+                const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+                const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+                const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+                // Fetch transfer hook accounts for token X and Y (Token2022 support)
+                const baseRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+                // Extract reward infos for claiming rewards during rebalance
+                const rewardInfos = [];
+                const rewardInfosFromPair = lbPairState.rewardInfos;
+                if (rewardInfosFromPair && rewardInfosFromPair.length > 0) {
+                    // Collect reward mints that are active (non-default)
+                    const activeRewardMints = [];
+                    for (const reward of rewardInfosFromPair) {
+                        if (!reward.mint.equals(web3.PublicKey.default)) {
+                            activeRewardMints.push(reward.mint);
+                        }
+                    }
+                    // Get token programs for reward mints
+                    if (activeRewardMints.length > 0) {
+                        const rewardTokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, activeRewardMints);
+                        for (let i = 0; i < rewardInfosFromPair.length; i++) {
+                            const reward = rewardInfosFromPair[i];
+                            if (!reward.mint.equals(web3.PublicKey.default)) {
+                                rewardInfos.push({
+                                    rewardIndex: i,
+                                    rewardVault: reward.vault,
+                                    rewardMint: reward.mint,
+                                    rewardTokenProgram: rewardTokenProgramMap[reward.mint.toString()],
+                                });
+                            }
+                        }
+                    }
+                }
+                console.log(`[Pipeline] Found ${rewardInfos.length} active reward(s) for this pool`);
+                // Build combined remainingAccountsInfo with transfer hooks for X, Y, and rewards
+                // The slices describe: TransferHookX, TransferHookY, TransferHookMultiReward(index) for each reward
+                // IMPORTANT: Always include all slices, even with length=0, so Meteora knows the account structure
+                const combinedSlices = [];
+                const combinedAccounts = [];
+                // Always add TransferHookX and TransferHookY slices (even if length=0)
+                const xSlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookX);
+                const ySlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookY);
+                combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookX, length: (_b = xSlice === null || xSlice === void 0 ? void 0 : xSlice.length) !== null && _b !== void 0 ? _b : 0 });
+                combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookY, length: (_c = ySlice === null || ySlice === void 0 ? void 0 : ySlice.length) !== null && _c !== void 0 ? _c : 0 });
+                // Add transfer hook accounts from base (for X and Y)
+                combinedAccounts.push(...baseRemainingAccountsInfo.accounts);
+                // Fetch transfer hook accounts for each reward and add to combined info
+                // IMPORTANT: Always add TransferHookMultiReward slice for each reward, even if length=0
+                // This tells Meteora about the reward position in the remaining accounts
+                for (const reward of rewardInfos) {
+                    const rewardTransferHookInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, reward.rewardMint, reward.rewardTokenProgram);
+                    // Always add TransferHookMultiReward slice (even if empty length for standard SPL tokens)
+                    const transferHookLength = rewardTransferHookInfo.slices.length > 0
+                        ? rewardTransferHookInfo.slices[0].length
+                        : 0;
+                    combinedSlices.push({
+                        accountsType: types_1.RemainingAccountsType.TransferHookMultiReward,
+                        length: transferHookLength,
+                        multiRewardIndex: reward.rewardIndex,
+                    });
+                    combinedAccounts.push(...rewardTransferHookInfo.accounts);
+                }
+                const remainingAccountsInfo = {
+                    slices: combinedSlices,
+                    accounts: combinedAccounts,
+                };
+                const distributionToStrategyType = {
+                    'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
+                    'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
+                    'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
+                };
+                const strategyType = (_d = distributionToStrategyType[params.distribution]) !== null && _d !== void 0 ? _d : liquidityStrategy_1.StrategyType.SPOT;
+                const binStep = new bn_js_1.default(dlmmPool.dlmm.lbPair.binStep);
+                // Build new-position deposit chunks
+                const minDeltaId = new bn_js_1.default(newLowerBinId - activeId);
+                const maxDeltaId = new bn_js_1.default(newUpperBinId - activeId);
+                const favorXInActiveId = totalYAmount.isZero() && !totalXAmount.isZero();
+                const strategyParams = (0, liquidityStrategy_1.buildStrategyParameters)(strategyType, totalXAmount, totalYAmount, minDeltaId, maxDeltaId, binStep, new bn_js_1.default(activeId), favorXInActiveId);
+                // =====================================================================
+                // Pipeline algorithm: pack withdraw + deposit work into fewer TXs.
+                //
+                // Given W old bins to withdraw and D new bins to deposit:
+                //   Phase 1: Pure withdraw TXs — all withdraw chunks except the last
+                //   Phase 2: Pivot TX — last withdraw chunk + extend + initBinArrays
+                //            + first deposit (if small enough to fit without CU issues)
+                //   Phase 3: Pure deposit TXs — remaining deposit bins by CHUNK_SIZE
+                //
+                // When the total extension is large or the deposit range spans many
+                // bin arrays, the transition IXs (extend + initBinArrays) are placed
+                // in a separate TX to avoid exceeding compute unit limits.
+                // =====================================================================
+                const txInstructions = [];
+                // Helper: build on-chain deposit param from a ChunkedDepositParameters
+                const buildDepositParam = (chunk) => {
+                    const p = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunk.params.x0, chunk.params.y0, chunk.params.deltaX, chunk.params.deltaY);
+                    return {
+                        minDeltaId: chunk.minDeltaId.toNumber(),
+                        maxDeltaId: chunk.maxDeltaId.toNumber(),
+                        x0: p.x0, y0: p.y0, deltaX: p.deltaX, deltaY: p.deltaY,
+                        bitFlag: p.bitFlag, favorXInActiveId,
+                    };
+                };
+                // Helper: build withdraw IX
+                const buildWithdrawIx = (lower, upper) => __awaiter(this, void 0, void 0, function* () {
+                    const binArrayOverrides = this.ix.pda.meteora.deriveBinArrays(params.lbPair, lower, upper);
+                    return this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
+                        connection,
+                        userWallet: params.userWallet,
+                        position: params.position,
+                        lbPair: params.lbPair,
+                        tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
+                        activeId,
+                        pdaTokenType: types_1.TokenType.ATA,
+                        maxActiveBinSlippage: 300,
+                        shouldClaimFee: true,
+                        shouldClaimReward: rewardInfos.length > 0,
+                        minWithdrawXAmount: new bn_js_1.default(0),
+                        maxDepositXAmount: new bn_js_1.default(0),
+                        minWithdrawYAmount: new bn_js_1.default(0),
+                        maxDepositYAmount: new bn_js_1.default(0),
+                        removeLiquidityParams: [{ minBinId: lower, maxBinId: upper, bps: 10000 }],
+                        addLiquidityParams: [],
+                        binArrayOverrides,
+                        shrinkMode: types_3.ShrinkMode.Default,
+                        rewardInfos,
+                        remainingAccountsInfo,
+                    });
+                });
+                // Helper: build deposit IX from a deposit chunk
+                const buildDepositIx = (chunk, removeLiquidityParams) => __awaiter(this, void 0, void 0, function* () {
+                    let trueMin = chunk.lowerBinId;
+                    let trueMax = chunk.upperBinId;
+                    if (removeLiquidityParams) {
+                        trueMin = Math.min(chunk.lowerBinId, removeLiquidityParams.minBinId);
+                        trueMax = Math.max(chunk.upperBinId, removeLiquidityParams.maxBinId);
+                    }
+                    const binArrayOverrides = this.ix.pda.meteora.deriveBinArrays(params.lbPair, trueMin, trueMax);
+                    return yield this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
+                        connection,
+                        userWallet: params.userWallet,
+                        position: params.position,
+                        lbPair: params.lbPair,
+                        tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
+                        activeId,
+                        pdaTokenType: types_1.TokenType.ATA,
+                        maxActiveBinSlippage: 300,
+                        shouldClaimFee: removeLiquidityParams ? true : false,
+                        shouldClaimReward: !!removeLiquidityParams && rewardInfos.length > 0,
+                        minWithdrawXAmount: new bn_js_1.default(0),
+                        maxDepositXAmount: chunk.maxAmountX,
+                        minWithdrawYAmount: new bn_js_1.default(0),
+                        maxDepositYAmount: chunk.maxAmountY,
+                        removeLiquidityParams: removeLiquidityParams ? [{ minBinId: removeLiquidityParams.minBinId, maxBinId: removeLiquidityParams.maxBinId, bps: 10000 }] : [],
+                        addLiquidityParams: [buildDepositParam(chunk)],
+                        binArrayOverrides,
+                        shrinkMode: removeLiquidityParams ? types_3.ShrinkMode.Default : types_3.ShrinkMode.NoShrinkBoth,
+                        rewardInfos: removeLiquidityParams ? rewardInfos : undefined,
+                        remainingAccountsInfo,
+                    });
+                });
+                // Build transition IXs: increasePositionLength + initBinArrays.
+                // Bin arrays must be pre-initialized before rebalanceLiquidity deposits.
+                const increasePositionLengthIxs = [];
+                // Generate increasePositionLength IXs to extend position (assumption at the moment, I expect calculation to be wrong)
+                let currentLower = newLowerBinId + WITHDRAW_CHUNK_SIZE;
+                while (currentLower < newUpperBinId) {
+                    const currentWidth = newUpperBinId - currentLower + 1;
+                    const binsToAdd = Math.min(91, currentWidth);
+                    console.log('Increasing position length by', binsToAdd, 'bins at lower', currentLower);
+                    increasePositionLengthIxs.push(yield this.ix.meteoraDlmm.increasePositionLengthAutomation({
+                        connection,
+                        userWallet: params.userWallet,
+                        lbPair: params.lbPair,
+                        position: params.position,
+                        lengthToAdd: binsToAdd,
+                        side: types_1.MeteoraPositionSide.Upper,
+                    }));
+                    currentLower = currentLower + binsToAdd;
+                }
+                // Build all deposit chunks upfront
+                const depositChunks = (0, liquidityStrategy_1.chunkDepositParametersWithInitialSize)(strategyParams, minDeltaId, maxDeltaId, new bn_js_1.default(activeId), binStep, DEPOSIT_CHUNK_INITIAL_SIZE, DEPOSIT_CHUNK_SIZE, favorXInActiveId);
+                // Build old-position withdraw chunks, reserving PIVOT_RESERVE bins for pivot TX
+                const oldWidth = oldUpperBinId - oldLowerBinId + 1;
+                const oldChunks = [];
+                let current = oldLowerBinId;
+                // Build Phase 1 withdraw chunks (before pivot)
+                while (current < oldUpperBinId) {
+                    const upper = Math.min(WITHDRAW_CHUNK_SIZE - 1, oldUpperBinId - current) + current;
+                    console.log(`Generating withdraw chunk: [${current}, ${upper}, ${upper - current + 1} bins]`);
+                    oldChunks.push({ lower: current, upper });
+                    current = upper + 1;
+                }
+                const remainder = oldWidth % WITHDRAW_CHUNK_SIZE;
+                if (remainder === 0 || remainder > PIVOT_RESERVE) {
+                    // Pop last chunk to reserve for pivot
+                    const popped = oldChunks.pop();
+                    // Then insert bigger and final chunk for pivot
+                    const upper = popped.upper - PIVOT_RESERVE;
+                    oldChunks.push({ lower: popped.lower, upper });
+                    oldChunks.push({ lower: upper + 1, upper: popped.upper });
+                }
+                // =====================================================================
+                // Phase 1: Pure withdraw TXs — all chunks in oldChunks (before pivot)
+                // =====================================================================
+                for (const chunk of oldChunks) {
+                    console.log(`Withdrawing from chunk: [${chunk.lower}, ${chunk.upper}]`);
+                    txInstructions.push([yield buildWithdrawIx(chunk.lower, chunk.upper)]);
+                }
+                // Pop the last one
+                txInstructions.pop();
+                // Get the last withdraw chunk for pivot
+                const lastWithdrawChunk = oldChunks[oldChunks.length - 1];
+                // =====================================================================
+                // Phase 2 (Pivot TX): Withdraw pivot reserve + first deposit
+                // This ensures bins "jump" to new position, preventing ReallocExceedMaxLengthPerInstruction
+                // =====================================================================
+                txInstructions.push([
+                    yield buildDepositIx(depositChunks[0], { minBinId: lastWithdrawChunk.lower, maxBinId: lastWithdrawChunk.upper }),
+                    ...increasePositionLengthIxs,
+                ]);
+                // =====================================================================
+                // Phase 3: Remaining deposit TXs
+                // - Second deposit (i=1): includes increasePositionLengthIxs if needed
+                // - Subsequent deposits (i=2+): pure deposit
+                // =====================================================================
+                for (let i = 1; i < depositChunks.length; i++) {
+                    const chunk = depositChunks[i];
+                    txInstructions.push([yield buildDepositIx(chunk)]);
+                }
+                // Wrap each instruction array with createTransactionMeta
+                const transactions = [];
+                for (let i = 0; i < txInstructions.length; i++) {
+                    transactions.push(yield (0, functions_1.createTransactionMeta)({
+                        payer: params.userWallet,
+                        description: `Automation IX: Reshape position (tx ${i + 1}/${txInstructions.length})`,
+                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                        mainInstructions: txInstructions[i],
+                    }));
+                }
+                return transactions;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Build raw instruction arrays for depositing liquidity to a large Meteora DLMM position
+     * using rebalanceLiquidityAutomation (automation variant).
+     * Skips depositMultipleTokenV2 since tokens are already in ATA from the withdraw phase.
+     */
+    _meteoraDepositToLargePositionAutomation(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const MAX_BINS_PER_TX = 149;
+            const { connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, lowerBinId, upperBinId, strategyType, activeId, totalXAmount, totalYAmount, } = params;
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+            const binStep = new bn_js_1.default(dlmmPool.dlmm.lbPair.binStep);
+            // 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);
+            // Auto-determine favorXInActiveId from deposit amounts (matches Meteora SDK behavior)
+            const favorXInActiveId = totalYAmount.isZero() && !totalXAmount.isZero();
+            // Build strategy parameters ONCE for entire position using actual withdrawn amounts
+            const strategyParams = (0, liquidityStrategy_1.buildStrategyParameters)(strategyType, totalXAmount, totalYAmount, minDeltaId, maxDeltaId, binStep, new bn_js_1.default(activeId), favorXInActiveId);
+            // 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);
+            const txInstructions = [];
+            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);
+                const instructions = [];
+                // 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 rebalanceLiquidityAutomation
+                const depositIx = yield this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
+                    connection,
+                    userWallet,
+                    position,
+                    lbPair,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
+                    activeId,
+                    pdaTokenType: types_1.TokenType.ATA,
+                    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: [],
+                    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);
+                txInstructions.push(instructions);
+            }
+            return txInstructions;
+        });
+    }
+    /**
+     * Build merged rebalance chunks that combine withdraw + init/extend + deposit
+     * into fewer transactions. Each TX handles ~75 bins of withdraw and deposit,
+     * significantly reducing the total number of transactions needed.
+     *
+     * Per-chunk instructions (in order):
+     *   [First TX only] initializePositionRelativeAutomation (≤70 bins)
+     *   [If position not yet covers this chunk] increasePositionLengthAutomation (≤91 bins each)
+     *   removeLiquidityByRange2Automation (≤75 bins from old position)
+     *   claimFee2Automation (≤75 bins from old position)
+     *   claimReward2Automation × N (≤75 bins from old position, per active reward)
+     *   [Last old chunk only] closePosition2Automation
+     *   meteoraDlmmInitializeBinArray (≤75 bins for new position)
+     *   rebalanceLiquidityAutomation (≤75 bins deposit to new position)
+     */
+    _buildMergedRebalanceChunks(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const CHUNK_SIZE = 75;
+            const MAX_INIT_WIDTH = 70;
+            const MAX_EXTEND_LENGTH = 91;
+            const { connection, userWallet, lbPair, oldPosition, oldLowerBinId, oldUpperBinId, newPosition, relativeLowerBinId, width, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, remainingAccountsInfo, rewardInfos, pdaTokenTypeForClaimables, binStep, strategyType, activeId, totalXAmount, totalYAmount, } = params;
+            // Pre-resolve reward info (avoid repeated RPC calls)
+            const rewardIxBuilders = [];
+            for (let rewardIndex = 0; rewardIndex < 2; rewardIndex++) {
+                const rewardInfo = rewardInfos[rewardIndex];
+                if (!rewardInfo || rewardInfo.mint.equals(web3.PublicKey.default)) {
+                    continue;
+                }
+                const rewardTokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [rewardInfo.mint]);
+                const rewardTokenProgram = rewardTokenProgramMap[rewardInfo.mint.toString()];
+                const rewardRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, rewardInfo.mint, rewardTokenProgram);
+                rewardIxBuilders.push({
+                    rewardIndex,
+                    rewardMint: rewardInfo.mint,
+                    rewardVault: rewardInfo.vault,
+                    rewardTokenProgram,
+                    rewardRemainingAccountsInfo,
+                });
+            }
+            // Build old-position withdraw chunks (75 bins each)
+            const oldChunks = [];
+            let current = oldLowerBinId;
+            while (current <= oldUpperBinId) {
+                const upper = Math.min(current + CHUNK_SIZE - 1, oldUpperBinId);
+                oldChunks.push({ lower: current, upper });
+                current = upper + 1;
+            }
+            // Build new-position deposit chunks
+            const newLowerBinId = activeId + relativeLowerBinId;
+            const newUpperBinId = newLowerBinId + width - 1;
+            const minDeltaId = new bn_js_1.default(newLowerBinId - activeId);
+            const maxDeltaId = new bn_js_1.default(newUpperBinId - activeId);
+            const favorXInActiveId = totalYAmount.isZero() && !totalXAmount.isZero();
+            const strategyParams = (0, liquidityStrategy_1.buildStrategyParameters)(strategyType, totalXAmount, totalYAmount, minDeltaId, maxDeltaId, binStep, new bn_js_1.default(activeId), favorXInActiveId);
+            const depositChunks = (0, liquidityStrategy_1.chunkDepositParameters)(strategyParams, minDeltaId, maxDeltaId, new bn_js_1.default(activeId), binStep, CHUNK_SIZE, favorXInActiveId);
+            const totalChunks = Math.max(oldChunks.length, depositChunks.length);
+            const txInstructions = [];
+            let positionBinsAllocated = 0;
+            for (let i = 0; i < totalChunks; i++) {
+                const instructions = [];
+                // === Init/extend new position for this chunk's deposit range ===
+                if (i === 0) {
+                    const initWidth = Math.min(MAX_INIT_WIDTH, width);
+                    const initPositionIx = yield this.ix.meteoraDlmm.initializePositionRelativeAutomation(connection, {
+                        userWallet,
+                        lbPair,
+                        position: newPosition,
+                        relativeLowerBinId,
+                        width: initWidth,
+                    });
+                    instructions.push(initPositionIx);
+                    positionBinsAllocated = initWidth;
+                }
+                // Extend position to cover this chunk's deposit range
+                if (i < depositChunks.length) {
+                    const binsNeeded = Math.min((i + 1) * CHUNK_SIZE, width);
+                    while (positionBinsAllocated < binsNeeded) {
+                        const toAdd = Math.min(MAX_EXTEND_LENGTH, binsNeeded - positionBinsAllocated);
+                        const extendIx = yield this.ix.meteoraDlmm.increasePositionLengthAutomation({
+                            connection,
+                            userWallet,
+                            lbPair,
+                            position: newPosition,
+                            lengthToAdd: toAdd,
+                            side: types_1.MeteoraPositionSide.Upper,
+                        });
+                        instructions.push(extendIx);
+                        positionBinsAllocated += toAdd;
+                    }
+                }
+                // === Withdraw from old position ===
+                if (i < oldChunks.length) {
+                    const chunk = oldChunks[i];
+                    const isLastOldChunk = (i === oldChunks.length - 1);
+                    const removeLiquidityIx = yield this.ix.meteoraDlmm.removeLiquidityByRange2Automation({
+                        connection,
+                        userWallet,
+                        lbPair,
+                        position: oldPosition,
+                        tokenXMint,
+                        tokenYMint,
+                        tokenXProgram,
+                        tokenYProgram,
+                        fromBinId: chunk.lower,
+                        toBinId: chunk.upper,
+                        bpsToRemove: 10000, // 100%
+                        pdaTokenType: types_1.TokenType.ATA,
+                        remainingAccountsInfo,
+                    });
+                    instructions.push(removeLiquidityIx);
+                    const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2Automation(connection, {
+                        userWallet,
+                        lbPair,
+                        position: oldPosition,
+                        tokenMintX: tokenXMint,
+                        tokenMintY: tokenYMint,
+                        tokenProgramX: tokenXProgram,
+                        tokenProgramY: tokenYProgram,
+                        lowerBinId: chunk.lower,
+                        upperBinId: chunk.upper,
+                        pdaTokenType: pdaTokenTypeForClaimables,
+                        remainingAccountsInfo,
+                    });
+                    instructions.push(claimFeeIx);
+                    for (const reward of rewardIxBuilders) {
+                        const claimRewardIx = yield this.ix.meteoraDlmm.claimReward2Automation(connection, {
+                            userWallet,
+                            lbPair,
+                            position: oldPosition,
+                            rewardIndex: reward.rewardIndex,
+                            rewardMint: reward.rewardMint,
+                            rewardVault: reward.rewardVault,
+                            tokenProgram: reward.rewardTokenProgram,
+                            lowerBinId: chunk.lower,
+                            upperBinId: chunk.upper,
+                            pdaTokenType: types_1.TokenType.STA,
+                            remainingAccountsInfo: reward.rewardRemainingAccountsInfo,
+                        });
+                        instructions.push(claimRewardIx);
+                    }
+                    if (isLastOldChunk) {
+                        const closePositionIx = yield this.ix.meteoraDlmm.closePosition2Automation({
+                            connection,
+                            userWallet,
+                            position: oldPosition,
+                            lbPair,
+                        });
+                        instructions.push(closePositionIx);
+                    }
+                }
+                // === Deposit to new position ===
+                if (i < depositChunks.length) {
+                    const chunk = depositChunks[i];
+                    const onChainParams = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunk.params.x0, chunk.params.y0, chunk.params.deltaX, chunk.params.deltaY);
+                    const initBinArraysIx = yield this.ix.meteoraDlmm.meteoraDlmmInitializeBinArray({
+                        connection,
+                        userWallet,
+                        lbPair,
+                        lowerBinId: chunk.lowerBinId,
+                        upperBinId: chunk.upperBinId,
+                    });
+                    instructions.push(initBinArraysIx);
+                    const depositIx = yield this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
+                        connection,
+                        userWallet,
+                        position: newPosition,
+                        lbPair,
+                        tokenXMint,
+                        tokenYMint,
+                        tokenXProgram,
+                        tokenYProgram,
+                        activeId,
+                        pdaTokenType: types_1.TokenType.ATA,
+                        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: [],
+                        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);
+                }
+                txInstructions.push(instructions);
+            }
+            return txInstructions;
+        });
+    }
+    openAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, params.pool, this.ix);
+            const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+            // Open new position
+            const initPositionAndAddLiquidityBuilder = yield dlmmPool.initializePositionAndAddLiquidityByStrategy(connection, params.userWallet, addresses_1.HS_AUTHORITY, {
+                positionPubKey: params.position,
+                user: userPda,
+                slippage: params.slippage,
+                totalXAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                totalYAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                strategy: {
+                    maxBinId: params.binRange.upperRange,
+                    minBinId: params.binRange.lowerRange,
+                    strategyType: types_3.StrategyTypeMap[params.distribution],
+                },
+                skipInputTokenCheck: true, // Rebalance should be independent of user wallet TA
+                opt: {
+                    pdaTokenType: params.opt.pdaTokenType,
+                    withAmount: {
+                        userTokenXAmount: params.opt.withAmount.userTokenXAmount,
+                        userTokenYAmount: params.opt.withAmount.userTokenYAmount,
+                    },
+                    fuelAccount: params.opt.fuelAccount,
+                },
+            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
+            const mainInstructions = [...initPositionAndAddLiquidityBuilder.mainIxs];
+            return (0, functions_1.createTransactionMeta)({
+                payer: params.userWallet,
+                description: 'Automation IX: Meteora Open instruction (Open position)',
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    relativeOpenAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const { userWallet, pool, position, relativeBinRange, checkRange, distribution, targetActiveBin, fuelAccount, pdaTokenType, userTokenXAmount, userTokenYAmount } = params;
+            const openParams = {
+                userWallet,
+                lbPair: pool,
+                position,
+                relativeLowerBinId: relativeBinRange.lowerRange,
+                relativeUpperBinId: relativeBinRange.upperRange,
+                strategyType: types_3.StrategyTypeMap[distribution],
+                checkRange: {
+                    minBinId: checkRange.lowerRange,
+                    maxBinId: checkRange.upperRange,
+                },
+                targetActiveBin: targetActiveBin !== null && targetActiveBin !== void 0 ? targetActiveBin : undefined,
+                useFuelAccount: fuelAccount !== null && fuelAccount !== void 0 ? fuelAccount : false,
+                pdaTokenType,
+                userTokenXAmount,
+                userTokenYAmount,
+            };
+            const openIx = yield this.ix.meteoraDlmm.relativeOpenAutomation(connection, openParams);
+            return (0, functions_1.createTransactionMeta)({
+                payer: params.userWallet,
+                description: 'Automation IX: Meteora Open with relative bins',
                 addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
                 mainInstructions: [openIx],
             });
@@ -2330,25 +3540,32 @@ 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
+     * Creates a large position with more than 69 bins.
+     * Splits into multiple transactions if needed (max 1344 bins per tx, max 1400 bins total).
      *
      * @param connection - Solana connection
      * @param params - Parameters containing userWallet, lbPair, position, lowerBinId, upperBinId
-     * @returns Array of TransactionInstructions for initializing and extending the position
+     * @returns Array of TransactionMetadataResponse (one per transaction)
      */
-    meteoraInitializeLargePosition(_a) {
+    /**
+     * Build raw instruction arrays for initializing a large Meteora DLMM position.
+     * Returns a 2D array where each inner array is one transaction's worth of instructions.
+     */
+    _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 MAX_BINS_PER_TX = 1344; // Maximum bins that fit in a single transaction
             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`);
+            // Validate bin count (max 1400 supported by Meteora)
+            if (totalBins > 1400) {
+                throw new Error(`Position size ${totalBins} bins exceeds maximum of 1400 bins`);
             }
-            const instructions = [];
+            const txInstructions = [];
+            let instructions = [];
+            let binsInCurrentTx = 0;
             // 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({
@@ -2360,46 +3577,63 @@ class Transactions {
                 width: initWidth,
             });
             instructions.push(initializePositionIx);
+            binsInCurrentTx += initWidth;
             // 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);
+                // Check if adding this extension would exceed max bins per tx
+                if (binsInCurrentTx + binsToAdd > MAX_BINS_PER_TX) {
+                    txInstructions.push(instructions);
+                    instructions = [];
+                    binsInCurrentTx = 0;
+                }
                 const extendIx = yield this.ix.meteoraDlmm.increasePositionLength({
                     connection,
                     userWallet,
                     lbPair,
                     position,
                     lengthToAdd: binsToAdd,
-                    side: types_1.MeteoraPositionSide.Upper, // Extend to the right (upper side)
+                    side: types_1.MeteoraPositionSide.Upper,
                 });
                 instructions.push(extendIx);
+                binsInCurrentTx += binsToAdd;
                 currentUpperBinId += binsToAdd;
             }
-            return (0, functions_1.createTransactionMeta)({
-                payer: params.userWallet,
-                description: 'Initialize large Meteora DLMM Position',
-                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                mainInstructions: instructions,
-            });
+            // Finalize remaining instructions
+            if (instructions.length > 0) {
+                txInstructions.push(instructions);
+            }
+            return txInstructions;
+        });
+    }
+    meteoraInitializeLargePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const txInstructions = yield this._meteoraInitializeLargePosition({ connection, params });
+            const transactions = [];
+            for (const instructions of txInstructions) {
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: 'Initialize large Meteora DLMM Position',
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: instructions,
+                }));
+            }
+            return transactions;
         });
     }
     /**
-     * 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
+     * Build raw instruction arrays for depositing liquidity to a large Meteora DLMM position.
+     * Returns a 2D array where each inner array is one transaction's worth of instructions.
      */
-    meteoraDepositToLargePosition(_a) {
+    _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 { userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, lowerBinId, upperBinId, totalXAmount, totalYAmount, strategyType = liquidityStrategy_1.StrategyType.SPOT, pdaTokenType, } = params;
+            // Auto-determine favorXInActiveId from deposit amounts (matches Meteora SDK behavior):
+            // Single-sided X deposit (Y is zero) → favor X in active bin
+            const favorXInActiveId = totalYAmount.isZero() && !totalXAmount.isZero();
             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);
@@ -2413,7 +3647,7 @@ class Transactions {
             // 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 = [];
+            const txInstructions = [];
             // === TRANSACTION 1: Create LTA accounts and deposit tokens ===
             const depositInstructions = [];
             // Build deposit array for tokens with non-zero amounts
@@ -2456,7 +3690,6 @@ class Transactions {
                 });
                 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,
@@ -2489,14 +3722,213 @@ class Transactions {
                         }],
                 });
                 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})`,
+                txInstructions.push(instructions);
+            }
+            return txInstructions;
+        });
+    }
+    /**
+     * 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, }) {
+            var _b;
+            let lbPair, upperBinId, lowerBinId;
+            if (params.fastGeneration !== undefined) {
+                lbPair = params.fastGeneration.pool;
+                upperBinId = params.fastGeneration.upperBinId;
+                lowerBinId = params.fastGeneration.lowerBinId;
+            }
+            else {
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+                upperBinId = position.upperBinId;
+                lowerBinId = position.lowerBinId;
+            }
+            const totalBins = upperBinId - lowerBinId + 1;
+            // ≤149 bins: single-tx path via meteoraDepositLargerPosition
+            if (totalBins <= 149) {
+                const result = yield this.meteoraDepositLargerPosition({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        lbPair,
+                        position: params.position,
+                        lowerBinId,
+                        upperBinId,
+                        totalXAmount: params.totalXAmount,
+                        totalYAmount: params.totalYAmount,
+                        distribution: params.distribution,
+                        slippage: params.slippage,
+                        skipInputTokenCheck: params.skipInputTokenCheck,
+                        pdaTokenType: params.pdaTokenType,
+                        initializePosition: false,
+                    },
+                    fetch: undefined,
+                });
+                return [result];
+            }
+            // ≥150 bins: multi-tx chunked deposit path
+            // Resolve token mints and programs from lbPair
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+            const lbPairState = dlmmPool.dlmm.lbPair;
+            const tokenXMint = lbPairState.tokenXMint;
+            const tokenYMint = lbPairState.tokenYMint;
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+            const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+            const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+            // Convert Distribution to liquidityStrategy.StrategyType
+            const distributionToStrategyType = {
+                'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
+                'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
+                'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
+            };
+            const strategyType = (_b = distributionToStrategyType[params.distribution]) !== null && _b !== void 0 ? _b : liquidityStrategy_1.StrategyType.SPOT;
+            const txInstructions = yield this._meteoraDepositToLargePosition({ connection, params: {
+                    userWallet: params.userWallet,
+                    lbPair,
+                    position: params.position,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
+                    lowerBinId,
+                    upperBinId,
+                    totalXAmount: params.totalXAmount,
+                    totalYAmount: params.totalYAmount,
+                    strategyType,
+                    pdaTokenType: params.pdaTokenType,
+                } });
+            const transactions = [];
+            for (let i = 0; i < txInstructions.length; i++) {
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: `Deposit to large Meteora DLMM Position (chunk ${i + 1}/${txInstructions.length})`,
                     addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                    mainInstructions: instructions,
+                    mainInstructions: txInstructions[i],
+                }));
+            }
+            return transactions;
+        });
+    }
+    /**
+     * Create a position and deposit liquidity for any bin count.
+     *
+     * - For ≤149 bins: delegates to meteoraDepositLargerPosition (single tx with position init)
+     * - For ≥150 bins: uses _meteoraInitializeLargePosition + _meteoraDepositToLargePosition (multi-tx)
+     *   When init produces 2 TXs (>1344 bins), the 2nd init TX is merged into the 1st deposit TX.
+     */
+    meteoraCreatePositionAndDepositToLargePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b;
+            const totalBins = params.binRange.upperRange - params.binRange.lowerRange + 1;
+            // ≤149 bins: single-tx path via meteoraDepositLargerPosition
+            if (totalBins <= 149) {
+                const result = 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,
                 });
-                transactions.push(txMeta);
+                return [result];
+            }
+            // ≥150 bins: multi-tx path
+            // Convert Distribution string to liquidityStrategy.StrategyType number for chunked deposit
+            const distributionToStrategyType = {
+                'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
+                'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
+                'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
+            };
+            const strategyType = (_b = distributionToStrategyType[params.distribution]) !== null && _b !== void 0 ? _b : liquidityStrategy_1.StrategyType.SPOT;
+            // Step 1: Initialize position
+            const initTxs = yield this._meteoraInitializeLargePosition({
+                connection,
+                params: {
+                    userWallet: params.userWallet,
+                    lbPair: params.pool,
+                    position: params.position,
+                    lowerBinId: params.binRange.lowerRange,
+                    upperBinId: params.binRange.upperRange,
+                },
+            });
+            // Step 2: Resolve token mints and programs from lbPair
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, params.pool, this.ix);
+            const lbPairState = dlmmPool.dlmm.lbPair;
+            const tokenXMint = lbPairState.tokenXMint;
+            const tokenYMint = lbPairState.tokenYMint;
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+            const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+            const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+            // Step 3: Build deposit instructions
+            const depositTxs = yield this._meteoraDepositToLargePosition({
+                connection,
+                params: {
+                    userWallet: params.userWallet,
+                    lbPair: params.pool,
+                    position: params.position,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
+                    lowerBinId: params.binRange.lowerRange,
+                    upperBinId: params.binRange.upperRange,
+                    totalXAmount: params.totalXAmount,
+                    totalYAmount: params.totalYAmount,
+                    strategyType,
+                    pdaTokenType: params.pdaTokenType,
+                },
+            });
+            // Step 4: Assemble — merge init's last TX into deposit's first TX if init has >1 TX
+            const assembled = [];
+            if (initTxs.length > 1) {
+                // Add all init TXs except the last
+                for (let i = 0; i < initTxs.length - 1; i++) {
+                    assembled.push(initTxs[i]);
+                }
+                // Merge last init TX into first deposit TX
+                const lastInitTx = initTxs[initTxs.length - 1];
+                const firstDepositTx = depositTxs[0];
+                assembled.push([...lastInitTx, ...firstDepositTx]);
+                // Add remaining deposit TXs
+                for (let i = 1; i < depositTxs.length; i++) {
+                    assembled.push(depositTxs[i]);
+                }
+            }
+            else {
+                // Single init TX — no merge needed
+                assembled.push(initTxs[0]);
+                for (const tx of depositTxs) {
+                    assembled.push(tx);
+                }
+            }
+            // Step 5: Wrap each instruction array with createTransactionMeta
+            const transactions = [];
+            for (let i = 0; i < assembled.length; i++) {
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: `Create position and deposit to large Meteora DLMM Position (tx ${i + 1}/${assembled.length})`,
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: assembled[i],
+                }));
             }
             return transactions;
         });