@hawksightco/hawk-sdk 1.3.236 → 1.3.238

package/dist/src/classes/Transactions.js

@@ -46,6 +46,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.txgen = exports.Transactions = void 0;
+exports.getHybridChunkOffsets = getHybridChunkOffsets;
+exports.batchHybridChunkInstructionGroups = batchHybridChunkInstructionGroups;
 const errors_1 = require("../errors");
 const dlmm_1 = require("@meteora-ag/dlmm");
 const web3 = __importStar(require("@solana/web3.js"));
@@ -70,6 +72,53 @@ const anchor = __importStar(require("@coral-xyz/anchor"));
 const RaydiumIxGenerator_1 = require("../ixGenerator/RaydiumIxGenerator");
 const RaydiumSDK_1 = require("./RaydiumSDK");
 const types_3 = require("../types");
+function getHybridChunkOffsets(positionLowerBinId, chunkLowerBinId, chunkUpperBinId) {
+    return {
+        chunkLowerOffset: chunkLowerBinId - positionLowerBinId,
+        chunkUpperOffset: chunkUpperBinId - positionLowerBinId,
+    };
+}
+function getInstructionDedupKey(ix) {
+    return [
+        ix.programId.toString(),
+        ix.data.toString('base64'),
+        ...ix.keys.map(meta => [
+            meta.pubkey.toString(),
+            meta.isSigner ? '1' : '0',
+            meta.isWritable ? '1' : '0',
+        ].join(':')),
+    ].join('|');
+}
+function dedupeInitBinArrayInstructions(ixs) {
+    const seenInitKeys = new Set();
+    const deduped = [];
+    for (const ix of ixs) {
+        if (ix.label !== 'init_bin_array') {
+            deduped.push(ix);
+            continue;
+        }
+        const dedupKey = getInstructionDedupKey(ix.instruction);
+        if (seenInitKeys.has(dedupKey)) {
+            continue;
+        }
+        seenInitKeys.add(dedupKey);
+        deduped.push(ix);
+    }
+    return deduped;
+}
+function batchHybridChunkInstructionGroups(chunkInstructionGroups, chunksPerTransaction = 2) {
+    if (!Number.isInteger(chunksPerTransaction) || chunksPerTransaction <= 0) {
+        throw new Error('chunksPerTransaction must be a positive integer');
+    }
+    const batchedGroups = [];
+    for (let i = 0; i < chunkInstructionGroups.length; i += chunksPerTransaction) {
+        const mergedGroup = chunkInstructionGroups
+            .slice(i, i + chunksPerTransaction)
+            .flat();
+        batchedGroups.push(dedupeInitBinArrayInstructions(mergedGroup));
+    }
+    return batchedGroups;
+}
 class Transactions {
     /**
      * Prohibit creating instance other than getInstance
@@ -1703,70 +1752,6 @@ class Transactions {
             }
         });
     }
-    /**
-     *
-     * @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,
-                    strategyType: types_3.StrategyTypeMap[params.distribution],
-                },
-                skipInputTokenCheck: true, // Rebalance should be independent of user wallet TA
-            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
-            const mainInstructions = [
-                // Initialize required ATA
-                ...removeLiquidityBuilder.createAtaIxs,
-                // Remove liquidity
-                ...removeLiquidityBuilder.mainIxs,
-                // Re-deposit liquidity
-                ...initPositionAndAddLiquidityBuilder.mainIxs,
-            ];
-            return (0, functions_1.createTransactionMeta)({
-                payer: params.userWallet,
-                description: 'Automation IX: Meteora Auto-rebalance instructions (Close position and deposit to new position)',
-                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                mainInstructions,
-            });
-        });
-    }
     /**
      *
      * @param connection The Solana web3 connection object for blockchain interactions.
@@ -1858,246 +1843,6 @@ class Transactions {
             }
         });
     }
-    /**
-     * Rebalance a Meteora DLMM position with hybrid liquidity support.
-     *
-     * Supports two modes:
-     * - Simple mode: Single distribution (same as rebalanceAutomationIx2)
-     * - Hybrid mode: Multiple liquidity layers with per-side distribution control
-     *
-     * Simple mode (1 TX): Remove + close + init + deposit (same as Ixs2)
-     * Hybrid mode (2 TXs):
-     *   TX1: Remove liquidity + claim fees/rewards + close position
-     *   TX2: Init new position + deposit layer 1 (static amounts) + deposit layer 2 (sweep remaining)
-     */
-    rebalanceAutomationIx3(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
-            var _b, _c;
-            try {
-                // --- Validate and normalize layers ---
-                let layers;
-                if (params.distribution && !params.layers) {
-                    layers = [
-                        {
-                            distribution: params.distribution,
-                            percentageX: 100,
-                            percentageY: 100,
-                        },
-                    ];
-                }
-                else if (params.layers && !params.distribution) {
-                    layers = params.layers;
-                }
-                else {
-                    throw new Error('Provide either distribution or layers, not both');
-                }
-                if (layers.length === 0 || layers.length > 3) {
-                    throw new Error('layers must have 1-3 entries');
-                }
-                const sumX = layers.reduce((s, l) => s + l.percentageX, 0);
-                const sumY = layers.reduce((s, l) => s + l.percentageY, 0);
-                if (sumX !== 100 || sumY !== 100) {
-                    throw new Error(`Layer percentages must sum to 100 per side (got X=${sumX}, Y=${sumY})`);
-                }
-                // --- Build labeled instructions ---
-                const program = yield meteora_1.MeteoraDLMM.program(connection);
-                const positionOnChain = yield program.account.positionV2.fetch(params.currentPosition);
-                const lbPair = positionOnChain.lbPair;
-                const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
-                const userPda = (0, functions_1.generateUserPda)(params.userWallet);
-                // Get position data for amount estimates and bin range
-                const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
-                const userPosition = userPositions.find(p => p.publicKey.equals(params.currentPosition));
-                if (!userPosition) {
-                    throw new Error(`Position: ${params.currentPosition} does not exist.`);
-                }
-                const currentLowerBinId = userPosition.positionData.lowerBinId;
-                const currentUpperBinId = userPosition.positionData.upperBinId;
-                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 pdaTokenTypeForClaimables = params.useAta
-                    ? types_1.TokenType.ATA
-                    : types_1.TokenType.STA;
-                // Estimate total X/Y from position data (liquidity + fees)
-                const estimatedTotalX = new bn_js_1.default(userPosition.positionData.totalXAmount).add(userPosition.positionData.feeX);
-                const estimatedTotalY = new bn_js_1.default(userPosition.positionData.totalYAmount).add(userPosition.positionData.feeY);
-                const instructions = [];
-                const labels = [];
-                const removeLiquidityIx = yield this.ix.meteoraDlmm.removeLiquidityByRange2Automation({
-                    connection,
-                    userWallet: params.userWallet,
-                    lbPair,
-                    position: params.currentPosition,
-                    tokenXMint,
-                    tokenYMint,
-                    tokenXProgram,
-                    tokenYProgram,
-                    fromBinId: currentLowerBinId,
-                    toBinId: currentUpperBinId,
-                    bpsToRemove: 10000,
-                    pdaTokenType: types_1.TokenType.ATA,
-                    remainingAccountsInfo,
-                });
-                instructions.push(removeLiquidityIx);
-                labels.push('remove');
-                const claimFeeIx = yield this.ix.meteoraDlmm.claimFee2Automation(connection, {
-                    userWallet: params.userWallet,
-                    lbPair,
-                    position: params.currentPosition,
-                    tokenMintX: tokenXMint,
-                    tokenMintY: tokenYMint,
-                    tokenProgramX: tokenXProgram,
-                    tokenProgramY: tokenYProgram,
-                    lowerBinId: currentLowerBinId,
-                    upperBinId: currentUpperBinId,
-                    pdaTokenType: pdaTokenTypeForClaimables,
-                    remainingAccountsInfo,
-                });
-                instructions.push(claimFeeIx);
-                labels.push('claim_fee');
-                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);
-                    const claimRewardIx = yield this.ix.meteoraDlmm.claimReward2Automation(connection, {
-                        userWallet: params.userWallet,
-                        lbPair,
-                        position: params.currentPosition,
-                        rewardIndex,
-                        rewardMint: rewardInfo.mint,
-                        rewardVault: rewardInfo.vault,
-                        tokenProgram: rewardTokenProgram,
-                        lowerBinId: currentLowerBinId,
-                        upperBinId: currentUpperBinId,
-                        pdaTokenType: types_1.TokenType.STA,
-                        remainingAccountsInfo: rewardRemainingAccountsInfo,
-                    });
-                    instructions.push(claimRewardIx);
-                    labels.push('claim_reward');
-                }
-                const closePositionIx = yield this.ix.meteoraDlmm.closePosition2Automation({
-                    connection,
-                    userWallet: params.userWallet,
-                    position: params.currentPosition,
-                    lbPair,
-                });
-                instructions.push(closePositionIx);
-                labels.push('close');
-                // Find the last layer index that has non-zero percentage for X and Y
-                let lastActiveXIndex = -1;
-                let lastActiveYIndex = -1;
-                for (let i = layers.length - 1; i >= 0; i--) {
-                    if (lastActiveXIndex === -1 && layers[i].percentageX > 0)
-                        lastActiveXIndex = i;
-                    if (lastActiveYIndex === -1 && layers[i].percentageY > 0)
-                        lastActiveYIndex = i;
-                }
-                // Helper to compute optional amounts for a layer
-                const computeAmounts = (layer, i) => {
-                    let optionalTokenXAmount;
-                    let optionalTokenYAmount;
-                    if (layer.percentageX === 0) {
-                        optionalTokenXAmount = new bn_js_1.default(0);
-                    }
-                    else if (i === lastActiveXIndex) {
-                        optionalTokenXAmount = undefined; // sweep remaining
-                    }
-                    else {
-                        optionalTokenXAmount = estimatedTotalX
-                            .mul(new bn_js_1.default(layer.percentageX))
-                            .div(new bn_js_1.default(100));
-                    }
-                    if (layer.percentageY === 0) {
-                        optionalTokenYAmount = new bn_js_1.default(0);
-                    }
-                    else if (i === lastActiveYIndex) {
-                        optionalTokenYAmount = undefined; // sweep remaining
-                    }
-                    else {
-                        optionalTokenYAmount = estimatedTotalY
-                            .mul(new bn_js_1.default(layer.percentageY))
-                            .div(new bn_js_1.default(100));
-                    }
-                    return { optionalTokenXAmount, optionalTokenYAmount };
-                };
-                // Layer 0: init position + first deposit via relativeOpenAutomation
-                const firstLayer = layers[0];
-                const firstAmounts = computeAmounts(firstLayer, 0);
-                const firstStrategyType = types_3.StrategyTypeMap[firstLayer.distribution];
-                const initAndDepositIx = yield this.ix.meteoraDlmm.relativeOpenAutomation(connection, {
-                    userWallet: params.userWallet,
-                    lbPair,
-                    position: params.newPosition,
-                    relativeLowerBinId: params.relativeBinRange.lowerRange,
-                    relativeUpperBinId: params.relativeBinRange.upperRange,
-                    strategyType: firstStrategyType,
-                    checkRange: {
-                        minBinId: params.checkRange.lowerRange,
-                        maxBinId: params.checkRange.upperRange,
-                    },
-                    targetActiveBin: (_b = params.targetActiveBin) !== null && _b !== void 0 ? _b : undefined,
-                    userTokenXAmount: firstAmounts.optionalTokenXAmount,
-                    userTokenYAmount: firstAmounts.optionalTokenYAmount,
-                    pdaTokenType: types_1.TokenType.ATA,
-                });
-                instructions.push(initAndDepositIx);
-                labels.push('init');
-                // Layers 1+ : deposit-only via addLiquidityByStrategy2Automation
-                const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
-                const effectiveActiveId = (_c = params.targetActiveBin) !== null && _c !== void 0 ? _c : activeId;
-                const absLower = effectiveActiveId + params.relativeBinRange.lowerRange;
-                const absUpper = effectiveActiveId + params.relativeBinRange.upperRange;
-                for (let i = 1; i < layers.length; i++) {
-                    const layer = layers[i];
-                    const { optionalTokenXAmount, optionalTokenYAmount } = computeAmounts(layer, i);
-                    const strategyType = types_3.StrategyTypeMap[layer.distribution];
-                    const depositIx = yield this.ix.meteoraDlmm.addLiquidityByStrategy2Automation(connection, {
-                        userWallet: params.userWallet,
-                        lbPair,
-                        position: params.newPosition,
-                        tokenXMint,
-                        tokenYMint,
-                        tokenXProgram,
-                        tokenYProgram,
-                        activeId: effectiveActiveId,
-                        maxActiveBinSlippage: 0,
-                        strategyParametersMinBinId: absLower,
-                        strategyParametersMaxBinId: absUpper,
-                        strategyParametersStrategyType: strategyType,
-                        strategyParametersParameters: new Array(64).fill(0),
-                        userTokenXAmount: optionalTokenXAmount,
-                        userTokenYAmount: optionalTokenYAmount,
-                        remainingAccountsInfo,
-                        pdaTokenType: types_1.TokenType.ATA,
-                    });
-                    instructions.push(depositIx);
-                    labels.push('deposit');
-                }
-                return { instructions, labels };
-            }
-            catch (error) {
-                console.error('=== REBALANCE AUTOMATION IX3 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;
-            }
-        });
-    }
     rebalanceSmallPositionAutomation(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             // Current theoretical limit (149-bin)
@@ -2841,98 +2586,6 @@ class Transactions {
             }
         });
     }
