@hawksightco/hawk-sdk 1.3.237 → 1.3.239

package/dist/src/classes/Transactions.js

@@ -1752,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.
@@ -1907,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)
@@ -2890,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.
@@ -6447,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) {
@@ -6474,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}]`);
@@ -6490,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 : 45;
+                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,
@@ -6518,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];
@@ -6548,309 +6142,7 @@ class Transactions {
                     }
                 }
                 // =========================================================================
-                // PHASE 2: REBUILD (init + extend + deposit with hybrid layers)
-                // =========================================================================
-                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),
-                });
-                // Build init + extend instructions
-                const initExtendIxs = [];
-                const initWidth = Math.min(MAX_INIT_WIDTH, newWidth);
-                initExtendIxs.push({
-                    label: 'initialize_position_relative',
-                    class: CLASS,
-                    instruction: yield this.ix.meteoraDlmm.initializePositionRelativeAutomation(connection, {
-                        userWallet: params.userWallet,
-                        lbPair,
-                        position: params.newPosition,
-                        relativeLowerBinId: params.relativeBinRange.lowerRange,
-                        width: initWidth,
-                    }),
-                });
-                let positionBinsAllocated = initWidth;
-                while (positionBinsAllocated < newWidth) {
-                    const toAdd = Math.min(MAX_EXTEND_LENGTH, newWidth - positionBinsAllocated);
-                    initExtendIxs.push({
-                        label: 'increase_position_length',
-                        class: CLASS,
-                        instruction: yield this.ix.meteoraDlmm.increasePositionLengthAutomation({
-                            connection,
-                            userWallet: params.userWallet,
-                            lbPair,
-                            position: params.newPosition,
-                            lengthToAdd: toAdd,
-                            side: types_1.MeteoraPositionSide.Upper,
-                        }),
-                    });
-                    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));
-                    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,
-                            ...binArrayInitIxsLabeled,
-                            depositIx,
-                        ]);
-                    }
-                    else {
-                        // 71-149 bins: extension needed, split init+extend from deposit to stay within TX size limit
-                        rebuildTxGroups.push(initExtendIxs);
-                        rebuildTxGroups.push([...binArrayInitIxsLabeled, 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);
-                    for (const chunk of depositChunks) {
-                        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 chunkTotalMaxX = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountX), new bn_js_1.default(0));
-                        const chunkTotalMaxY = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountY), new bn_js_1.default(0));
-                        const binArrayInitIxs = yield this._initBinArraysForRange(connection, lbPair, dlmmPool, chunk.lowerBinId, chunk.upperBinId);
-                        rebuildTxGroups.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,
-                            }),
-                        ]);
-                    }
-                }
-                // =========================================================================
-                // 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];
-                const transactions = [];
-                for (const txIxs of allTxGroups) {
-                    transactions.push(yield (0, functions_1.createTransactionMeta2)({
-                        payer: params.userWallet,
-                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                        mainInstructions: txIxs,
-                    }));
-                }
-                return transactions;
-            }
-            catch (error) {
-                console.error('=== REBALANCE HYBRID LIQUIDITY 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 ===');
-                throw error;
-            }
-        });
-    }
-    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 = 175;
-                const CHUNKS_PER_TRANSACTION = 3;
-                const CLASS = 'meteoraRebalanceHybridLiquidityV2Automation';
-                // --- Validate layers ---
-                const layers = params.layers;
-                if (layers.length === 0 || layers.length > 3) {
-                    throw new Error('layers must have 1-3 entries');
-                }
-                const sumX = layers.reduce((s, l) => s + l.x.percentage, 0);
-                const sumY = layers.reduce((s, l) => s + l.y.percentage, 0);
-                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, baseRemainingAccountsInfo, } = yield this.resolvePositionContext({
-                    connection,
-                    userWallet: params.userWallet,
-                    position: params.currentPosition,
-                    compound: params.compound,
-                    targetActiveBin: params.targetActiveBin,
-                });
-                if (activeId < params.checkRange.lowerRange ||
-                    activeId > params.checkRange.upperRange) {
-                    throw new Error(`Active bin ${activeId} outside checkRange [${params.checkRange.lowerRange}, ${params.checkRange.upperRange}]`);
-                }
-                const newLowerBinId = activeId + params.relativeBinRange.lowerRange;
-                const newUpperBinId = activeId + params.relativeBinRange.upperRange;
-                const newWidth = newUpperBinId - newLowerBinId + 1;
-                const currentWidth = currentUpperBinId - currentLowerBinId + 1;
-                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) {
-                    teardownTxGroups.push([
-                        ...(yield withdrawFn({
-                            position: params.currentPosition,
-                            minBinId: currentLowerBinId,
-                            maxBinId: currentUpperBinId,
-                            compound: params.compound,
-                            origin: CLASS,
-                        })),
-                        {
-                            label: 'close_position',
-                            class: CLASS,
-                            instruction: yield this.ix.meteoraDlmm.closePosition2Automation({
-                                connection,
-                                userWallet: params.userWallet,
-                                position: params.currentPosition,
-                                lbPair,
-                            }),
-                        },
-                    ]);
-                }
-                else {
-                    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];
-                        const isLast = i === withdrawChunks.length - 1;
-                        const chunkIxs = [
-                            ...(yield withdrawFn({
-                                position: params.currentPosition,
-                                minBinId: chunk.lowerBinId,
-                                maxBinId: chunk.upperBinId,
-                                compound: params.compound,
-                                origin: CLASS,
-                            })),
-                        ];
-                        if (isLast) {
-                            chunkIxs.push({
-                                label: 'close_position',
-                                class: CLASS,
-                                instruction: yield this.ix.meteoraDlmm.closePosition2Automation({
-                                    connection,
-                                    userWallet: params.userWallet,
-                                    position: params.currentPosition,
-                                    lbPair,
-                                }),
-                            });
-                        }
-                        teardownTxGroups.push(chunkIxs);
-                    }
-                }
-                // =========================================================================
-                // PHASE 2: REBUILD (init + extend + deposit with NEW add_liquidity_2 instruction)
+                // 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;
@@ -7062,224 +6354,6 @@ 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) {
-        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';
-                // --- Validate layers ---
-                const layers = params.layers;
-                if (layers.length === 0 || layers.length > 3) {
-                    throw new Error('layers must have 1-3 entries');
-                }
-                const sumX = layers.reduce((s, l) => s + l.x.percentage, 0);
-                const sumY = layers.reduce((s, l) => s + l.y.percentage, 0);
-                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({
-                    connection,
-                    userWallet: params.userWallet,
-                    position: params.position,
-                    compound: params.compound,
-                    targetActiveBin: undefined,
-                    skipClaim: true,
-                });
-                if (params.targetActiveBin !== undefined &&
-                    params.targetActiveBin !== activeId) {
-                    throw new Error(`targetActiveBin ${params.targetActiveBin} does not match live active bin ${activeId} for V2 redeposit`);
-                }
-                const positionWidth = upperBinId - lowerBinId + 1;
-                const binStep = new bn_js_1.default(lbPairState.binStep);
-                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;
-                // =========================================================================
-                // PHASE 1: WITHDRAW (no close — same position)
-                // =========================================================================
-                const withdrawTxGroups = [];
-                if (positionWidth <= MAX_BINS_PER_WITHDRAW_CHUNK) {
-                    withdrawTxGroups.push([
-                        ...(yield withdrawFn({
-                            position: params.position,
-                            minBinId: lowerBinId,
-                            maxBinId: upperBinId,
-                            compound: params.compound,
-                            origin: CLASS,
-                        })),
-                    ]);
-                }
-                else {
-                    const withdrawChunks = (0, liquidityStrategy_1.chunkBinRange)(lowerBinId, upperBinId, MAX_BINS_PER_WITHDRAW_CHUNK);
-                    for (const chunk of withdrawChunks) {
-                        withdrawTxGroups.push([
-                            ...(yield withdrawFn({
-                                position: params.position,
-                                minBinId: chunk.lowerBinId,
-                                maxBinId: chunk.upperBinId,
-                                compound: params.compound,
-                                origin: CLASS,
-                            })),
-                        ]);
-                    }
-                }
-                // =========================================================================
-                // PHASE 2: DEPOSIT (hybrid layers, no init/extend needed)
-                // =========================================================================
-                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({
-                            position: params.position,
-                            shouldClaimFee: false,
-                            shouldClaimReward: false,
-                            maxDepositXAmount: totalMaxX,
-                            maxDepositYAmount: totalMaxY,
-                            pdaTokenType: types_1.TokenType.ATA,
-                            addLiquidityParams: allAddLiquidityParams,
-                            origin: CLASS,
-                        }),
-                    ]);
-                }
-                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);
-                    for (const chunk of depositChunks) {
-                        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 chunkTotalMaxX = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountX), new bn_js_1.default(0));
-                        const chunkTotalMaxY = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountY), 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,
-                            }),
-                        ]);
-                    }
-                }
-                // =========================================================================
-                // 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];
-                const transactions = [];
-                for (const txIxs of allTxGroups) {
-                    transactions.push(yield (0, functions_1.createTransactionMeta2)({
-                        payer: params.userWallet,
-                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                        mainInstructions: txIxs,
-                    }));
-                }
-                return transactions;
-            }
-            catch (error) {
-                console.error('=== REDEPOSIT HYBRID LIQUIDITY 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 ===');
-                throw error;
-            }
-        });
-    }
     meteoraRedepositHybridLiquidityV2Automation(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             var _b, _c;
@@ -7306,7 +6380,7 @@ class Transactions {
                     skipClaim: true,
                 });
                 const positionWidth = upperBinId - lowerBinId + 1;
-                const maxBinsPerDepositChunk = positionWidth === 69 ? 69 : 50;
+                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;