@hawksightco/hawk-sdk 1.3.218 → 1.3.220

package/dist/src/classes/Transactions.js

@@ -1484,13 +1484,17 @@ class Transactions {
                 }
                 // ≥150 bins: chunked multi-TX approach
                 const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
-                // For compound, we use dummy equal amounts for deposit strategy calculation.
-                // The on-chain RebalanceLiquidity overrides totalXAmount/totalYAmount with ATA balance,
-                // so these values only affect the strategy ratio. Using equal amounts (like the single-TX
-                // compoundAutomationIx does with 100_000) ensures the strategy distributes evenly and
-                // doesn't try to transfer more of one token than is available from claimed fees.
-                const totalXAmount = new bn_js_1.default(100000);
-                const totalYAmount = new bn_js_1.default(100000);
+                // Compute expected post-claim ATA amounts for accurate strategy parameters.
+                // TX0 claims fees to ATA, minus 20% protocol fee sent to treasury on-chain.
+                // TX1 deposit must use strategy params that match actual post-claim ATA balance.
+                // Fee computation uses raw account parsing (avoids expensive getPositionsByUserAndLbPair).
+                const claimableFees = yield this._computeClaimableFees(connection, params.position, lbPair, lowerBinId, upperBinId);
+                const PROTOCOL_FEE_BPS = 2000; // 20% protocol fee deducted during claim_fee on-chain
+                const totalXAmount = claimableFees.feeX.sub(claimableFees.feeX.mul(new bn_js_1.default(PROTOCOL_FEE_BPS)).div(new bn_js_1.default(10000)));
+                const totalYAmount = claimableFees.feeY.sub(claimableFees.feeY.mul(new bn_js_1.default(PROTOCOL_FEE_BPS)).div(new bn_js_1.default(10000)));
+                if (totalXAmount.isZero() && totalYAmount.isZero()) {
+                    throw new Error('No claimable fees to compound');
+                }
                 const lbPairState = dlmmPool.dlmm.lbPair;
                 const tokenXMint = lbPairState.tokenXMint;
                 const tokenYMint = lbPairState.tokenYMint;
@@ -1590,6 +1594,7 @@ class Transactions {
                     activeId,
                     totalXAmount,
                     totalYAmount,
+                    skipInitBinArrays: true, // compound: position already exists, bin arrays are already initialized
                 });
                 // =========================================================================
                 // Phase 3: Assemble transactions