-    /**
-     * 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: 0,
-                        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'],
-            };
-        });
-    }
     /**
      * Compute claimable fees for a position directly from on-chain account data.
      * Avoids expensive getPositionsByUserAndLbPair by parsing raw buffers.
@@ -4437,16 +4090,21 @@ class Transactions {
             }
             for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
                 const chunk = chunks[chunkIndex];
-                const mergedLayer = chunk.layers.reduce((acc, l) => ({
-                    x0: acc.x0.add(l.params.x0),
-                    y0: acc.y0.add(l.params.y0),
-                    deltaX: acc.deltaX.add(l.params.deltaX),
-                    deltaY: acc.deltaY.add(l.params.deltaY),
-                }), { x0: new bn_js_1.default(0), y0: new bn_js_1.default(0), deltaX: new bn_js_1.default(0), deltaY: new bn_js_1.default(0) });
-                const onChainParams = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(mergedLayer.x0, mergedLayer.y0, mergedLayer.deltaX, mergedLayer.deltaY);
-                const mergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), chunk.minDeltaId, chunk.maxDeltaId, mergedLayer.deltaX, mergedLayer.deltaY, mergedLayer.x0, mergedLayer.y0, binStep, favorXInActiveId);
-                const chunkMaxX = mergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                const chunkMaxY = mergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
+                const chunkAddLiquidityParams = chunk.layers.map(layer => {
+                    const onChainParams = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(layer.params.x0, layer.params.y0, layer.params.deltaX, layer.params.deltaY);
+                    return {
+                        minDeltaId: chunk.minDeltaId.toNumber(),
+                        maxDeltaId: chunk.maxDeltaId.toNumber(),
+                        x0: onChainParams.x0,
+                        y0: onChainParams.y0,
+                        deltaX: onChainParams.deltaX,
+                        deltaY: onChainParams.deltaY,
+                        bitFlag: onChainParams.bitFlag,
+                        favorXInActiveId,
+                    };
+                });
+                const chunkMaxX = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountX), new bn_js_1.default(0));
+                const chunkMaxY = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountY), new bn_js_1.default(0));
                 const instructions = [];
                 if (!depositIncluded) {
                     depositIncluded = true;
@@ -4482,18 +4140,7 @@ class Transactions {
                     minWithdrawYAmount: new bn_js_1.default(0),
                     maxDepositYAmount: chunkMaxY,
                     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,
-                        },
-                    ],
+                    addLiquidityParams: chunkAddLiquidityParams,
                 });
                 instructions.push({
                     instruction: depositIx,
@@ -4823,7 +4470,7 @@ class Transactions {
                                 };
                             return {
                                 instruction: ix,
-                                label: 'Add liquidity by strategy (meteora deposit)'
+                                label: 'Add liquidity by strategy (meteora deposit)',
                             };
                         }),
                     ];
@@ -6404,23 +6051,15 @@ class Transactions {
             });
         });
     }
-    /**
-     * Hybrid liquidity rebalance for automation: teardown old position and rebuild
-     * with independent X/Y distributions per layer using rebalanceLiquidityAutomation.
-     *
-     * Supports all position sizes (≤70, 71-149, ≥150 bins).
-     * All hybrid layers are passed as multiple addLiquidityParams entries in a single
-     * rebalanceLiquidityAutomation call per chunk (rather than one call per layer).
-     */
-    meteoraRebalanceHybridLiquidityAutomation(_a) {
+    meteoraRebalanceHybridLiquidityV2Automation(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             var _b, _c;
             try {
                 const MAX_INIT_WIDTH = 70;
                 const MAX_EXTEND_LENGTH = 91;
-                const MAX_BINS_PER_WITHDRAW_CHUNK = 149;
-                const MAX_BINS_PER_DEPOSIT_CHUNK = 149;
-                const CLASS = 'meteoraRebalanceHybridLiquidityAutomation';
+                const MAX_BINS_PER_WITHDRAW_CHUNK = 175;
+                const CHUNKS_PER_TRANSACTION = 3;
+                const CLASS = 'meteoraRebalanceHybridLiquidityV2Automation';
                 // --- Validate layers ---
                 const layers = params.layers;
                 if (layers.length === 0 || layers.length > 3) {
@@ -6431,14 +6070,13 @@ class Transactions {
                 if (sumX !== 100 || sumY !== 100) {
                     throw new Error(`Layer percentages must sum to 100 per side (got X=${sumX}, Y=${sumY})`);
                 }
-                const { lbPair, lbPairState, dlmmPool, lowerBinId: currentLowerBinId, upperBinId: currentUpperBinId, estimatedTotalX, estimatedTotalY, activeId, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, withdrawFn, depositFn, } = yield this.resolvePositionContext({
+                const { lbPair, lbPairState, dlmmPool, lowerBinId: currentLowerBinId, upperBinId: currentUpperBinId, estimatedTotalX, estimatedTotalY, activeId, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, withdrawFn, baseRemainingAccountsInfo, } = yield this.resolvePositionContext({
                     connection,
                     userWallet: params.userWallet,
                     position: params.currentPosition,
                     compound: params.compound,
                     targetActiveBin: params.targetActiveBin,
                 });
-                // checkRange validation
                 if (activeId < params.checkRange.lowerRange ||
                     activeId > params.checkRange.upperRange) {
                     throw new Error(`Active bin ${activeId} outside checkRange [${params.checkRange.lowerRange}, ${params.checkRange.upperRange}]`);
@@ -6447,13 +6085,13 @@ class Transactions {
                 const newUpperBinId = activeId + params.relativeBinRange.upperRange;
                 const newWidth = newUpperBinId - newLowerBinId + 1;
                 const currentWidth = currentUpperBinId - currentLowerBinId + 1;
-                const binStep = new bn_js_1.default(lbPairState.binStep);
+                const maxBinsPerDepositChunk = newWidth === 69 ? 69 : 50;
+                const useLayeredDepositsForSmallPosition = newWidth <= 69 && layers.length > 1;
                 // =========================================================================
                 // PHASE 1: TEARDOWN (withdraw from old position + close)
                 // =========================================================================
                 const teardownTxGroups = [];
                 if (currentWidth <= MAX_BINS_PER_WITHDRAW_CHUNK) {
-                    // Small/medium: single withdraw TX
                     teardownTxGroups.push([
                         ...(yield withdrawFn({
                             position: params.currentPosition,
@@ -6475,7 +6113,6 @@ class Transactions {
                     ]);
                 }
                 else {
-                    // Large: chunked withdrawal
                     const withdrawChunks = (0, liquidityStrategy_1.chunkBinRange)(currentLowerBinId, currentUpperBinId, MAX_BINS_PER_WITHDRAW_CHUNK);
                     for (let i = 0; i < withdrawChunks.length; i++) {
                         const chunk = withdrawChunks[i];
@@ -6505,23 +6142,20 @@ class Transactions {
                     }
                 }
                 // =========================================================================
-                // PHASE 2: REBUILD (init + extend + deposit with hybrid layers)
+                // PHASE 2: REBUILD (init + extend + deposit with NEW add_liquidity_2 instruction)
                 // =========================================================================
                 const effectiveAmountX = (_b = params.amountXOverride) !== null && _b !== void 0 ? _b : estimatedTotalX;
                 const effectiveAmountY = (_c = params.amountYOverride) !== null && _c !== void 0 ? _c : estimatedTotalY;
                 const favorXInActiveId = effectiveAmountY.isZero() && !effectiveAmountX.isZero();
                 const minDeltaId = newLowerBinId - activeId;
                 const maxDeltaId = newUpperBinId - activeId;
-                // Compute hybrid strategy for the full new range
-                const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
-                    hybridDistribution: layers,
-                    amountX: effectiveAmountX,
-                    amountY: effectiveAmountY,
-                    minDeltaId: new bn_js_1.default(minDeltaId),
-                    maxDeltaId: new bn_js_1.default(maxDeltaId),
-                    binStep,
-                    activeId: new bn_js_1.default(activeId),
-                });
+                const binStep = new bn_js_1.default(lbPairState.binStep);
+                const contractLayers = layers.map(l => ({
+                    strategyTypeX: (0, liquidityStrategy_1.distributionToStrategyType)(l.x.distribution),
+                    strategyTypeY: (0, liquidityStrategy_1.distributionToStrategyType)(l.y.distribution),
+                    percentageX: l.x.percentage,
+                    percentageY: l.y.percentage,
+                }));
                 // Build init + extend instructions
                 const initExtendIxs = [];
                 const initWidth = Math.min(MAX_INIT_WIDTH, newWidth);
@@ -6553,158 +6187,151 @@ class Transactions {
                     });
                     positionBinsAllocated += toAdd;
                 }
-                // Build deposit TX group(s)
                 const rebuildTxGroups = [];
-                if (newWidth <= MAX_BINS_PER_DEPOSIT_CHUNK) {
-                    // Small/medium: all layers in one rebalanceLiquidity call.
-                    // Split into two TXs when extension is needed (newWidth > MAX_INIT_WIDTH) to
-                    // avoid exceeding the TX size limit with init + extend + binArrayInits + deposit.
-                    //
-                    // Merge all layers into a single AddLiquidityParams entry by summing x0/y0/deltaX/deltaY.
-                    // Meteora's rebalanceLiquidity requires non-overlapping ranges across entries; since all
-                    // layers share the same full range, they must be merged into one. The formula is linear
-                    // so summing params is equivalent to summing per-bin amounts from each layer.
-                    const mergedLayer = strategyResults.reduce((acc, l) => ({
-                        x0: acc.x0.add(l.x0),
-                        y0: acc.y0.add(l.y0),
-                        deltaX: acc.deltaX.add(l.deltaX),
-                        deltaY: acc.deltaY.add(l.deltaY),
-                    }), {
-                        x0: new bn_js_1.default(0),
-                        y0: new bn_js_1.default(0),
-                        deltaX: new bn_js_1.default(0),
-                        deltaY: new bn_js_1.default(0),
-                    });
-                    const mergedP = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(mergedLayer.x0, mergedLayer.y0, mergedLayer.deltaX, mergedLayer.deltaY);
-                    const allAddLiquidityParams = [
-                        {
-                            minDeltaId,
-                            maxDeltaId,
-                            x0: mergedP.x0,
-                            y0: mergedP.y0,
-                            deltaX: mergedP.deltaX,
-                            deltaY: mergedP.deltaY,
-                            bitFlag: mergedP.bitFlag,
-                            favorXInActiveId,
-                        },
-                    ];
-                    const mergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), mergedLayer.deltaX, mergedLayer.deltaY, mergedLayer.x0, mergedLayer.y0, binStep, favorXInActiveId);
-                    const totalMaxX = mergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                    const totalMaxY = mergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
+                if (newWidth <= maxBinsPerDepositChunk) {
                     const binArrayInitIxs = yield this._initBinArraysForRange(connection, lbPair, dlmmPool, newLowerBinId, newUpperBinId);
                     const binArrayInitIxsLabeled = binArrayInitIxs.map(ix => ({
                         label: 'init_bin_array',
                         class: CLASS,
                         instruction: ix,
                     }));
-                    const depositIx = yield depositFn({
-                        position: params.newPosition,
-                        shouldClaimFee: false,
-                        shouldClaimReward: false,
-                        maxDepositXAmount: totalMaxX,
-                        maxDepositYAmount: totalMaxY,
-                        pdaTokenType: types_1.TokenType.ATA,
-                        addLiquidityParams: allAddLiquidityParams,
-                        origin: CLASS,
-                    });
-                    if (newWidth <= MAX_INIT_WIDTH) {
-                        // ≤70 bins: no extension needed, everything fits in one TX
-                        rebuildTxGroups.push([
-                            ...initExtendIxs,
+                    if (useLayeredDepositsForSmallPosition) {
+                        const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                            hybridDistribution: layers,
+                            amountX: effectiveAmountX,
+                            amountY: effectiveAmountY,
+                            minDeltaId: new bn_js_1.default(minDeltaId),
+                            maxDeltaId: new bn_js_1.default(maxDeltaId),
+                            binStep,
+                            activeId: new bn_js_1.default(activeId),
+                        });
+                        rebuildTxGroups.push(initExtendIxs);
+                        const layeredDepositIxs = [
                             ...binArrayInitIxsLabeled,
-                            depositIx,
-                        ]);
+                        ];
+                        for (let i = 0; i < strategyResults.length; i++) {
+                            const layerStrategy = strategyResults[i];
+                            if (layerStrategy.maxAmountX.isZero() && layerStrategy.maxAmountY.isZero()) {
+                                continue;
+                            }
+                            const singleLayer = {
+                                strategyTypeX: contractLayers[i].strategyTypeX,
+                                strategyTypeY: contractLayers[i].strategyTypeY,
+                                percentageX: layers[i].x.percentage > 0 ? 100 : 0,
+                                percentageY: layers[i].y.percentage > 0 ? 100 : 0,
+                            };
+                            const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                                connection,
+                                userWallet: params.userWallet,
+                                lbPair,
+                                position: params.newPosition,
+                                tokenXMint,
+                                tokenYMint,
+                                tokenXProgram,
+                                tokenYProgram,
+                                layers: [singleLayer],
+                                checkRange: params.checkRange,
+                                userTokenXAmount: layerStrategy.maxAmountX,
+                                userTokenYAmount: layerStrategy.maxAmountY,
+                                remainingAccountsInfo: baseRemainingAccountsInfo,
+                                pdaTokenType: types_1.TokenType.ATA,
+                                lowerBinId: newLowerBinId,
+                                upperBinId: newUpperBinId,
+                            });
+                            layeredDepositIxs.push({ label: 'deposit_v2', class: CLASS, instruction: depositIx });
+                        }
+                        if (layeredDepositIxs.length > 0) {
+                            rebuildTxGroups.push(layeredDepositIxs);
+                        }
                     }
                     else {
-                        // 71-149 bins: extension needed, split init+extend from deposit to stay within TX size limit
-                        rebuildTxGroups.push(initExtendIxs);
-                        rebuildTxGroups.push([...binArrayInitIxsLabeled, depositIx]);
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.newPosition,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            checkRange: params.checkRange,
+                            userTokenXAmount: effectiveAmountX,
+                            userTokenYAmount: effectiveAmountY,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            lowerBinId: newLowerBinId,
+                            upperBinId: newUpperBinId,
+                        });
+                        if (newWidth <= MAX_INIT_WIDTH) {
+                            rebuildTxGroups.push([
+                                ...initExtendIxs,
+                                ...binArrayInitIxsLabeled,
+                                { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                            ]);
+                        }
+                        else {
+                            rebuildTxGroups.push(initExtendIxs);
+                            rebuildTxGroups.push([
+                                ...binArrayInitIxsLabeled,
+                                { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                            ]);
+                        }
                     }
                 }
                 else {
-                    // Large: init+extend in first TX, then one TX per deposit chunk
                     rebuildTxGroups.push(initExtendIxs);
-                    const depositChunks = (0, liquidityStrategy_1.chunkHybridDepositParameters)(strategyResults, new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), new bn_js_1.default(activeId), binStep, MAX_BINS_PER_DEPOSIT_CHUNK, favorXInActiveId);
+                    const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                        hybridDistribution: layers,
+                        amountX: effectiveAmountX,
+                        amountY: effectiveAmountY,
+                        minDeltaId: new bn_js_1.default(minDeltaId),
+                        maxDeltaId: new bn_js_1.default(maxDeltaId),
+                        binStep,
+                        activeId: new bn_js_1.default(activeId),
+                    });
+                    const depositChunks = (0, liquidityStrategy_1.chunkHybridDepositParameters)(strategyResults, new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), new bn_js_1.default(activeId), binStep, maxBinsPerDepositChunk, favorXInActiveId);
+                    const chunkInstructionGroups = [];
                     for (const chunk of depositChunks) {
-                        // Merge all layers into a single AddLiquidityParams entry per chunk (see comment above).
-                        const chunkMergedLayer = chunk.layers.reduce((acc, l) => ({
-                            x0: acc.x0.add(l.params.x0),
-                            y0: acc.y0.add(l.params.y0),
-                            deltaX: acc.deltaX.add(l.params.deltaX),
-                            deltaY: acc.deltaY.add(l.params.deltaY),
-                        }), {
-                            x0: new bn_js_1.default(0),
-                            y0: new bn_js_1.default(0),
-                            deltaX: new bn_js_1.default(0),
-                            deltaY: new bn_js_1.default(0),
-                        });
-                        const chunkMergedP = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunkMergedLayer.x0, chunkMergedLayer.y0, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY);
-                        const chunkAddLiquidityParams = [
-                            {
-                                minDeltaId: chunk.minDeltaId.toNumber(),
-                                maxDeltaId: chunk.maxDeltaId.toNumber(),
-                                x0: chunkMergedP.x0,
-                                y0: chunkMergedP.y0,
-                                deltaX: chunkMergedP.deltaX,
-                                deltaY: chunkMergedP.deltaY,
-                                bitFlag: chunkMergedP.bitFlag,
-                                favorXInActiveId,
-                            },
-                        ];
-                        const chunkMergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), chunk.minDeltaId, chunk.maxDeltaId, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY, chunkMergedLayer.x0, chunkMergedLayer.y0, binStep, favorXInActiveId);
-                        const chunkTotalMaxX = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                        const chunkTotalMaxY = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
+                        const { chunkLowerOffset, chunkUpperOffset } = getHybridChunkOffsets(newLowerBinId, chunk.lowerBinId, chunk.upperBinId);
+                        const chunkAmountX = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountX), new bn_js_1.default(0));
+                        const chunkAmountY = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountY), new bn_js_1.default(0));
+                        if (chunkAmountX.isZero() && chunkAmountY.isZero()) {
+                            continue;
+                        }
                         const binArrayInitIxs = yield this._initBinArraysForRange(connection, lbPair, dlmmPool, chunk.lowerBinId, chunk.upperBinId);
-                        rebuildTxGroups.push([
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.newPosition,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            checkRange: params.checkRange,
+                            userTokenXAmount: chunkAmountX,
+                            userTokenYAmount: chunkAmountY,
+                            chunkLowerOffset,
+                            chunkUpperOffset,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            lowerBinId: chunk.lowerBinId,
+                            upperBinId: chunk.upperBinId,
+                        });
+                        chunkInstructionGroups.push([
                             ...binArrayInitIxs.map(ix => ({
                                 label: 'init_bin_array',
                                 class: CLASS,
                                 instruction: ix,
                             })),
-                            yield depositFn({
-                                position: params.newPosition,
-                                shouldClaimFee: false,
-                                shouldClaimReward: false,
-                                maxDepositXAmount: chunkTotalMaxX,
-                                maxDepositYAmount: chunkTotalMaxY,
-                                pdaTokenType: types_1.TokenType.ATA,
-                                addLiquidityParams: chunkAddLiquidityParams,
-                                origin: CLASS,
-                            }),
+                            { label: 'deposit_v2', class: CLASS, instruction: depositIx },
                         ]);
                     }
+                    rebuildTxGroups.push(...batchHybridChunkInstructionGroups(chunkInstructionGroups, CHUNKS_PER_TRANSACTION));
                 }
                 // =========================================================================