@@ -1615,7 +1620,6 @@ class Transactions {
         });
     }
     /**
-     * @deprecated Use rebalanceLargerPositionAutomation instead
      *
      * @param connection The Solana web3 connection object for blockchain interactions.
      * @param params Parameters required for rebalance
@@ -1680,7 +1684,6 @@ class Transactions {
         });
     }
     /**
-     * @deprecated Use rebalanceLargerPositionAutomation instaed
      *
      * @param connection The Solana web3 connection object for blockchain interactions.
      * @param params Parameters required for rebalance
@@ -1983,35 +1986,7 @@ class Transactions {
             }
         });
     }
-    /**
-     * Rebalance a Meteora DLMM position with support for larger positions.
-     *
-     * This is a backwards-compatible implementation of the rebalance operation that handles
-     * positions of any size. The method automatically splits operations into 2-dimensional
-     * instruction arrays (where each dimension represents a transaction) when dealing with
-     * large bin arrays that would exceed single transaction limits.
-     *
-     * This rebalance method performs the following steps:
-     * 1. Removes liquidity from the current position (supports larger bin ranges, not limited to 70-bin chunks, max 149-bin)
-     * 2. Claims fees from the current position
-     * 3. Claims rewards from the current position (if any)
-     * 4. Closes the current position
-     * 5. Initializes a new position
-     * 6. Extends the new position length if needed (for larger positions)
-     * 7. Adds liquidity to the new position using deposit automation
-     *
-     * Key benefits:
-     * - Backwards-compatible with existing rebalance implementations
-     * - Supports large bin arrays through automatic transaction splitting into multiple transactions
-     * - Does NOT depend on Meteora SDK
-     * - Handles positions that exceed single transaction size limits
-     * - Uses increasePositionLengthAutomation for larger new positions
-     *
-     * @param connection The Solana web3 connection object for blockchain interactions.
-     * @param params Parameters required for rebalance (same as MeteoraRebalance)
-     * @returns Array of TransactionMetadataResponse for each transaction
-     */
-    rebalanceLargerPositionAutomation(_a) {
+    rebalanceSmallPositionAutomation(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
             // Current theoretical limit (149-bin)
             const MAX_POSITION_WIDTH = 149;
@@ -2267,6 +2242,7 @@ class Transactions {
     }
     redepositForLargePositionAutomationIx(_a) {
         return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b;
             try {
                 const program = yield meteora_1.MeteoraDLMM.program(connection);
                 const positionData = yield program.account.positionV2.fetch(params.position);
@@ -2292,7 +2268,6 @@ class Transactions {
                 const remainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
                 const transactions = [];
                 const withdrawIxs = [];
-                const depositIxs = [];
                 const removeLiquidityIx = yield this.ix.meteoraDlmm.removeLiquidityByRange2Automation({
                     connection,
                     userWallet: params.userWallet,
@@ -2310,9 +2285,20 @@ class Transactions {
                 });
                 withdrawIxs.push(removeLiquidityIx);
                 const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
-                const relativeLowerBin = currentLowerBinId - activeId;
-                const relativeUpperBin = currentUpperBinId - activeId;
-                const addLiquidityIx = yield this.ix.meteoraDlmm.meteoraDlmmDepositRelativeAutomation({
+                // Compute total token amounts from position bin data for strategy parameter calculation
+                const positionBinData = userPosition.positionData.positionBinData;
+                const { totalXAmount, totalYAmount } = positionBinData.reduce((acc, bin) => ({
+                    totalXAmount: acc.totalXAmount.add(new bn_js_1.default(bin.positionXAmount)),
+                    totalYAmount: acc.totalYAmount.add(new bn_js_1.default(bin.positionYAmount)),
+                }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
+                const distributionToStrategyType = {
+                    'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
+                    'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
+                    'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
+                };
+                const strategyType = (_b = distributionToStrategyType[params.distribution]) !== null && _b !== void 0 ? _b : liquidityStrategy_1.StrategyType.SPOT;
+                // Deposit using chunked rebalanceLiquidityAutomation (handles >70 bins)
+                const depositIxArrays = yield this._meteoraDepositToLargePositionAutomation({
                     connection,
                     userWallet: params.userWallet,
                     lbPair,
@@ -2321,38 +2307,28 @@ class Transactions {
                     tokenYMint,
                     tokenXProgram,
                     tokenYProgram,
+                    lowerBinId: currentLowerBinId,
+                    upperBinId: currentUpperBinId,
+                    strategyType,
                     activeId,
-                    relativeBinRange: {
-                        lowerRange: relativeLowerBin,
-                        upperRange: relativeUpperBin,
-                    },
-                    strategyType: types_3.StrategyTypeMap[params.distribution],
-                    pdaTokenType: types_1.TokenType.ATA,
-                    remainingAccountsInfo,
-                    positionIsSigner: false,
+                    totalXAmount,
+                    totalYAmount,
+                    skipInitBinArrays: true,
                 });
-                depositIxs.push(addLiquidityIx);
-                const positionWidth = currentUpperBinId - currentLowerBinId + 1;
-                if (positionWidth <= 70) {
-                    transactions.push(yield (0, functions_1.createTransactionMeta)({
-                        payer: params.userWallet,
-                        description: 'Automation IX: Meteora Redeposit: Remove liquidity + add liquidity',
-                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                        mainInstructions: [...withdrawIxs, ...depositIxs],
-                    }));
-                }
-                else {
-                    transactions.push(yield (0, functions_1.createTransactionMeta)({
-                        payer: params.userWallet,
-                        description: 'Automation IX: Meteora Redeposit TX1: Remove liquidity',
-                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                        mainInstructions: withdrawIxs,
-                    }));
+                // TX1: withdraw (full range)
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: 'Automation IX: Meteora Redeposit TX1: Remove liquidity',
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: withdrawIxs,
+                }));
+                // TX2..N: deposit chunks
+                for (let i = 0; i < depositIxArrays.length; i++) {
                     transactions.push(yield (0, functions_1.createTransactionMeta)({
                         payer: params.userWallet,
-                        description: 'Automation IX: Meteora Redeposit TX2: Add liquidity',
+                        description: `Automation IX: Meteora Redeposit TX${i + 2}: Add liquidity`,
                         addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                        mainInstructions: depositIxs,
+                        mainInstructions: depositIxArrays[i],
                     }));
                 }
                 return transactions;
@@ -2366,10 +2342,213 @@ class Transactions {
             }
         });
     }
+    /**
+     * Phased rebalance for Meteora DLMM positions (71-149 bins).
+     *
+     * Produces exactly 2 TXs:
+     *   TX1: removeLiquidity + claimFee (with fee splitting) + claimRewards + closePosition
+     *   TX2: initPosition + extendPosition + initBinArrays + deposit (rebalanceLiquidityAutomation)
+     *
+     * Uses rebalanceLiquidityAutomation for deposit (handles 149 bins reliably),
+     * unlike rebalanceSmallPositionAutomation which uses meteoraDlmmDepositRelativeAutomation.
+     * Separate withdraw/deposit TXs enable Jupiter swap injection by the caller.
+     */
+    rebalancePhasedPositionAutomation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b, _c, _d;
+            const MAX_POSITION_WIDTH = 149;
+            const MAX_INIT_WIDTH = 70;
+            const MAX_EXTEND_LENGTH = 91;
+            try {
+                const program = yield meteora_1.MeteoraDLMM.program(connection);
+                const positionData = yield program.account.positionV2.fetch(params.currentPosition);
+                if (!positionData || !positionData.lbPair) {
+                    throw new Error(`Invalid position data: ${params.currentPosition.toString()}`);
+                }
+                const lbPair = positionData.lbPair;
+                const currentLowerBinId = positionData.lowerBinId;
+                const currentUpperBinId = positionData.upperBinId;
+                if (params.width > MAX_POSITION_WIDTH) {
+                    throw new Error(`Position width ${params.width} exceeds maximum ${MAX_POSITION_WIDTH}`);
+                }
+                const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+                const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+                const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+                const userPosition = userPositions.find(pos => pos.publicKey.equals(params.currentPosition));
+                if (!userPosition) {
+                    throw new Error(`Position ${params.currentPosition.toString()} not found`);
+                }
+                const positionBinData = userPosition.positionData.positionBinData;
+                const { totalXAmount, totalYAmount } = positionBinData.reduce((acc, bin) => ({
+                    totalXAmount: acc.totalXAmount.add(new bn_js_1.default(bin.positionXAmount)),
+                    totalYAmount: acc.totalYAmount.add(new bn_js_1.default(bin.positionYAmount)),
+                }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
+                const lbPairState = dlmmPool.dlmm.lbPair;
+                const tokenXMint = lbPairState.tokenXMint;
+                const tokenYMint = lbPairState.tokenYMint;
+                const rewardInfos = lbPairState.rewardInfos;
+                const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+                const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+                const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+                const remainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+                const pdaTokenTypeForClaimables = params.useAta ? types_1.TokenType.ATA : types_1.TokenType.STA;
+                const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
+                const distributionToStrategyType = {
+                    'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
+                    'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
+                    'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
+                };
+                const strategyType = (_b = distributionToStrategyType[params.distribution]) !== null && _b !== void 0 ? _b : liquidityStrategy_1.StrategyType.SPOT;
+                // =========================================================================
+                // TX1: Withdraw + Claim + Close (separate IXs — preserves fee splitting)
+                // =========================================================================
+                const group1Ixs = [];
+                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,
+                });
+                group1Ixs.push(removeLiquidityIx);
+                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,
+                });
+                group1Ixs.push(claimFeeIx);
+                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,
+                    });
+                    group1Ixs.push(claimRewardIx);
+                }
+                const closePositionIx = yield this.ix.meteoraDlmm.closePosition2Automation({
+                    connection,
+                    userWallet: params.userWallet,
+                    position: params.currentPosition,
+                    lbPair,
+                });
+                group1Ixs.push(closePositionIx);
+                // =========================================================================
+                // TX2: Init position + Extend + InitBinArrays + Deposit (rebalanceLiquidityAutomation)
+                // =========================================================================
+                const group2Ixs = [];
+                const initialWidth = Math.min(MAX_INIT_WIDTH, params.width);
+                const initPositionIx = yield this.ix.meteoraDlmm.initializePositionRelativeAutomation(connection, {
+                    userWallet: params.userWallet,
+                    lbPair,
+                    position: params.newPosition,
+                    relativeLowerBinId: params.relativeLowerBin,
+                    width: initialWidth,
+                });
+                group2Ixs.push(initPositionIx);
+                let positionBinsAllocated = initialWidth;
+                while (positionBinsAllocated < params.width) {
+                    const toAdd = Math.min(MAX_EXTEND_LENGTH, params.width - positionBinsAllocated);
+                    const extendIx = yield this.ix.meteoraDlmm.increasePositionLengthAutomation({
+                        connection,
+                        userWallet: params.userWallet,
+                        lbPair,
+                        position: params.newPosition,
+                        lengthToAdd: toAdd,
+                        side: types_1.MeteoraPositionSide.Upper,
+                    });
+                    group2Ixs.push(extendIx);
+                    positionBinsAllocated += toAdd;
+                }
+                const newLowerBinId = activeId + params.relativeLowerBin;
+                const newUpperBinId = newLowerBinId + params.width - 1;
+                // Only initialize bin arrays that don't exist yet (avoids bloating TX with redundant inits)
+                const binArraysRequired = yield (0, dlmm_1.getBinArraysRequiredByPositionRange)(lbPair, new bn_js_1.default(newLowerBinId), new bn_js_1.default(newUpperBinId), dlmmPool.dlmm.program.programId);
+                if (binArraysRequired.length > 0) {
+                    const initBinArraysIx = yield dlmmPool.dlmm.initializeBinArrays(binArraysRequired.map(b => b.index), addresses_1.HS_AUTHORITY);
+                    group2Ixs.push(...initBinArraysIx);
+                }
+                // Use adjusted amounts for strategy computation if provided (post-swap prediction).
+                // When a Jupiter swap occurs between withdraw and deposit, the ATA balances change.
+                // Strategy parameters (x0, y0) must match what will actually be in the ATA at deposit time.
+                const depositXAmount = (_c = params.adjustedTotalXAmount) !== null && _c !== void 0 ? _c : totalXAmount;
+                const depositYAmount = (_d = params.adjustedTotalYAmount) !== null && _d !== void 0 ? _d : totalYAmount;
+                // Skip bin array init inside deposit helper since we handled it above.
+                // Allow active bin slippage of 10 bins to tolerate price movement from the
+                // Jupiter swap that may occur between the withdraw TX and this deposit TX.
+                const depositIxArrays = yield this._meteoraDepositToLargePositionAutomation({
+                    connection,
+                    userWallet: params.userWallet,
+                    lbPair,
+                    position: params.newPosition,
+                    tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
+                    lowerBinId: newLowerBinId,
+                    upperBinId: newUpperBinId,
+                    strategyType,
+                    activeId,
+                    totalXAmount: depositXAmount,
+                    totalYAmount: depositYAmount,
+                    skipInitBinArrays: true,
+                    maxActiveBinSlippage: 10,
+                });
+                // For ≤149 bins, depositIxArrays has exactly 1 chunk
+                group2Ixs.push(...depositIxArrays[0]);
+                // =========================================================================
+                // Assemble TXs
+                // =========================================================================
+                const transactions = [];
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: 'Automation IX: Meteora Phased Rebalance TX1: Withdraw + Claim + Close',
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: group1Ixs,
+                }));
+                transactions.push(yield (0, functions_1.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: 'Automation IX: Meteora Phased Rebalance TX2: Init + Deposit',
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: group2Ixs,
+                }));
+                return transactions;
+            }
+            catch (error) {
+                console.error('=== REBALANCE PHASED POSITION AUTOMATION ERROR ===');
+                console.error('Error type:', error instanceof Error ? error.constructor.name : typeof error);
+                console.error('Error message:', error instanceof Error ? error.message : String(error));
+                console.error('Error stack:', error instanceof Error ? error.stack : 'No stack trace');
+                console.error('Full error object:', error);
+                console.error('=== END ERROR LOG ===');
+                throw error;
+            }
+        });
+    }
     /**
      * Rebalance a large Meteora DLMM position (up to 1400 bins) using automation instructions.
      *
-     * For ≤149 bins, delegates to rebalanceLargerPositionAutomation.
+     * For ≤70 bins, delegates to rebalanceSmallerPositionAutomation.
+     * For 71-149 bins, delegates to rebalancePhasedPositionAutomation.
      * For ≥150 bins, uses a chunked multi-TX approach:
      *   Phase 1: Chunked withdraw from current position
      *   Phase 2: Initialize new large position
@@ -2393,9 +2572,13 @@ class Transactions {
                 const currentLowerBinId = positionData.lowerBinId;
                 const currentUpperBinId = positionData.upperBinId;
                 const currentBinCount = currentUpperBinId - currentLowerBinId + 1;
-                // For ≤149 bins, delegate to existing rebalanceLargerPositionAutomation
+                // For ≤70 bins, delegate to existing rebalanceSmallPositionAutomation
+                if (currentBinCount <= 70 && params.width <= 70) {
+                    return this.rebalanceSmallPositionAutomation({ connection, params, fetch: undefined });
+                }
+                // For 71-149 bins, use phased approach (separate withdraw/deposit TXs)
                 if (currentBinCount <= 149 && params.width <= 149) {
-                    return this.rebalanceLargerPositionAutomation({ connection, params, fetch: undefined });
+                    return this.rebalancePhasedPositionAutomation({ connection, params, fetch: undefined });
                 }
                 // ≥150 bins: multi-TX chunked approach
                 const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
@@ -2543,7 +2726,7 @@ class Transactions {
                         tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
                         activeId: params.activeId,
                         pdaTokenType: types_1.TokenType.ATA,
-                        maxActiveBinSlippage: 300,
+                        maxActiveBinSlippage: 0,
                         shouldClaimFee: false,
                         shouldClaimReward: false,
                         minWithdrawXAmount: new bn_js_1.default(0),
@@ -2560,304 +2743,121 @@ class Transactions {
         });
     }
     /**
-     * @note DO NOT USE. STILL UNDER DEVELOPMENT. Tests still failing
-     * Reshape position: withdraw from old bins and deposit to new bins on the SAME position.
-     *
-     * Uses only rebalanceLiquidityAutomation (one IX per TX):
-     *   Remove TXs: rebalanceLiquidityAutomation with removeLiquidityParams (~75 bins/TX)
-     *   Deposit TXs: rebalanceLiquidityAutomation with addLiquidityParams (~75 bins/TX)
-     *
-     * Meteora's rebalance_liquidity handles position extension and bin array
-     * initialization internally — no separate IXs needed.
-     *
-     * Key differences from rebalanceLargePositionAutomation:
-     *   - Same position (no close/create, no new position keypair needed)
-     *   - Supports positions of any size (69 to 1400+ bins)
+     * Compute claimable fees for a position directly from on-chain account data.
+     * Avoids expensive getPositionsByUserAndLbPair by parsing raw buffers.
+     * Handles extended positions (>70 bins) by reading extended data after reserved bytes.
+     * Reference: data/tvl/src/meteoraFunctions.ts:getBatchedFees
      */