-                // PHASE 3: SWEEP REMAINING DUST
-                // =========================================================================
-                // After the main hybrid deposit, add one final deposit with undefined amounts
-                // so the on-chain instruction reads the actual ATA balance and sweeps any dust.
-                // Uses Spot distribution. Bin range follows the position's range (preserving
-                // directional bias), clamped to 70 bins max (Meteora's single-call limit).
-                const { sweepLower, sweepUpper } = this._calculateSweepBinRange(params.relativeBinRange.lowerRange, params.relativeBinRange.upperRange);
-                const sweepIx = yield this.ix.meteoraDlmm.meteoraDlmmDepositRelativeAutomation({
-                    connection,
-                    userWallet: params.userWallet,
-                    lbPair,
-                    position: params.newPosition,
-                    tokenXMint,
-                    tokenYMint,
-                    tokenXProgram,
-                    tokenYProgram,
-                    activeId,
-                    relativeBinRange: { lowerRange: sweepLower, upperRange: sweepUpper },
-                    strategyType: 6, // SpotImBalanced — handles any X/Y ratio including single-sided
-                    optionalTokenXAmount: undefined, // sweep — use full ATA balance
-                    optionalTokenYAmount: undefined, // sweep — use full ATA balance
-                    checkRange: params.checkRange,
-                    pdaTokenType: types_1.TokenType.ATA,
-                });
-                rebuildTxGroups.push([{
-                        label: 'sweep_dust',
-                        class: CLASS,
-                        instruction: sweepIx,
-                    }]);
-                // =========================================================================
                 // Assemble final TX list
                 // =========================================================================
                 const allTxGroups = [...teardownTxGroups, ...rebuildTxGroups];
@@ -6719,7 +6346,7 @@ class Transactions {
                 return transactions;
             }
             catch (error) {
-                console.error('=== REBALANCE HYBRID LIQUIDITY AUTOMATION ERROR ===');
+                console.error('=== REBALANCE HYBRID LIQUIDITY V2 AUTOMATION ERROR ===');
                 console.error('Error:', error instanceof Error ? error.message : String(error));
                 console.error('Stack:', error instanceof Error ? error.stack : 'No stack trace');
                 console.error('=== END ERROR LOG ===');
@@ -6727,20 +6354,13 @@ class Transactions {
             }
         });
     }
-    /**
-     * Hybrid liquidity redeposit for automation: withdraw all liquidity from the same
-     * position and re-deposit with independent X/Y distributions per layer.
-     *
-     * Unlike rebalance, the position is NOT closed or moved — the same bin range is reused.
-     * Supports all position sizes (≤70, 71-149, ≥150 bins).
-     */
-    meteoraRedepositHybridLiquidityAutomation(_a) {
+    meteoraRedepositHybridLiquidityV2Automation(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             var _b, _c;
             try {
-                const MAX_BINS_PER_WITHDRAW_CHUNK = 149;
-                const MAX_BINS_PER_DEPOSIT_CHUNK = 149;
-                const CLASS = 'meteoraRedepositHybridLiquidityAutomation';
+                const MAX_BINS_PER_WITHDRAW_CHUNK = 150;
+                const CHUNKS_PER_TRANSACTION = 3;
+                const CLASS = 'meteoraRedepositHybridLiquidityV2Automation';
                 // --- Validate layers ---
                 const layers = params.layers;
                 if (layers.length === 0 || layers.length > 3) {
@@ -6751,7 +6371,7 @@ class Transactions {
                 if (sumX !== 100 || sumY !== 100) {
                     throw new Error(`Layer percentages must sum to 100 per side (got X=${sumX}, Y=${sumY})`);
                 }
-                const { lbPair, lbPairState, lowerBinId, upperBinId, estimatedTotalX, estimatedTotalY, activeId, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, withdrawFn, depositFn, } = yield this.resolvePositionContext({
+                const { lbPair, lbPairState, dlmmPool, lowerBinId, upperBinId, estimatedTotalX, estimatedTotalY, activeId, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, withdrawFn, baseRemainingAccountsInfo, } = yield this.resolvePositionContext({
                     connection,
                     userWallet: params.userWallet,
                     position: params.position,
@@ -6760,12 +6380,20 @@ class Transactions {
                     skipClaim: true,
                 });
                 const positionWidth = upperBinId - lowerBinId + 1;
-                const binStep = new bn_js_1.default(lbPairState.binStep);
+                const maxBinsPerDepositChunk = positionWidth === 69 ? 69 : 45;
+                const useLayeredDepositsForSmallPosition = positionWidth <= 69 && layers.length > 1;
                 const effectiveAmountX = (_b = params.amountXOverride) !== null && _b !== void 0 ? _b : estimatedTotalX;
                 const effectiveAmountY = (_c = params.amountYOverride) !== null && _c !== void 0 ? _c : estimatedTotalY;
                 const favorXInActiveId = effectiveAmountY.isZero() && !effectiveAmountX.isZero();
                 const minDeltaId = lowerBinId - activeId;
                 const maxDeltaId = upperBinId - activeId;
+                const binStep = new bn_js_1.default(lbPairState.binStep);
+                const contractLayers = layers.map(l => ({
+                    strategyTypeX: (0, liquidityStrategy_1.distributionToStrategyType)(l.x.distribution),
+                    strategyTypeY: (0, liquidityStrategy_1.distributionToStrategyType)(l.y.distribution),
+                    percentageX: l.x.percentage,
+                    percentageY: l.y.percentage,
+                }));
                 // =========================================================================
                 // PHASE 1: WITHDRAW (no close — same position)
                 // =========================================================================
@@ -6796,140 +6424,123 @@ class Transactions {
                     }
                 }
                 // =========================================================================
-                // PHASE 2: DEPOSIT (hybrid layers, no init/extend needed)
+                // PHASE 2: DEPOSIT (hybrid layers via new add_liquidity_2 instruction)
                 // =========================================================================
-                const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
-                    hybridDistribution: layers,
-                    amountX: effectiveAmountX,
-                    amountY: effectiveAmountY,
-                    minDeltaId: new bn_js_1.default(minDeltaId),
-                    maxDeltaId: new bn_js_1.default(maxDeltaId),
-                    binStep,
-                    activeId: new bn_js_1.default(activeId),
-                });
                 const depositTxGroups = [];
-                if (positionWidth <= MAX_BINS_PER_DEPOSIT_CHUNK) {
-                    // Single deposit TX — all layers merged into one rebalanceLiquidity call.
-                    // Merge all layers into a single AddLiquidityParams entry by summing x0/y0/deltaX/deltaY.
-                    // Meteora's rebalanceLiquidity requires non-overlapping ranges across entries; since all
-                    // layers share the same full range, they must be merged into one. The formula is linear
-                    // so summing params is equivalent to summing per-bin amounts from each layer.
-                    const mergedLayer = strategyResults.reduce((acc, l) => ({
-                        x0: acc.x0.add(l.x0),
-                        y0: acc.y0.add(l.y0),
-                        deltaX: acc.deltaX.add(l.deltaX),
-                        deltaY: acc.deltaY.add(l.deltaY),
-                    }), {
-                        x0: new bn_js_1.default(0),
-                        y0: new bn_js_1.default(0),
-                        deltaX: new bn_js_1.default(0),
-                        deltaY: new bn_js_1.default(0),
-                    });
-                    const mergedP = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(mergedLayer.x0, mergedLayer.y0, mergedLayer.deltaX, mergedLayer.deltaY);
-                    const allAddLiquidityParams = [
-                        {
-                            minDeltaId,
-                            maxDeltaId,
-                            x0: mergedP.x0,
-                            y0: mergedP.y0,
-                            deltaX: mergedP.deltaX,
-                            deltaY: mergedP.deltaY,
-                            bitFlag: mergedP.bitFlag,
-                            favorXInActiveId,
-                        },
-                    ];
-                    const mergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), mergedLayer.deltaX, mergedLayer.deltaY, mergedLayer.x0, mergedLayer.y0, binStep, favorXInActiveId);
-                    const totalMaxX = mergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                    const totalMaxY = mergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
-                    depositTxGroups.push([
-                        yield depositFn({
+                if (positionWidth <= maxBinsPerDepositChunk) {
+                    if (useLayeredDepositsForSmallPosition) {
+                        const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                            hybridDistribution: layers,
+                            amountX: effectiveAmountX,
+                            amountY: effectiveAmountY,
+                            minDeltaId: new bn_js_1.default(minDeltaId),
+                            maxDeltaId: new bn_js_1.default(maxDeltaId),
+                            binStep,
+                            activeId: new bn_js_1.default(activeId),
+                        });
+                        const layeredDepositIxs = [];
+                        for (let i = 0; i < strategyResults.length; i++) {
+                            const layerStrategy = strategyResults[i];
+                            if (layerStrategy.maxAmountX.isZero() && layerStrategy.maxAmountY.isZero()) {
+                                continue;
+                            }
+                            const singleLayer = {
+                                strategyTypeX: contractLayers[i].strategyTypeX,
+                                strategyTypeY: contractLayers[i].strategyTypeY,
+                                percentageX: layers[i].x.percentage > 0 ? 100 : 0,
+                                percentageY: layers[i].y.percentage > 0 ? 100 : 0,
+                            };
+                            const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                                connection,
+                                userWallet: params.userWallet,
+                                lbPair,
+                                position: params.position,
+                                tokenXMint,
+                                tokenYMint,
+                                tokenXProgram,
+                                tokenYProgram,
+                                layers: [singleLayer],
+                                userTokenXAmount: layerStrategy.maxAmountX,
+                                userTokenYAmount: layerStrategy.maxAmountY,
+                                remainingAccountsInfo: baseRemainingAccountsInfo,
+                                pdaTokenType: types_1.TokenType.ATA,
+                                lowerBinId,
+                                upperBinId,
+                            });
+                            layeredDepositIxs.push({ label: 'deposit_v2', class: CLASS, instruction: depositIx });
+                        }
+                        if (layeredDepositIxs.length > 0) {
+                            depositTxGroups.push(layeredDepositIxs);
+                        }
+                    }
+                    else {
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
                             position: params.position,
-                            shouldClaimFee: false,
-                            shouldClaimReward: false,
-                            maxDepositXAmount: totalMaxX,
-                            maxDepositYAmount: totalMaxY,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            userTokenXAmount: effectiveAmountX,
+                            userTokenYAmount: effectiveAmountY,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
                             pdaTokenType: types_1.TokenType.ATA,
-                            addLiquidityParams: allAddLiquidityParams,
-                            origin: CLASS,
-                        }),
-                    ]);
+                            lowerBinId,
+                            upperBinId,
+                        });
+                        depositTxGroups.push([
+                            { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                        ]);
+                    }
                 }
                 else {
-                    // Chunked deposit — one TX per chunk, all layers per chunk
-                    const depositChunks = (0, liquidityStrategy_1.chunkHybridDepositParameters)(strategyResults, new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), new bn_js_1.default(activeId), binStep, MAX_BINS_PER_DEPOSIT_CHUNK, favorXInActiveId);
+                    const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                        hybridDistribution: layers,
+                        amountX: effectiveAmountX,
+                        amountY: effectiveAmountY,
+                        minDeltaId: new bn_js_1.default(minDeltaId),
+                        maxDeltaId: new bn_js_1.default(maxDeltaId),
+                        binStep,
+                        activeId: new bn_js_1.default(activeId),
+                    });
+                    const depositChunks = (0, liquidityStrategy_1.chunkHybridDepositParameters)(strategyResults, new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), new bn_js_1.default(activeId), binStep, maxBinsPerDepositChunk, favorXInActiveId);
+                    const chunkInstructionGroups = [];
                     for (const chunk of depositChunks) {
-                        // Merge all layers into a single AddLiquidityParams entry per chunk (see comment above).
-                        const chunkMergedLayer = chunk.layers.reduce((acc, l) => ({
-                            x0: acc.x0.add(l.params.x0),
-                            y0: acc.y0.add(l.params.y0),
-                            deltaX: acc.deltaX.add(l.params.deltaX),
-                            deltaY: acc.deltaY.add(l.params.deltaY),
-                        }), {
-                            x0: new bn_js_1.default(0),
-                            y0: new bn_js_1.default(0),
-                            deltaX: new bn_js_1.default(0),
-                            deltaY: new bn_js_1.default(0),
+                        const { chunkLowerOffset, chunkUpperOffset } = getHybridChunkOffsets(lowerBinId, chunk.lowerBinId, chunk.upperBinId);
+                        const chunkAmountX = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountX), new bn_js_1.default(0));
+                        const chunkAmountY = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountY), new bn_js_1.default(0));
+                        if (chunkAmountX.isZero() && chunkAmountY.isZero()) {
+                            continue;
+                        }
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.position,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            userTokenXAmount: chunkAmountX,
+                            userTokenYAmount: chunkAmountY,
+                            chunkLowerOffset,
+                            chunkUpperOffset,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            lowerBinId: chunk.lowerBinId,
+                            upperBinId: chunk.upperBinId,
                         });