-    meteoraRebalanceLargePositionAutomation2(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
-            var _b, _c, _d;
-            try {
-                const WITHDRAW_CHUNK_SIZE = 200;
-                const DEPOSIT_CHUNK_SIZE = 200;
-                const DEPOSIT_CHUNK_INITIAL_SIZE = 100;
-                // Always reserve a small portion of bins for the pivot TX to ensure
-                // withdraw + deposit happen together (prevents ReallocExceedMaxLengthPerInstruction)
-                const PIVOT_RESERVE = 160;
-                // Fetch pool data
-                const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, params.lbPair, this.ix);
-                const userPda = (0, functions_1.generateUserPda)(params.userWallet);
-                const { binId: activeId } = yield dlmmPool.dlmm.getActiveBin();
-                // Get position's token amounts for deposit strategy calculation
-                const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
-                const userPosition = userPositions.find(pos => pos.publicKey.equals(params.position));
-                if (!userPosition) {
-                    throw new Error(`Position ${params.position.toString()} not found`);
-                }
-                const positionBinData = userPosition.positionData.positionBinData;
-                // Use actual liquidity range (bins with non-zero amounts) instead of padded position struct range
-                const binsWithLiquidity = positionBinData.filter(bin => !new bn_js_1.default(bin.positionXAmount).isZero() || !new bn_js_1.default(bin.positionYAmount).isZero());
-                const oldLowerBinId = binsWithLiquidity.length > 0
-                    ? binsWithLiquidity[0].binId
-                    : userPosition.positionData.lowerBinId;
-                const oldUpperBinId = binsWithLiquidity.length > 0
-                    ? binsWithLiquidity[binsWithLiquidity.length - 1].binId
-                    : userPosition.positionData.upperBinId;
-                const { totalXAmount, totalYAmount } = positionBinData.reduce((acc, bin) => ({
-                    totalXAmount: acc.totalXAmount.add(new bn_js_1.default(bin.positionXAmount)),
-                    totalYAmount: acc.totalYAmount.add(new bn_js_1.default(bin.positionYAmount)),
-                }), { totalXAmount: new bn_js_1.default(0), totalYAmount: new bn_js_1.default(0) });
-                const newLowerBinId = activeId + params.relativeLowerBin;
-                const newUpperBinId = newLowerBinId + params.width - 1;
-                console.log(`Total chunk per tx (withdraw): ${WITHDRAW_CHUNK_SIZE} bins, total chunk per tx (deposit): ${DEPOSIT_CHUNK_SIZE} bins`);
-                console.log(`old lower bin id: ${oldLowerBinId}, old upper bin id: ${oldUpperBinId}, old width: ${oldUpperBinId - oldLowerBinId + 1}`);
-                console.log(`new lower bin id: ${newLowerBinId}, new upper bin id: ${newUpperBinId}, new width: ${newUpperBinId - newLowerBinId + 1}`);
-                const lbPairState = dlmmPool.dlmm.lbPair;
-                const tokenXMint = lbPairState.tokenXMint;
-                const tokenYMint = lbPairState.tokenYMint;
-                const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
-                const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
-                const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
-                // Fetch transfer hook accounts for token X and Y (Token2022 support)
-                const baseRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
-                // Extract reward infos for claiming rewards during rebalance
-                const rewardInfos = [];
-                const rewardInfosFromPair = lbPairState.rewardInfos;
-                if (rewardInfosFromPair && rewardInfosFromPair.length > 0) {
-                    // Collect reward mints that are active (non-default)
-                    const activeRewardMints = [];
-                    for (const reward of rewardInfosFromPair) {
-                        if (!reward.mint.equals(web3.PublicKey.default)) {
-                            activeRewardMints.push(reward.mint);
-                        }
-                    }
-                    // Get token programs for reward mints
-                    if (activeRewardMints.length > 0) {
-                        const rewardTokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, activeRewardMints);
-                        for (let i = 0; i < rewardInfosFromPair.length; i++) {
-                            const reward = rewardInfosFromPair[i];
-                            if (!reward.mint.equals(web3.PublicKey.default)) {
-                                rewardInfos.push({
-                                    rewardIndex: i,
-                                    rewardVault: reward.vault,
-                                    rewardMint: reward.mint,
-                                    rewardTokenProgram: rewardTokenProgramMap[reward.mint.toString()],
-                                });
-                            }
-                        }
-                    }
-                }
-                console.log(`[Pipeline] Found ${rewardInfos.length} active reward(s) for this pool`);
-                // Build combined remainingAccountsInfo with transfer hooks for X, Y, and rewards
-                // The slices describe: TransferHookX, TransferHookY, TransferHookMultiReward(index) for each reward
-                // IMPORTANT: Always include all slices, even with length=0, so Meteora knows the account structure
-                const combinedSlices = [];
-                const combinedAccounts = [];
-                // Always add TransferHookX and TransferHookY slices (even if length=0)
-                const xSlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookX);
-                const ySlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookY);
-                combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookX, length: (_b = xSlice === null || xSlice === void 0 ? void 0 : xSlice.length) !== null && _b !== void 0 ? _b : 0 });
-                combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookY, length: (_c = ySlice === null || ySlice === void 0 ? void 0 : ySlice.length) !== null && _c !== void 0 ? _c : 0 });
-                // Add transfer hook accounts from base (for X and Y)
-                combinedAccounts.push(...baseRemainingAccountsInfo.accounts);
-                // Fetch transfer hook accounts for each reward and add to combined info
-                // IMPORTANT: Always add TransferHookMultiReward slice for each reward, even if length=0
-                // This tells Meteora about the reward position in the remaining accounts
-                for (const reward of rewardInfos) {
-                    const rewardTransferHookInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, reward.rewardMint, reward.rewardTokenProgram);
-                    // Always add TransferHookMultiReward slice (even if empty length for standard SPL tokens)
-                    const transferHookLength = rewardTransferHookInfo.slices.length > 0
-                        ? rewardTransferHookInfo.slices[0].length
-                        : 0;
-                    combinedSlices.push({
-                        accountsType: types_1.RemainingAccountsType.TransferHookMultiReward,
-                        length: transferHookLength,
-                        multiRewardIndex: reward.rewardIndex,
-                    });
-                    combinedAccounts.push(...rewardTransferHookInfo.accounts);
-                }
-                const remainingAccountsInfo = {
-                    slices: combinedSlices,
-                    accounts: combinedAccounts,
-                };
-                const distributionToStrategyType = {
-                    'SPOT': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-IMBALANCED': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-ONE-SIDE': liquidityStrategy_1.StrategyType.SPOT, 'SPOT-BALANCED': liquidityStrategy_1.StrategyType.SPOT,
-                    'CURVE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-IMBALANCED': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-ONE-SIDE': liquidityStrategy_1.StrategyType.CURVE, 'CURVE-BALANCED': liquidityStrategy_1.StrategyType.CURVE,
-                    'BID-ASK': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-IMBALANCED': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-ONE-SIDE': liquidityStrategy_1.StrategyType.BID_ASK, 'BID-ASK-BALANCED': liquidityStrategy_1.StrategyType.BID_ASK,
-                };
-                const strategyType = (_d = distributionToStrategyType[params.distribution]) !== null && _d !== void 0 ? _d : liquidityStrategy_1.StrategyType.SPOT;
-                const binStep = new bn_js_1.default(dlmmPool.dlmm.lbPair.binStep);
-                // Build new-position deposit chunks
-                const minDeltaId = new bn_js_1.default(newLowerBinId - activeId);
-                const maxDeltaId = new bn_js_1.default(newUpperBinId - activeId);
-                const favorXInActiveId = totalYAmount.isZero() && !totalXAmount.isZero();
-                const strategyParams = (0, liquidityStrategy_1.buildStrategyParameters)(strategyType, totalXAmount, totalYAmount, minDeltaId, maxDeltaId, binStep, new bn_js_1.default(activeId), favorXInActiveId);
-                // =====================================================================
-                // Pipeline algorithm: pack withdraw + deposit work into fewer TXs.
-                //
-                // Given W old bins to withdraw and D new bins to deposit:
-                //   Phase 1: Pure withdraw TXs — all withdraw chunks except the last
-                //   Phase 2: Pivot TX — last withdraw chunk + extend + initBinArrays
-                //            + first deposit (if small enough to fit without CU issues)
-                //   Phase 3: Pure deposit TXs — remaining deposit bins by CHUNK_SIZE
-                //
-                // When the total extension is large or the deposit range spans many
-                // bin arrays, the transition IXs (extend + initBinArrays) are placed
-                // in a separate TX to avoid exceeding compute unit limits.
-                // =====================================================================
-                const txInstructions = [];
-                // Helper: build on-chain deposit param from a ChunkedDepositParameters
-                const buildDepositParam = (chunk) => {
-                    const p = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunk.params.x0, chunk.params.y0, chunk.params.deltaX, chunk.params.deltaY);
-                    return {
-                        minDeltaId: chunk.minDeltaId.toNumber(),
-                        maxDeltaId: chunk.maxDeltaId.toNumber(),
-                        x0: p.x0, y0: p.y0, deltaX: p.deltaX, deltaY: p.deltaY,
-                        bitFlag: p.bitFlag, favorXInActiveId,
-                    };
-                };
-                // Helper: build withdraw IX
-                const buildWithdrawIx = (lower, upper) => __awaiter(this, void 0, void 0, function* () {
-                    const binArrayOverrides = this.ix.pda.meteora.deriveBinArrays(params.lbPair, lower, upper);
-                    return this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
-                        connection,
-                        userWallet: params.userWallet,
-                        position: params.position,
-                        lbPair: params.lbPair,
-                        tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
-                        activeId,
-                        pdaTokenType: types_1.TokenType.ATA,
-                        maxActiveBinSlippage: 300,
-                        shouldClaimFee: true,
-                        shouldClaimReward: rewardInfos.length > 0,
-                        minWithdrawXAmount: new bn_js_1.default(0),
-                        maxDepositXAmount: new bn_js_1.default(0),
-                        minWithdrawYAmount: new bn_js_1.default(0),
-                        maxDepositYAmount: new bn_js_1.default(0),
-                        removeLiquidityParams: [{ minBinId: lower, maxBinId: upper, bps: 10000 }],
-                        addLiquidityParams: [],
-                        binArrayOverrides,
-                        shrinkMode: types_3.ShrinkMode.Default,
-                        rewardInfos,
-                        remainingAccountsInfo,
-                    });
+    _computeClaimableFees(connection, position, lbPair, lowerBinId, upperBinId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const MAX_BIN_PER_ARRAY = 70;
+            const DLMM_PROGRAM_ID = new web3.PublicKey('LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo');
+            const positionAccountInfo = yield connection.getAccountInfo(position);
+            if (!positionAccountInfo || !positionAccountInfo.data) {
+                throw new Error(`Failed to fetch position account: ${position.toString()}`);
+            }
+            const posBuffer = positionAccountInfo.data;
+            const binCount = upperBinId - lowerBinId + 1;
+            // PositionV2 struct layout offsets
+            const LIQUIDITY_OFFSET = 72; // 8 discriminator + 32 lbPair + 32 owner
+            const REWARD_OFFSET = LIQUIDITY_OFFSET + 70 * 16; // liquidityShares: u128[70]
+            const FEE_OFFSET = REWARD_OFFSET + 70 * 48; // rewardInfos: UserRewardInfo[70], 48 bytes each
+            // After feeInfos[70]: lowerBinId(4) + upperBinId(4) + lastUpdatedAt(8) + totalClaimedFeeX(8) + totalClaimedFeeY(8) + totalClaimedRewards(16) + reserved(160)
+            const EXTENDED_OFFSET = FEE_OFFSET + 70 * 48 + 4 + 4 + 8 + 8 + 8 + 16 + 160;
+            function readU64(buf, off) {
+                return buf.readBigUInt64LE(off);
+            }
+            function readU128(buf, off) {
+                const low = buf.readBigUInt64LE(off);
+                const high = buf.readBigUInt64LE(off + 8);
+                return low + (high << BigInt(64));
+            }
+            const liquidityShares = [];
+            const feeInfos = [];
+            const binsInFixed = Math.min(binCount, 70);
+            for (let i = 0; i < binsInFixed; i++) {
+                liquidityShares.push(readU128(posBuffer, LIQUIDITY_OFFSET + i * 16));
+                const feeStart = FEE_OFFSET + i * 48;
+                feeInfos.push({
+                    feeXPerTokenComplete: readU128(posBuffer, feeStart),
+                    feeYPerTokenComplete: readU128(posBuffer, feeStart + 16),
+                    feeXPending: readU64(posBuffer, feeStart + 32),
+                    feeYPending: readU64(posBuffer, feeStart + 40),
                 });
-                // Helper: build deposit IX from a deposit chunk
-                const buildDepositIx = (chunk, removeLiquidityParams) => __awaiter(this, void 0, void 0, function* () {
-                    let trueMin = chunk.lowerBinId;
-                    let trueMax = chunk.upperBinId;
-                    if (removeLiquidityParams) {
-                        trueMin = Math.min(chunk.lowerBinId, removeLiquidityParams.minBinId);
-                        trueMax = Math.max(chunk.upperBinId, removeLiquidityParams.maxBinId);
-                    }
-                    const binArrayOverrides = this.ix.pda.meteora.deriveBinArrays(params.lbPair, trueMin, trueMax);
-                    return yield this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
-                        connection,
-                        userWallet: params.userWallet,
-                        position: params.position,
-                        lbPair: params.lbPair,
-                        tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
-                        activeId,
-                        pdaTokenType: types_1.TokenType.ATA,
-                        maxActiveBinSlippage: 300,
-                        shouldClaimFee: removeLiquidityParams ? true : false,
-                        shouldClaimReward: !!removeLiquidityParams && rewardInfos.length > 0,
-                        minWithdrawXAmount: new bn_js_1.default(0),
-                        maxDepositXAmount: chunk.maxAmountX,
-                        minWithdrawYAmount: new bn_js_1.default(0),
-                        maxDepositYAmount: chunk.maxAmountY,
-                        removeLiquidityParams: removeLiquidityParams ? [{ minBinId: removeLiquidityParams.minBinId, maxBinId: removeLiquidityParams.maxBinId, bps: 10000 }] : [],
-                        addLiquidityParams: [buildDepositParam(chunk)],
-                        binArrayOverrides,
-                        shrinkMode: removeLiquidityParams ? types_3.ShrinkMode.Default : types_3.ShrinkMode.NoShrinkBoth,
-                        rewardInfos: removeLiquidityParams ? rewardInfos : undefined,
-                        remainingAccountsInfo,
+            }
+            // Extended bins (>70) — appended after reserved bytes
+            if (binCount > 70) {
+                let offset = EXTENDED_OFFSET;
+                for (let i = 70; i < binCount; i++) {
+                    liquidityShares.push(readU128(posBuffer, offset));
+                    offset += 16;
+                    offset += 48; // skip rewardInfo
+                    feeInfos.push({
+                        feeXPerTokenComplete: readU128(posBuffer, offset),
+                        feeYPerTokenComplete: readU128(posBuffer, offset + 16),
+                        feeXPending: readU64(posBuffer, offset + 32),
+                        feeYPending: readU64(posBuffer, offset + 40),
                     });
-                });
-                // Build transition IXs: increasePositionLength + initBinArrays.
-                // Bin arrays must be pre-initialized before rebalanceLiquidity deposits.
-                const increasePositionLengthIxs = [];
-                // Generate increasePositionLength IXs to extend position (assumption at the moment, I expect calculation to be wrong)
-                let currentLower = newLowerBinId + WITHDRAW_CHUNK_SIZE;
-                while (currentLower < newUpperBinId) {
-                    const currentWidth = newUpperBinId - currentLower + 1;
-                    const binsToAdd = Math.min(91, currentWidth);
-                    console.log('Increasing position length by', binsToAdd, 'bins at lower', currentLower);
-                    increasePositionLengthIxs.push(yield this.ix.meteoraDlmm.increasePositionLengthAutomation({
-                        connection,
-                        userWallet: params.userWallet,
-                        lbPair: params.lbPair,
-                        position: params.position,
-                        lengthToAdd: binsToAdd,
-                        side: types_1.MeteoraPositionSide.Upper,
-                    }));
-                    currentLower = currentLower + binsToAdd;
-                }
-                // Build all deposit chunks upfront
-                const depositChunks = (0, liquidityStrategy_1.chunkDepositParametersWithInitialSize)(strategyParams, minDeltaId, maxDeltaId, new bn_js_1.default(activeId), binStep, DEPOSIT_CHUNK_INITIAL_SIZE, DEPOSIT_CHUNK_SIZE, favorXInActiveId);
-                // Build old-position withdraw chunks, reserving PIVOT_RESERVE bins for pivot TX
-                const oldWidth = oldUpperBinId - oldLowerBinId + 1;
-                const oldChunks = [];
-                let current = oldLowerBinId;
-                // Build Phase 1 withdraw chunks (before pivot)
-                while (current < oldUpperBinId) {
-                    const upper = Math.min(WITHDRAW_CHUNK_SIZE - 1, oldUpperBinId - current) + current;
-                    console.log(`Generating withdraw chunk: [${current}, ${upper}, ${upper - current + 1} bins]`);
-                    oldChunks.push({ lower: current, upper });
-                    current = upper + 1;
-                }
-                const remainder = oldWidth % WITHDRAW_CHUNK_SIZE;
-                if (remainder === 0 || remainder > PIVOT_RESERVE) {
-                    // Pop last chunk to reserve for pivot
-                    const popped = oldChunks.pop();
-                    // Then insert bigger and final chunk for pivot
-                    const upper = popped.upper - PIVOT_RESERVE;
-                    oldChunks.push({ lower: popped.lower, upper });
-                    oldChunks.push({ lower: upper + 1, upper: popped.upper });
+                    offset += 48;
                 }
-                // =====================================================================
-                // Phase 1: Pure withdraw TXs — all chunks in oldChunks (before pivot)
-                // =====================================================================
-                for (const chunk of oldChunks) {
-                    console.log(`Withdrawing from chunk: [${chunk.lower}, ${chunk.upper}]`);
-                    txInstructions.push([yield buildWithdrawIx(chunk.lower, chunk.upper)]);
-                }
-                // Pop the last one
-                txInstructions.pop();
-                // Get the last withdraw chunk for pivot
-                const lastWithdrawChunk = oldChunks[oldChunks.length - 1];
-                // =====================================================================
-                // Phase 2 (Pivot TX): Withdraw pivot reserve + first deposit
-                // This ensures bins "jump" to new position, preventing ReallocExceedMaxLengthPerInstruction
-                // =====================================================================
-                txInstructions.push([
-                    yield buildDepositIx(depositChunks[0], { minBinId: lastWithdrawChunk.lower, maxBinId: lastWithdrawChunk.upper }),
-                    ...increasePositionLengthIxs,
-                ]);
-                // =====================================================================
-                // Phase 3: Remaining deposit TXs
-                // - Second deposit (i=1): includes increasePositionLengthIxs if needed
-                // - Subsequent deposits (i=2+): pure deposit
-                // =====================================================================
-                for (let i = 1; i < depositChunks.length; i++) {
-                    const chunk = depositChunks[i];
-                    txInstructions.push([yield buildDepositIx(chunk)]);
+            }
+            // Derive and fetch bin array accounts
+            const binArrayIndices = new Set();
+            for (let i = 0; i < binCount; i++) {
+                binArrayIndices.add(Math.floor((lowerBinId + i) / MAX_BIN_PER_ARRAY));
+            }
+            const binArrayIndexList = Array.from(binArrayIndices);
+            const binArrayPDAs = binArrayIndexList.map(index => {
+                const buf = Buffer.alloc(8);
+                buf.writeBigInt64LE(BigInt(index));
+                const [pda] = web3.PublicKey.findProgramAddressSync([Buffer.from('bin_array'), lbPair.toBytes(), buf], DLMM_PROGRAM_ID);
+                return pda;
+            });
+            const binArrayAccounts = yield connection.getMultipleAccountsInfo(binArrayPDAs);
+            // Parse bin array fee accumulators
+            const BIN_ARRAY_HEADER = 56;
+            const BIN_SIZE = 144;
+            const binArrayFeeMap = new Map();
+            for (let a = 0; a < binArrayIndexList.length; a++) {
+                const account = binArrayAccounts[a];
+                if (!account || !account.data)
+                    continue;
+                const feeMap = new Map();
+                for (let b = 0; b < MAX_BIN_PER_ARRAY; b++) {
+                    const binStart = BIN_ARRAY_HEADER + b * BIN_SIZE;
+                    feeMap.set(b, {
+                        feeXStored: readU128(account.data, binStart + 80),
+                        feeYStored: readU128(account.data, binStart + 96),
+                    });
                 }
-                // Wrap each instruction array with createTransactionMeta
-                const transactions = [];
-                for (let i = 0; i < txInstructions.length; i++) {
-                    transactions.push(yield (0, functions_1.createTransactionMeta)({
-                        payer: params.userWallet,
-                        description: `Automation IX: Reshape position (tx ${i + 1}/${txInstructions.length})`,
-                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
-                        mainInstructions: txInstructions[i],
-                    }));
+                binArrayFeeMap.set(binArrayIndexList[a], feeMap);
+            }
+            // Compute total claimable fees
+            let totalFeeX = BigInt(0);
+            let totalFeeY = BigInt(0);
+            for (let i = 0; i < binCount; i++) {
+                const binId = lowerBinId + i;
+                const arrayIndex = Math.floor(binId / MAX_BIN_PER_ARRAY);
+                const binIndexInArray = binId - arrayIndex * MAX_BIN_PER_ARRAY;
+                let feeX = feeInfos[i].feeXPending;
+                let feeY = feeInfos[i].feeYPending;
+                const binArray = binArrayFeeMap.get(arrayIndex);
+                if (binArray && liquidityShares[i] > BigInt(0)) {
+                    const binData = binArray.get(binIndexInArray);
+                    if (binData) {
+                        const deltaX = binData.feeXStored - feeInfos[i].feeXPerTokenComplete;
+                        const deltaY = binData.feeYStored - feeInfos[i].feeYPerTokenComplete;
+                        feeX += (liquidityShares[i] * deltaX) >> BigInt(128);
+                        feeY += (liquidityShares[i] * deltaY) >> BigInt(128);
+                    }
                 }
-                return transactions;
-            }
-            catch (error) {
-                throw error;
+                totalFeeX += feeX;
+                totalFeeY += feeY;
             }
+            return {
+                feeX: new bn_js_1.default(totalFeeX.toString()),
+                feeY: new bn_js_1.default(totalFeeY.toString()),
+            };
         });
     }
     /**
@@ -2868,7 +2868,8 @@ class Transactions {
     _meteoraDepositToLargePositionAutomation(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const MAX_BINS_PER_TX = 149;
-            const { connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, lowerBinId, upperBinId, strategyType, activeId, totalXAmount, totalYAmount, } = params;
+            const { connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, lowerBinId, upperBinId, strategyType, activeId, totalXAmount, totalYAmount, skipInitBinArrays, maxActiveBinSlippage: maxActiveBinSlippageParam, } = params;
+            const maxActiveBinSlippage = maxActiveBinSlippageParam !== null && maxActiveBinSlippageParam !== void 0 ? maxActiveBinSlippageParam : 0;
             const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
             const binStep = new bn_js_1.default(dlmmPool.dlmm.lbPair.binStep);
             // Calculate delta IDs relative to active bin for entire position
@@ -2886,16 +2887,20 @@ class Transactions {
                 // Convert strategy parameters to on-chain format with bitFlag for negative values
                 const onChainParams = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunk.params.x0, chunk.params.y0, chunk.params.deltaX, chunk.params.deltaY);
                 const instructions = [];
-                // Add initialize bin arrays instruction
-                // Use HS_AUTHORITY as funder since this is a raw Meteora IX and the automation worker signs with this key
-                const initBinArraysIx = yield this.ix.meteoraDlmm.meteoraDlmmInitializeBinArrayDefault({
-                    connection,
-                    userWallet: addresses_1.HS_AUTHORITY,
-                    lbPair,
-                    lowerBinId: chunk.lowerBinId,
-                    upperBinId: chunk.upperBinId,
-                });
-                instructions.push(...initBinArraysIx);
+                // Add initialize bin arrays instruction only when bin arrays may not yet exist.
+                // For compound operations the position already exists, so bin arrays are already
+                // initialized — skipping these saves TX space.
+                if (!skipInitBinArrays) {
+                    // Use HS_AUTHORITY as funder since this is a raw Meteora IX and the automation worker signs with this key
+                    const initBinArraysIx = yield this.ix.meteoraDlmm.meteoraDlmmInitializeBinArrayDefault({
+                        connection,
+                        userWallet: addresses_1.HS_AUTHORITY,
+                        lbPair,
+                        lowerBinId: chunk.lowerBinId,
+                        upperBinId: chunk.upperBinId,
+                    });
+                    instructions.push(...initBinArraysIx);
+                }
                 // Add liquidity via rebalanceLiquidityAutomation
                 // Use u64::MAX for maxDeposit amounts so they don't cap the deposit.
                 // The on-chain program uses ATA balance for actual amounts; these are just safety ceilings.
@@ -2911,7 +2916,7 @@ class Transactions {
                     tokenYProgram,
                     activeId,
                     pdaTokenType: types_1.TokenType.ATA,
-                    maxActiveBinSlippage: 300,
+                    maxActiveBinSlippage,
                     shouldClaimFee: false,
                     shouldClaimReward: false,
                     minWithdrawXAmount: new bn_js_1.default(0),
@@ -3110,7 +3115,7 @@ class Transactions {
                         tokenYProgram,
                         activeId,
                         pdaTokenType: types_1.TokenType.ATA,
-                        maxActiveBinSlippage: 300,
+                        maxActiveBinSlippage: 0,
                         shouldClaimFee: false,
                         shouldClaimReward: false,
                         minWithdrawXAmount: new bn_js_1.default(0),
@@ -3856,7 +3861,7 @@ class Transactions {
                     activeId,
                     pdaTokenType,
                     // RebalanceLiquidityParams
-                    maxActiveBinSlippage: 300,
+                    maxActiveBinSlippage: 0,
                     shouldClaimFee: false,
                     shouldClaimReward: false,
                     minWithdrawXAmount: new bn_js_1.default(0),
@@ -5909,6 +5914,377 @@ class Transactions {
             });
         });
     }
+    /**
+     * Hybrid liquidity rebalance for automation: teardown old position and rebuild
+     * with independent X/Y distributions per layer using rebalanceLiquidityAutomation.
+     *
+     * Scope: 70-bin positions only. No increasePositionLength needed.
+     */
+    meteoraRebalanceHybridLiquidityAutomation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b, _c;
+            try {
+                // --- 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: currentLowerBinId, upperBinId: currentUpperBinId, estimatedTotalX, estimatedTotalY, activeId, withdrawFn, depositFn, } = 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}]`);
+                }
+                const newLowerBinId = activeId + params.relativeBinRange.lowerRange;
+                const newUpperBinId = activeId + params.relativeBinRange.upperRange;
+                const binStep = new bn_js_1.default(lbPairState.binStep);
+                // --- Build TX1 (teardown) ---
+                // Generate rebalance_liquidity instruction meant for withdrawing liquidity, fees, and rewards, and
+                // shrinking position prior to closing
+                const tx1Instructions = [
+                    // Withdraw + claim fees + claim rewards using rebalanceLiquidity
+                    ...yield withdrawFn({
+                        position: params.currentPosition,
+                        minBinId: currentLowerBinId,
+                        maxBinId: currentUpperBinId,
+                        compound: params.compound,
+                        origin: `meteoraRebalanceHybridLiquidityAutomation`
+                    }),
+                    // Close position
+                    {
+                        label: 'close_position',
+                        class: 'meteoraRebalanceHybridLiquidityAutomation',
+                        instruction: yield this.ix.meteoraDlmm.closePosition2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            position: params.currentPosition,
+                            lbPair,
+                        })
+                    }
+                ];
+                // --- Build TX2+ (rebuild) ---
+                const CLASS = 'meteoraRebalanceHybridLiquidityAutomation';
+                const txInstructions = [tx1Instructions];
+                // New position bin arrays
+                const newWidth = newUpperBinId - newLowerBinId + 1;
+                // TX2: initializePositionRelativeAutomation + first deposit batch
+                const initIx = {
+                    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: newWidth,
+                    }),
+                };
+                // --- Build addLiquidityParams per layer ---
+                const minDeltaId = newLowerBinId - activeId;
+                const maxDeltaId = newUpperBinId - activeId;
+                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 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 allAddLiquidityParams = strategyResults.map(mergedParams => {
+                    const p = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(mergedParams.x0, mergedParams.y0, mergedParams.deltaX, mergedParams.deltaY);
+                    return {
+                        minDeltaId,
+                        maxDeltaId,
+                        x0: p.x0, y0: p.y0, deltaX: p.deltaX, deltaY: p.deltaY,
+                        bitFlag: p.bitFlag,
+                        favorXInActiveId,
+                        maxAmountX: mergedParams.maxAmountX,
+                        maxAmountY: mergedParams.maxAmountY,
+                    };
+                });
+                // One deposit IX per addLiquidityParams
+                const depositIxs = [];
+                for (const p of allAddLiquidityParams) {
+                    depositIxs.push(yield depositFn({
+                        position: params.newPosition,
+                        shouldClaimFee: false,
+                        shouldClaimReward: false,
+                        maxDepositXAmount: p.maxAmountX,
+                        maxDepositYAmount: p.maxAmountY,
+                        pdaTokenType: types_1.TokenType.ATA,
+                        addLiquidityParams: [{
+                                minDeltaId: p.minDeltaId,
+                                maxDeltaId: p.maxDeltaId,
+                                x0: p.x0, y0: p.y0, deltaX: p.deltaX, deltaY: p.deltaY,
+                                bitFlag: p.bitFlag,
+                                favorXInActiveId: p.favorXInActiveId,
+                            }],
+                        origin: CLASS,
+                    }));
+                }
+                // TX2: init + first deposit
+                txInstructions.push([initIx, depositIxs[0]]);
+                // TX3+: remaining deposit IXs
+                for (let i = 1; i < depositIxs.length; i++) {
+                    txInstructions.push([depositIxs[i]]);
+                }
+                // --- Wrap in TransactionMetadataResponse2 ---
+                const transactions = [];
+                for (let i = 0; i < txInstructions.length; i++) {
+                    transactions.push(yield (0, functions_1.createTransactionMeta2)({
+                        payer: params.userWallet,
+                        addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                        mainInstructions: txInstructions[i],
+                    }));
+                }
+                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;
+            }
+        });
+    }
+    /**
+     * Fetches a DLMM position's on-chain state and resolves all associated context
+     * needed for downstream instructions: pool state, token mints/programs,
+     * transfer hook remaining accounts, and reward hook remaining accounts.
+     */
+    resolvePositionContext(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, compound, targetActiveBin, }) {
+            var _b, _c;
+            // --- Fetch position + pool state ---
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            const positionOnChain = yield program.account.positionV2.fetch(position);
+            const lbPair = positionOnChain.lbPair;
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair, this.ix);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const lowerBinId = positionOnChain.lowerBinId;
+            const upperBinId = positionOnChain.upperBinId;
+            const lbPairState = dlmmPool.dlmm.lbPair;
+            const tokenXMint = lbPairState.tokenXMint;
+            const tokenYMint = lbPairState.tokenYMint;
+            const activeId = targetActiveBin !== undefined ? targetActiveBin : lbPairState.activeId;
+            // Position data. (techdebt, needs not to call this in the future)
+            // AI note, just keep it. we'll work on this later.
+            const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+            const userPosition = userPositions.find(p => p.publicKey.equals(position));
+            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 tokenXProgram = tokenProgramMap[tokenXMint.toString()];
+            const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
+            const baseRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+            // --- Build combined remainingAccountsInfo with rewards ---
+            const rewardInfos = [];
+            const rewardInfosFromPair = lbPairState.rewardInfos;
+            if (rewardInfosFromPair && rewardInfosFromPair.length > 0) {
+                const activeRewardMints = [];
+                for (const reward of rewardInfosFromPair) {
+                    if (!reward.mint.equals(web3.PublicKey.default)) {
+                        activeRewardMints.push(reward.mint);
+                    }
+                }
+                if (activeRewardMints.length > 0) {
+                    const rewardTokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, activeRewardMints);
+                    for (let i = 0; i < rewardInfosFromPair.length; i++) {
+                        const reward = rewardInfosFromPair[i];
+                        if (!reward.mint.equals(web3.PublicKey.default)) {
+                            rewardInfos.push({
+                                rewardIndex: i,
+                                rewardVault: reward.vault,
+                                rewardMint: reward.mint,
+                                rewardTokenProgram: rewardTokenProgramMap[reward.mint.toString()],
+                            });
+                        }
+                    }
+                }
+            }
+            const combinedSlices = [];
+            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 });
+            combinedAccounts.push(...baseRemainingAccountsInfo.accounts);
+            for (const reward of rewardInfos) {
+                const rewardTransferHookInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, reward.rewardMint, reward.rewardTokenProgram);
+                const transferHookLength = rewardTransferHookInfo.slices.length > 0
+                    ? rewardTransferHookInfo.slices[0].length
+                    : 0;
+                combinedSlices.push({
+                    accountsType: types_1.RemainingAccountsType.TransferHookMultiReward,
+                    length: transferHookLength,
+                    multiRewardIndex: reward.rewardIndex,
+                });
+                combinedAccounts.push(...rewardTransferHookInfo.accounts);
+            }
+            const remainingAccountsInfo = {
+                slices: combinedSlices,
+                accounts: combinedAccounts,
+            };
+            // --- Estimate total amounts ---
+            const positionData = userPosition.positionData;
+            const feeX = positionData.feeX;
+            const feeY = positionData.feeY;
+            const estimatedTotalX = compound
+                ? new bn_js_1.default(positionData.totalXAmount).add(feeX)
+                : new bn_js_1.default(positionData.totalXAmount);
+            const estimatedTotalY = compound
+                ? new bn_js_1.default(positionData.totalYAmount).add(feeY)
+                : 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, }) {
+                return yield this.ix.meteoraDlmm.rebalanceLiquidityAutomation({
+                    connection,
+                    userWallet: userWallet,
+                    position,
+                    lbPair,
+                    tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
+                    activeId,
+                    pdaTokenType,
+                    maxActiveBinSlippage: 0,
+                    shouldClaimFee,
+                    shouldClaimReward,
+                    minWithdrawXAmount: new bn_js_1.default(0),
+                    maxDepositXAmount,
+                    minWithdrawYAmount: new bn_js_1.default(0),
+                    maxDepositYAmount,
+                    removeLiquidityParams,
+                    addLiquidityParams,
+                    shrinkMode,
+                    rewardInfos,
+                    remainingAccountsInfo,
+                });
+            });
+            const _withdrawFn = (_a) => __awaiter(this, [_a], void 0, function* ({ position, minBinId, maxBinId, shrinkMode, shouldClaimFee, shouldClaimReward, pdaTokenType, }) {
+                return yield _rebalanceLiquidityAutomation({
+                    position,
+                    pdaTokenType,
+                    shouldClaimFee,
+                    shouldClaimReward,
+                    maxDepositXAmount: new bn_js_1.default(0),
+                    maxDepositYAmount: new bn_js_1.default(0),
+                    removeLiquidityParams: [{ minBinId, maxBinId, bps: 10000 }],
+                    addLiquidityParams: [],
+                    shrinkMode,
+                });
+            });
+            const withdrawFn = (_a) => __awaiter(this, [_a], void 0, function* ({ position, minBinId, maxBinId, compound, origin, }) {
+                if (compound) {
+                    // Withdraw + Claim Fee + Claim Reward
+                    return [
+                        {
+                            label: 'compound_withdraw_using_rbl',
+                            class: origin,
+                            instruction: yield _withdrawFn({
+                                position,
+                                minBinId,
+                                maxBinId,
+                                shouldClaimReward: true,
+                                shrinkMode: types_3.ShrinkMode.Default,
+                                shouldClaimFee: true,
+                                pdaTokenType: types_1.TokenType.ATA,
+                            })
+                        }
+                    ];
+                }
+                return [
+                    // Withdraw + claim reward from position
+                    {
+                        label: 'non_compound_withdraw_using_rbl',
+                        class: 'withdrawFn',
+                        instruction: yield _withdrawFn({
+                            position,
+                            minBinId,
+                            maxBinId,
+                            shouldClaimReward: true,
+                            shrinkMode: types_3.ShrinkMode.NoShrinkBoth,
+                            shouldClaimFee: false,
+                            // Note:
+                            //   User Reward Token is not affected by this parameter. It's always STA regardless.
+                            //   pdaTokenType only affects token deposits (which essentially are fees as well)
+                            pdaTokenType: types_1.TokenType.ATA,
+                        })
+                    },
+                    // Claim fees and shrink position
+                    {
+                        label: 'claim_fees_using_rbl',
+                        class: 'withdrawFn',
+                        instruction: yield _withdrawFn({
+                            position,
+                            minBinId,
+                            maxBinId,
+                            shouldClaimReward: false,
+                            // We shrink position at claim fees where we have zero deposits on given min ~ max binId
+                            // at this point
+                            shrinkMode: types_3.ShrinkMode.Default,
+                            shouldClaimFee: true,
+                            // Note (continuation):
+                            //   That is why we split it to 2 ix, because we want fees to be transfered to STA if
+                            //   compound is off
+                            pdaTokenType: types_1.TokenType.STA,
+                        })
+                    }
+                ];
+            });
+            const depositFn = (_a) => __awaiter(this, [_a], void 0, function* ({ position, maxDepositXAmount, maxDepositYAmount, pdaTokenType, addLiquidityParams, origin, }) {
+                return {
+                    label: 'deposit_using_rbl',
+                    class: origin,
+                    instruction: yield _rebalanceLiquidityAutomation({
+                        position,
+                        maxDepositXAmount,
+                        maxDepositYAmount,
+                        pdaTokenType,
+                        shrinkMode: types_3.ShrinkMode.NoShrinkBoth,
+                        shouldClaimFee: false,
+                        shouldClaimReward: false,
+                        removeLiquidityParams: [],
+                        addLiquidityParams,
+                    })
+                };
+            });
+            return {
+                program,
+                lbPair,
+                lbPairState,
+                activeId,
+                userPosition,
+                dlmmPool,
+                userPda,
+                lowerBinId,
+                upperBinId,
+                tokenXMint,
+                tokenYMint,
+                tokenXProgram,
+                tokenYProgram,
+                remainingAccountsInfo,
+                rewardInfos,
+                estimatedTotalX,
+                estimatedTotalY,
+                withdrawFn,
+                depositFn,
+            };
+        });
+    }
 }
 exports.Transactions = Transactions;
 exports.txgen = Transactions.getInstance();