-                        const chunkMergedP = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunkMergedLayer.x0, chunkMergedLayer.y0, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY);
-                        const chunkAddLiquidityParams = [
-                            {
-                                minDeltaId: chunk.minDeltaId.toNumber(),
-                                maxDeltaId: chunk.maxDeltaId.toNumber(),
-                                x0: chunkMergedP.x0,
-                                y0: chunkMergedP.y0,
-                                deltaX: chunkMergedP.deltaX,
-                                deltaY: chunkMergedP.deltaY,
-                                bitFlag: chunkMergedP.bitFlag,
-                                favorXInActiveId,
-                            },
-                        ];
-                        const chunkMergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), chunk.minDeltaId, chunk.maxDeltaId, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY, chunkMergedLayer.x0, chunkMergedLayer.y0, binStep, favorXInActiveId);
-                        const chunkTotalMaxX = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                        const chunkTotalMaxY = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
-                        depositTxGroups.push([
-                            yield depositFn({
-                                position: params.position,
-                                shouldClaimFee: false,
-                                shouldClaimReward: false,
-                                maxDepositXAmount: chunkTotalMaxX,
-                                maxDepositYAmount: chunkTotalMaxY,
-                                pdaTokenType: types_1.TokenType.ATA,
-                                addLiquidityParams: chunkAddLiquidityParams,
-                                origin: CLASS,
-                            }),
+                        chunkInstructionGroups.push([
+                            { label: 'deposit_v2', class: CLASS, instruction: depositIx },
                         ]);
                     }
+                    depositTxGroups.push(...batchHybridChunkInstructionGroups(chunkInstructionGroups, CHUNKS_PER_TRANSACTION));
                 }
                 // =========================================================================
-                // PHASE 3: SWEEP REMAINING DUST
-                // =========================================================================
-                // After the main hybrid deposit, add one final deposit with undefined amounts
-                // so the on-chain instruction reads the actual ATA balance and sweeps any dust.
-                // Uses Spot distribution. Bin range follows the position's range (preserving
-                // directional bias), clamped to 70 bins max (Meteora's single-call limit).
-                const { sweepLower, sweepUpper } = this._calculateSweepBinRange(minDeltaId, maxDeltaId);
-                const sweepIx = yield this.ix.meteoraDlmm.meteoraDlmmDepositRelativeAutomation({
-                    connection,
-                    userWallet: params.userWallet,
-                    lbPair,
-                    position: params.position,
-                    tokenXMint,
-                    tokenYMint,
-                    tokenXProgram,
-                    tokenYProgram,
-                    activeId,
-                    relativeBinRange: { lowerRange: sweepLower, upperRange: sweepUpper },
-                    strategyType: 6, // SpotImBalanced — handles any X/Y ratio including single-sided
-                    optionalTokenXAmount: undefined, // sweep — use full ATA balance
-                    optionalTokenYAmount: undefined, // sweep — use full ATA balance
-                    pdaTokenType: types_1.TokenType.ATA,
-                });
-                depositTxGroups.push([{
-                        label: 'sweep_dust',
-                        class: CLASS,
-                        instruction: sweepIx,
-                    }]);
-                // =========================================================================
                 // Assemble final TX list
                 // =========================================================================
                 const allTxGroups = [...withdrawTxGroups, ...depositTxGroups];
@@ -6944,7 +6555,7 @@ class Transactions {
                 return transactions;
             }
             catch (error) {
-                console.error('=== REDEPOSIT HYBRID LIQUIDITY AUTOMATION ERROR ===');
+                console.error('=== REDEPOSIT HYBRID LIQUIDITY V2 AUTOMATION ERROR ===');
                 console.error('Error:', error instanceof Error ? error.message : String(error));
                 console.error('Stack:', error instanceof Error ? error.stack : 'No stack trace');
                 console.error('=== END ERROR LOG ===');
@@ -7019,7 +6630,10 @@ class Transactions {
             if (userPosition === undefined) {
                 throw new Error(`Unexpected error: Position (${position}) doesn't exist on-chain`);
             }
-            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [
+                tokenXMint,
+                tokenYMint,
+            ]);
             const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
             const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
             const baseRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
@@ -7052,8 +6666,14 @@ class Transactions {
             const combinedAccounts = [];
             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 });
+            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,
+            });
             combinedAccounts.push(...baseRemainingAccountsInfo.accounts);
             for (const reward of rewardInfos) {
                 const rewardTransferHookInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, reward.rewardMint, reward.rewardTokenProgram);
@@ -7081,12 +6701,16 @@ class Transactions {
             const feeY = positionData.feeY;
             const HAWK_FEE_BPS = 800;
             const FEE_BPS_DENOM = 10000;
-            const netFeeX = feeX.mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS)).div(new bn_js_1.default(FEE_BPS_DENOM));
-            const netFeeY = feeY.mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS)).div(new bn_js_1.default(FEE_BPS_DENOM));
-            const estimatedTotalX = (compound && !skipClaim)
+            const netFeeX = feeX
+                .mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS))
+                .div(new bn_js_1.default(FEE_BPS_DENOM));
+            const netFeeY = feeY
+                .mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS))
+                .div(new bn_js_1.default(FEE_BPS_DENOM));
+            const estimatedTotalX = compound && !skipClaim
                 ? new bn_js_1.default(positionData.totalXAmount).add(netFeeX)
                 : new bn_js_1.default(positionData.totalXAmount);
-            const estimatedTotalY = (compound && !skipClaim)
+            const estimatedTotalY = compound && !skipClaim
                 ? new bn_js_1.default(positionData.totalYAmount).add(netFeeY)
                 : new bn_js_1.default(positionData.totalYAmount);
             const _rebalanceLiquidityAutomation = (_a) => __awaiter(this, [_a], void 0, function* ({ position, maxDepositXAmount, maxDepositYAmount, pdaTokenType, shrinkMode, shouldClaimFee, shouldClaimReward, removeLiquidityParams, addLiquidityParams, maxActiveBinSlippage, }) {
@@ -7095,7 +6719,10 @@ class Transactions {
                     userWallet: userWallet,
                     position,
                     lbPair,
-                    tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
                     activeId,
                     pdaTokenType,
                     maxActiveBinSlippage,
@@ -7127,7 +6754,9 @@ class Transactions {
                 });
             });
             const withdrawFn = (_a) => __awaiter(this, [_a], void 0, function* ({ position, minBinId, maxBinId, compound, origin, }) {
-                const pdaTokenTypeForClaimables = compound ? types_1.TokenType.ATA : types_1.TokenType.STA;
+                const pdaTokenTypeForClaimables = compound
+                    ? types_1.TokenType.ATA
+                    : types_1.TokenType.STA;
                 const ixs = [];
                 if (!skipClaim) {
                     // 1. Claim fees with hawk-side cut (must happen before withdraw+shrink invalidates position)
@@ -7179,7 +6808,7 @@ class Transactions {
                         maxBinId,
                         shouldClaimReward: false,
                         shouldClaimFee: false,
-                        shrinkMode: types_3.ShrinkMode.Default,
+                        shrinkMode: types_3.ShrinkMode.NoShrinkBoth,
                         pdaTokenType: types_1.TokenType.ATA,
                     }),
                 });
@@ -7261,17 +6890,18 @@ class Transactions {
             const ownerFeeReward = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, pool.rewardMint);
             // Mints that need ATAs on userPdaLamport (for withdrawal)
             const withdrawMints = [
-                ...new Set([
-                    pool.tokenMint.toString(),
-                    pool.rewardMint.toString(),
-                ]),
+                ...new Set([pool.tokenMint.toString(), pool.rewardMint.toString()]),
             ].map(v => new web3.PublicKey(v));
             // 1. Init ATAs for output token + reward on user PDA lamport
             const initAtaIxs = withdrawMints.map(mint => {
                 return (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(userWallet, (0, functions_1.generateAta)(userPdaLamport, mint), userPdaLamport, mint);
             });
             // Init ATAs for reward-related tokens on userPda (for harvest)
-            const initHarvestAtaIxs = [pool.lpMint, pool.rewardMint, addresses_1.SABER_IOU_MINT].map(mint => {
+            const initHarvestAtaIxs = [
+                pool.lpMint,
+                pool.rewardMint,
+                addresses_1.SABER_IOU_MINT,
+            ].map(mint => {
                 return (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(userWallet, (0, functions_1.generateAta)(userPda, mint), userPda, mint);
             });
             // 2. Harvest rewards from Quarry