@hawksightco/hawk-sdk 1.3.235 → 1.3.237

package/dist/src/classes/Transactions.js

@@ -46,6 +46,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.txgen = exports.Transactions = void 0;
+exports.getHybridChunkOffsets = getHybridChunkOffsets;
+exports.batchHybridChunkInstructionGroups = batchHybridChunkInstructionGroups;
 const errors_1 = require("../errors");
 const dlmm_1 = require("@meteora-ag/dlmm");
 const web3 = __importStar(require("@solana/web3.js"));
@@ -70,6 +72,53 @@ const anchor = __importStar(require("@coral-xyz/anchor"));
 const RaydiumIxGenerator_1 = require("../ixGenerator/RaydiumIxGenerator");
 const RaydiumSDK_1 = require("./RaydiumSDK");
 const types_3 = require("../types");
+function getHybridChunkOffsets(positionLowerBinId, chunkLowerBinId, chunkUpperBinId) {
+    return {
+        chunkLowerOffset: chunkLowerBinId - positionLowerBinId,
+        chunkUpperOffset: chunkUpperBinId - positionLowerBinId,
+    };
+}
+function getInstructionDedupKey(ix) {
+    return [
+        ix.programId.toString(),
+        ix.data.toString('base64'),
+        ...ix.keys.map(meta => [
+            meta.pubkey.toString(),
+            meta.isSigner ? '1' : '0',
+            meta.isWritable ? '1' : '0',
+        ].join(':')),
+    ].join('|');
+}
+function dedupeInitBinArrayInstructions(ixs) {
+    const seenInitKeys = new Set();
+    const deduped = [];
+    for (const ix of ixs) {
+        if (ix.label !== 'init_bin_array') {
+            deduped.push(ix);
+            continue;
+        }
+        const dedupKey = getInstructionDedupKey(ix.instruction);
+        if (seenInitKeys.has(dedupKey)) {
+            continue;
+        }
+        seenInitKeys.add(dedupKey);
+        deduped.push(ix);
+    }
+    return deduped;
+}
+function batchHybridChunkInstructionGroups(chunkInstructionGroups, chunksPerTransaction = 2) {
+    if (!Number.isInteger(chunksPerTransaction) || chunksPerTransaction <= 0) {
+        throw new Error('chunksPerTransaction must be a positive integer');
+    }
+    const batchedGroups = [];
+    for (let i = 0; i < chunkInstructionGroups.length; i += chunksPerTransaction) {
+        const mergedGroup = chunkInstructionGroups
+            .slice(i, i + chunksPerTransaction)
+            .flat();
+        batchedGroups.push(dedupeInitBinArrayInstructions(mergedGroup));
+    }
+    return batchedGroups;
+}
 class Transactions {
     /**
      * Prohibit creating instance other than getInstance
@@ -4437,16 +4486,21 @@ class Transactions {
             }
             for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
                 const chunk = chunks[chunkIndex];
-                const mergedLayer = chunk.layers.reduce((acc, l) => ({
-                    x0: acc.x0.add(l.params.x0),
-                    y0: acc.y0.add(l.params.y0),
-                    deltaX: acc.deltaX.add(l.params.deltaX),
-                    deltaY: acc.deltaY.add(l.params.deltaY),
-                }), { x0: new bn_js_1.default(0), y0: new bn_js_1.default(0), deltaX: new bn_js_1.default(0), deltaY: new bn_js_1.default(0) });
-                const onChainParams = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(mergedLayer.x0, mergedLayer.y0, mergedLayer.deltaX, mergedLayer.deltaY);
-                const mergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), chunk.minDeltaId, chunk.maxDeltaId, mergedLayer.deltaX, mergedLayer.deltaY, mergedLayer.x0, mergedLayer.y0, binStep, favorXInActiveId);
-                const chunkMaxX = mergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                const chunkMaxY = mergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
+                const chunkAddLiquidityParams = chunk.layers.map(layer => {
+                    const onChainParams = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(layer.params.x0, layer.params.y0, layer.params.deltaX, layer.params.deltaY);
+                    return {
+                        minDeltaId: chunk.minDeltaId.toNumber(),
+                        maxDeltaId: chunk.maxDeltaId.toNumber(),
+                        x0: onChainParams.x0,
+                        y0: onChainParams.y0,
+                        deltaX: onChainParams.deltaX,
+                        deltaY: onChainParams.deltaY,
+                        bitFlag: onChainParams.bitFlag,
+                        favorXInActiveId,
+                    };
+                });
+                const chunkMaxX = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountX), new bn_js_1.default(0));
+                const chunkMaxY = chunk.layers.reduce((s, layer) => s.add(layer.maxAmountY), new bn_js_1.default(0));
                 const instructions = [];
                 if (!depositIncluded) {
                     depositIncluded = true;
@@ -4482,18 +4536,7 @@ class Transactions {
                     minWithdrawYAmount: new bn_js_1.default(0),
                     maxDepositYAmount: chunkMaxY,
                     removeLiquidityParams: [],
-                    addLiquidityParams: [
-                        {
-                            minDeltaId: chunk.minDeltaId.toNumber(),
-                            maxDeltaId: chunk.maxDeltaId.toNumber(),
-                            x0: onChainParams.x0,
-                            y0: onChainParams.y0,
-                            deltaX: onChainParams.deltaX,
-                            deltaY: onChainParams.deltaY,
-                            bitFlag: onChainParams.bitFlag,
-                            favorXInActiveId,
-                        },
-                    ],
+                    addLiquidityParams: chunkAddLiquidityParams,
                 });
                 instructions.push({
                     instruction: depositIx,
@@ -4823,7 +4866,7 @@ class Transactions {
                                 };
                             return {
                                 instruction: ix,
-                                label: 'Add liquidity by strategy (meteora deposit)'
+                                label: 'Add liquidity by strategy (meteora deposit)',
                             };
                         }),
                     ];
@@ -6626,34 +6669,21 @@ class Transactions {
                     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) {
-                        // Merge all layers into a single AddLiquidityParams entry per chunk (see comment above).
-                        const chunkMergedLayer = chunk.layers.reduce((acc, l) => ({
-                            x0: acc.x0.add(l.params.x0),
-                            y0: acc.y0.add(l.params.y0),
-                            deltaX: acc.deltaX.add(l.params.deltaX),
-                            deltaY: acc.deltaY.add(l.params.deltaY),
-                        }), {
-                            x0: new bn_js_1.default(0),
-                            y0: new bn_js_1.default(0),
-                            deltaX: new bn_js_1.default(0),
-                            deltaY: new bn_js_1.default(0),
-                        });
-                        const chunkMergedP = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunkMergedLayer.x0, chunkMergedLayer.y0, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY);
-                        const chunkAddLiquidityParams = [
-                            {
+                        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: chunkMergedP.x0,
-                                y0: chunkMergedP.y0,
-                                deltaX: chunkMergedP.deltaX,
-                                deltaY: chunkMergedP.deltaY,
-                                bitFlag: chunkMergedP.bitFlag,
+                                x0: onChainParams.x0,
+                                y0: onChainParams.y0,
+                                deltaX: onChainParams.deltaX,
+                                deltaY: onChainParams.deltaY,
+                                bitFlag: onChainParams.bitFlag,
                                 favorXInActiveId,
-                            },
-                        ];
-                        const chunkMergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), chunk.minDeltaId, chunk.maxDeltaId, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY, chunkMergedLayer.x0, chunkMergedLayer.y0, binStep, favorXInActiveId);
-                        const chunkTotalMaxX = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                        const chunkTotalMaxY = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
+                            };
+                        });
+                        const 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 => ({
@@ -6699,11 +6729,13 @@ class Transactions {
                     checkRange: params.checkRange,
                     pdaTokenType: types_1.TokenType.ATA,
                 });
-                rebuildTxGroups.push([{
+                rebuildTxGroups.push([
+                    {
                         label: 'sweep_dust',
                         class: CLASS,
                         instruction: sweepIx,
-                    }]);
+                    },
+                ]);
                 // =========================================================================
                 // Assemble final TX list
                 // =========================================================================
@@ -6727,6 +6759,309 @@ class Transactions {
             }
         });
     }
+    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)
+                // =========================================================================
+                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;
+                const binStep = new bn_js_1.default(lbPairState.binStep);
+                const contractLayers = layers.map(l => ({
+                    strategyTypeX: (0, liquidityStrategy_1.distributionToStrategyType)(l.x.distribution),
+                    strategyTypeY: (0, liquidityStrategy_1.distributionToStrategyType)(l.y.distribution),
+                    percentageX: l.x.percentage,
+                    percentageY: l.y.percentage,
+                }));
+                // Build init + extend instructions
+                const initExtendIxs = [];
+                const initWidth = Math.min(MAX_INIT_WIDTH, newWidth);
+                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;
+                }
+                const rebuildTxGroups = [];
+                if (newWidth <= maxBinsPerDepositChunk) {
+                    const binArrayInitIxs = yield this._initBinArraysForRange(connection, lbPair, dlmmPool, newLowerBinId, newUpperBinId);
+                    const binArrayInitIxsLabeled = binArrayInitIxs.map(ix => ({
+                        label: 'init_bin_array',
+                        class: CLASS,
+                        instruction: ix,
+                    }));
+                    if (useLayeredDepositsForSmallPosition) {
+                        const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                            hybridDistribution: layers,
+                            amountX: effectiveAmountX,
+                            amountY: effectiveAmountY,
+                            minDeltaId: new bn_js_1.default(minDeltaId),
+                            maxDeltaId: new bn_js_1.default(maxDeltaId),
+                            binStep,
+                            activeId: new bn_js_1.default(activeId),
+                        });
+                        rebuildTxGroups.push(initExtendIxs);
+                        const layeredDepositIxs = [
+                            ...binArrayInitIxsLabeled,
+                        ];
+                        for (let i = 0; i < strategyResults.length; i++) {
+                            const layerStrategy = strategyResults[i];
+                            if (layerStrategy.maxAmountX.isZero() && layerStrategy.maxAmountY.isZero()) {
+                                continue;
+                            }
+                            const singleLayer = {
+                                strategyTypeX: contractLayers[i].strategyTypeX,
+                                strategyTypeY: contractLayers[i].strategyTypeY,
+                                percentageX: layers[i].x.percentage > 0 ? 100 : 0,
+                                percentageY: layers[i].y.percentage > 0 ? 100 : 0,
+                            };
+                            const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                                connection,
+                                userWallet: params.userWallet,
+                                lbPair,
+                                position: params.newPosition,
+                                tokenXMint,
+                                tokenYMint,
+                                tokenXProgram,
+                                tokenYProgram,
+                                layers: [singleLayer],
+                                checkRange: params.checkRange,
+                                userTokenXAmount: layerStrategy.maxAmountX,
+                                userTokenYAmount: layerStrategy.maxAmountY,
+                                remainingAccountsInfo: baseRemainingAccountsInfo,
+                                pdaTokenType: types_1.TokenType.ATA,
+                                lowerBinId: newLowerBinId,
+                                upperBinId: newUpperBinId,
+                            });
+                            layeredDepositIxs.push({ label: 'deposit_v2', class: CLASS, instruction: depositIx });
+                        }
+                        if (layeredDepositIxs.length > 0) {
+                            rebuildTxGroups.push(layeredDepositIxs);
+                        }
+                    }
+                    else {
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.newPosition,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            checkRange: params.checkRange,
+                            userTokenXAmount: effectiveAmountX,
+                            userTokenYAmount: effectiveAmountY,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            lowerBinId: newLowerBinId,
+                            upperBinId: newUpperBinId,
+                        });
+                        if (newWidth <= MAX_INIT_WIDTH) {
+                            rebuildTxGroups.push([
+                                ...initExtendIxs,
+                                ...binArrayInitIxsLabeled,
+                                { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                            ]);
+                        }
+                        else {
+                            rebuildTxGroups.push(initExtendIxs);
+                            rebuildTxGroups.push([
+                                ...binArrayInitIxsLabeled,
+                                { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                            ]);
+                        }
+                    }
+                }
+                else {
+                    rebuildTxGroups.push(initExtendIxs);
+                    const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                        hybridDistribution: layers,
+                        amountX: effectiveAmountX,
+                        amountY: effectiveAmountY,
+                        minDeltaId: new bn_js_1.default(minDeltaId),
+                        maxDeltaId: new bn_js_1.default(maxDeltaId),
+                        binStep,
+                        activeId: new bn_js_1.default(activeId),
+                    });
+                    const depositChunks = (0, liquidityStrategy_1.chunkHybridDepositParameters)(strategyResults, new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), new bn_js_1.default(activeId), binStep, maxBinsPerDepositChunk, favorXInActiveId);
+                    const chunkInstructionGroups = [];
+                    for (const chunk of depositChunks) {
+                        const { chunkLowerOffset, chunkUpperOffset } = getHybridChunkOffsets(newLowerBinId, chunk.lowerBinId, chunk.upperBinId);
+                        const chunkAmountX = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountX), new bn_js_1.default(0));
+                        const chunkAmountY = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountY), new bn_js_1.default(0));
+                        if (chunkAmountX.isZero() && chunkAmountY.isZero()) {
+                            continue;
+                        }
+                        const binArrayInitIxs = yield this._initBinArraysForRange(connection, lbPair, dlmmPool, chunk.lowerBinId, chunk.upperBinId);
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.newPosition,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            checkRange: params.checkRange,
+                            userTokenXAmount: chunkAmountX,
+                            userTokenYAmount: chunkAmountY,
+                            chunkLowerOffset,
+                            chunkUpperOffset,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            lowerBinId: chunk.lowerBinId,
+                            upperBinId: chunk.upperBinId,
+                        });
+                        chunkInstructionGroups.push([
+                            ...binArrayInitIxs.map(ix => ({
+                                label: 'init_bin_array',
+                                class: CLASS,
+                                instruction: ix,
+                            })),
+                            { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                        ]);
+                    }
+                    rebuildTxGroups.push(...batchHybridChunkInstructionGroups(chunkInstructionGroups, CHUNKS_PER_TRANSACTION));
+                }
+                // =========================================================================
+                // 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 V2 AUTOMATION ERROR ===');
+                console.error('Error:', error instanceof Error ? error.message : String(error));
+                console.error('Stack:', error instanceof Error ? error.stack : 'No stack trace');
+                console.error('=== END ERROR LOG ===');
+                throw error;
+            }
+        });
+    }
     /**
      * Hybrid liquidity redeposit for automation: withdraw all liquidity from the same
      * position and re-deposit with independent X/Y distributions per layer.
@@ -6756,9 +7091,13 @@ class Transactions {
                     userWallet: params.userWallet,
                     position: params.position,
                     compound: params.compound,
-                    targetActiveBin: params.targetActiveBin,
+                    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;
@@ -6858,34 +7197,21 @@ class Transactions {
                     // 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) {
-                        // Merge all layers into a single AddLiquidityParams entry per chunk (see comment above).
-                        const chunkMergedLayer = chunk.layers.reduce((acc, l) => ({
-                            x0: acc.x0.add(l.params.x0),
-                            y0: acc.y0.add(l.params.y0),
-                            deltaX: acc.deltaX.add(l.params.deltaX),
-                            deltaY: acc.deltaY.add(l.params.deltaY),
-                        }), {
-                            x0: new bn_js_1.default(0),
-                            y0: new bn_js_1.default(0),
-                            deltaX: new bn_js_1.default(0),
-                            deltaY: new bn_js_1.default(0),
-                        });
-                        const chunkMergedP = (0, liquidityStrategy_1.buildBitFlagAndNegateStrategyParameters)(chunkMergedLayer.x0, chunkMergedLayer.y0, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY);
-                        const chunkAddLiquidityParams = [
-                            {
+                        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: chunkMergedP.x0,
-                                y0: chunkMergedP.y0,
-                                deltaX: chunkMergedP.deltaX,
-                                deltaY: chunkMergedP.deltaY,
-                                bitFlag: chunkMergedP.bitFlag,
+                                x0: onChainParams.x0,
+                                y0: onChainParams.y0,
+                                deltaX: onChainParams.deltaX,
+                                deltaY: onChainParams.deltaY,
+                                bitFlag: onChainParams.bitFlag,
                                 favorXInActiveId,
-                            },
-                        ];
-                        const chunkMergedBinsAmounts = (0, liquidityStrategy_1.toAmountIntoBins)(new bn_js_1.default(activeId), chunk.minDeltaId, chunk.maxDeltaId, chunkMergedLayer.deltaX, chunkMergedLayer.deltaY, chunkMergedLayer.x0, chunkMergedLayer.y0, binStep, favorXInActiveId);
-                        const chunkTotalMaxX = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountX), new bn_js_1.default(0));
-                        const chunkTotalMaxY = chunkMergedBinsAmounts.reduce((s, b) => s.add(b.amountY), new bn_js_1.default(0));
+                            };
+                        });
+                        const 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,
@@ -6924,11 +7250,13 @@ class Transactions {
                     optionalTokenYAmount: undefined, // sweep — use full ATA balance
                     pdaTokenType: types_1.TokenType.ATA,
                 });
-                depositTxGroups.push([{
+                depositTxGroups.push([
+                    {
                         label: 'sweep_dust',
                         class: CLASS,
                         instruction: sweepIx,
-                    }]);
+                    },
+                ]);
                 // =========================================================================
                 // Assemble final TX list
                 // =========================================================================
@@ -6952,6 +7280,215 @@ class Transactions {
             }
         });
     }
+    meteoraRedepositHybridLiquidityV2Automation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            var _b, _c;
+            try {
+                const MAX_BINS_PER_WITHDRAW_CHUNK = 150;
+                const CHUNKS_PER_TRANSACTION = 3;
+                const CLASS = 'meteoraRedepositHybridLiquidityV2Automation';
+                // --- Validate layers ---
+                const layers = params.layers;
+                if (layers.length === 0 || layers.length > 3) {
+                    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, upperBinId, estimatedTotalX, estimatedTotalY, activeId, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, withdrawFn, baseRemainingAccountsInfo, } = yield this.resolvePositionContext({
+                    connection,
+                    userWallet: params.userWallet,
+                    position: params.position,
+                    compound: params.compound,
+                    targetActiveBin: params.targetActiveBin,
+                    skipClaim: true,
+                });
+                const positionWidth = upperBinId - lowerBinId + 1;
+                const maxBinsPerDepositChunk = positionWidth === 69 ? 69 : 50;
+                const useLayeredDepositsForSmallPosition = positionWidth <= 69 && layers.length > 1;
+                const effectiveAmountX = (_b = params.amountXOverride) !== null && _b !== void 0 ? _b : estimatedTotalX;
+                const effectiveAmountY = (_c = params.amountYOverride) !== null && _c !== void 0 ? _c : estimatedTotalY;
+                const favorXInActiveId = effectiveAmountY.isZero() && !effectiveAmountX.isZero();
+                const minDeltaId = lowerBinId - activeId;
+                const maxDeltaId = upperBinId - activeId;
+                const binStep = new bn_js_1.default(lbPairState.binStep);
+                const contractLayers = layers.map(l => ({
+                    strategyTypeX: (0, liquidityStrategy_1.distributionToStrategyType)(l.x.distribution),
+                    strategyTypeY: (0, liquidityStrategy_1.distributionToStrategyType)(l.y.distribution),
+                    percentageX: l.x.percentage,
+                    percentageY: l.y.percentage,
+                }));
+                // =========================================================================
+                // PHASE 1: WITHDRAW (no close — same position)
+                // =========================================================================
+                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 via new add_liquidity_2 instruction)
+                // =========================================================================
+                const depositTxGroups = [];
+                if (positionWidth <= maxBinsPerDepositChunk) {
+                    if (useLayeredDepositsForSmallPosition) {
+                        const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                            hybridDistribution: layers,
+                            amountX: effectiveAmountX,
+                            amountY: effectiveAmountY,
+                            minDeltaId: new bn_js_1.default(minDeltaId),
+                            maxDeltaId: new bn_js_1.default(maxDeltaId),
+                            binStep,
+                            activeId: new bn_js_1.default(activeId),
+                        });
+                        const layeredDepositIxs = [];
+                        for (let i = 0; i < strategyResults.length; i++) {
+                            const layerStrategy = strategyResults[i];
+                            if (layerStrategy.maxAmountX.isZero() && layerStrategy.maxAmountY.isZero()) {
+                                continue;
+                            }
+                            const singleLayer = {
+                                strategyTypeX: contractLayers[i].strategyTypeX,
+                                strategyTypeY: contractLayers[i].strategyTypeY,
+                                percentageX: layers[i].x.percentage > 0 ? 100 : 0,
+                                percentageY: layers[i].y.percentage > 0 ? 100 : 0,
+                            };
+                            const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                                connection,
+                                userWallet: params.userWallet,
+                                lbPair,
+                                position: params.position,
+                                tokenXMint,
+                                tokenYMint,
+                                tokenXProgram,
+                                tokenYProgram,
+                                layers: [singleLayer],
+                                userTokenXAmount: layerStrategy.maxAmountX,
+                                userTokenYAmount: layerStrategy.maxAmountY,
+                                remainingAccountsInfo: baseRemainingAccountsInfo,
+                                pdaTokenType: types_1.TokenType.ATA,
+                                lowerBinId,
+                                upperBinId,
+                            });
+                            layeredDepositIxs.push({ label: 'deposit_v2', class: CLASS, instruction: depositIx });
+                        }
+                        if (layeredDepositIxs.length > 0) {
+                            depositTxGroups.push(layeredDepositIxs);
+                        }
+                    }
+                    else {
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.position,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            userTokenXAmount: effectiveAmountX,
+                            userTokenYAmount: effectiveAmountY,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            lowerBinId,
+                            upperBinId,
+                        });
+                        depositTxGroups.push([
+                            { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                        ]);
+                    }
+                }
+                else {
+                    const strategyResults = (0, liquidityStrategy_1.distributionToHybridStrategy)({
+                        hybridDistribution: layers,
+                        amountX: effectiveAmountX,
+                        amountY: effectiveAmountY,
+                        minDeltaId: new bn_js_1.default(minDeltaId),
+                        maxDeltaId: new bn_js_1.default(maxDeltaId),
+                        binStep,
+                        activeId: new bn_js_1.default(activeId),
+                    });
+                    const depositChunks = (0, liquidityStrategy_1.chunkHybridDepositParameters)(strategyResults, new bn_js_1.default(minDeltaId), new bn_js_1.default(maxDeltaId), new bn_js_1.default(activeId), binStep, maxBinsPerDepositChunk, favorXInActiveId);
+                    const chunkInstructionGroups = [];
+                    for (const chunk of depositChunks) {
+                        const { chunkLowerOffset, chunkUpperOffset } = getHybridChunkOffsets(lowerBinId, chunk.lowerBinId, chunk.upperBinId);
+                        const chunkAmountX = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountX), new bn_js_1.default(0));
+                        const chunkAmountY = chunk.layers.reduce((sum, layer) => sum.add(layer.maxAmountY), new bn_js_1.default(0));
+                        if (chunkAmountX.isZero() && chunkAmountY.isZero()) {
+                            continue;
+                        }
+                        const depositIx = yield this.ix.meteoraDlmm.addLiquidity2Automation({
+                            connection,
+                            userWallet: params.userWallet,
+                            lbPair,
+                            position: params.position,
+                            tokenXMint,
+                            tokenYMint,
+                            tokenXProgram,
+                            tokenYProgram,
+                            layers: contractLayers,
+                            userTokenXAmount: chunkAmountX,
+                            userTokenYAmount: chunkAmountY,
+                            chunkLowerOffset,
+                            chunkUpperOffset,
+                            remainingAccountsInfo: baseRemainingAccountsInfo,
+                            pdaTokenType: types_1.TokenType.ATA,
+                            lowerBinId: chunk.lowerBinId,
+                            upperBinId: chunk.upperBinId,
+                        });
+                        chunkInstructionGroups.push([
+                            { label: 'deposit_v2', class: CLASS, instruction: depositIx },
+                        ]);
+                    }
+                    depositTxGroups.push(...batchHybridChunkInstructionGroups(chunkInstructionGroups, CHUNKS_PER_TRANSACTION));
+                }
+                // =========================================================================
+                // 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 V2 AUTOMATION ERROR ===');
+                console.error('Error:', error instanceof Error ? error.message : String(error));
+                console.error('Stack:', error instanceof Error ? error.stack : 'No stack trace');
+                console.error('=== END ERROR LOG ===');
+                throw error;
+            }
+        });
+    }
     /**
      * Compute the bin range to use for a dust sweep deposit.
      *
@@ -7019,7 +7556,10 @@ class Transactions {
             if (userPosition === undefined) {
                 throw new Error(`Unexpected error: Position (${position}) doesn't exist on-chain`);
             }
-            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [tokenXMint, tokenYMint]);
+            const tokenProgramMap = yield (0, functions_1.getTokenProgramMapForMints)(connection, [
+                tokenXMint,
+                tokenYMint,
+            ]);
             const tokenXProgram = tokenProgramMap[tokenXMint.toString()];
             const tokenYProgram = tokenProgramMap[tokenYMint.toString()];
             const baseRemainingAccountsInfo = yield (0, functions_1.fetchRemainingAccountsInfo)(connection, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
@@ -7052,8 +7592,14 @@ class Transactions {
             const combinedAccounts = [];
             const xSlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookX);
             const ySlice = baseRemainingAccountsInfo.slices.find(s => s.accountsType === types_1.RemainingAccountsType.TransferHookY);
-            combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookX, length: (_b = xSlice === null || xSlice === void 0 ? void 0 : xSlice.length) !== null && _b !== void 0 ? _b : 0 });
-            combinedSlices.push({ accountsType: types_1.RemainingAccountsType.TransferHookY, length: (_c = ySlice === null || ySlice === void 0 ? void 0 : ySlice.length) !== null && _c !== void 0 ? _c : 0 });
+            combinedSlices.push({
+                accountsType: types_1.RemainingAccountsType.TransferHookX,
+                length: (_b = xSlice === null || xSlice === void 0 ? void 0 : xSlice.length) !== null && _b !== void 0 ? _b : 0,
+            });
+            combinedSlices.push({
+                accountsType: types_1.RemainingAccountsType.TransferHookY,
+                length: (_c = ySlice === null || ySlice === void 0 ? void 0 : ySlice.length) !== null && _c !== void 0 ? _c : 0,
+            });
             combinedAccounts.push(...baseRemainingAccountsInfo.accounts);
             for (const reward of rewardInfos) {
                 const rewardTransferHookInfo = yield (0, functions_1.fetchRemainingAccountsInfoForReward)(connection, reward.rewardMint, reward.rewardTokenProgram);
@@ -7081,12 +7627,16 @@ class Transactions {
             const feeY = positionData.feeY;
             const HAWK_FEE_BPS = 800;
             const FEE_BPS_DENOM = 10000;
-            const netFeeX = feeX.mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS)).div(new bn_js_1.default(FEE_BPS_DENOM));
-            const netFeeY = feeY.mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS)).div(new bn_js_1.default(FEE_BPS_DENOM));
-            const estimatedTotalX = (compound && !skipClaim)
+            const netFeeX = feeX
+                .mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS))
+                .div(new bn_js_1.default(FEE_BPS_DENOM));
+            const netFeeY = feeY
+                .mul(new bn_js_1.default(FEE_BPS_DENOM - HAWK_FEE_BPS))
+                .div(new bn_js_1.default(FEE_BPS_DENOM));
+            const estimatedTotalX = compound && !skipClaim
                 ? new bn_js_1.default(positionData.totalXAmount).add(netFeeX)
                 : new bn_js_1.default(positionData.totalXAmount);
-            const estimatedTotalY = (compound && !skipClaim)
+            const estimatedTotalY = compound && !skipClaim
                 ? new bn_js_1.default(positionData.totalYAmount).add(netFeeY)
                 : new bn_js_1.default(positionData.totalYAmount);
             const _rebalanceLiquidityAutomation = (_a) => __awaiter(this, [_a], void 0, function* ({ position, maxDepositXAmount, maxDepositYAmount, pdaTokenType, shrinkMode, shouldClaimFee, shouldClaimReward, removeLiquidityParams, addLiquidityParams, maxActiveBinSlippage, }) {
@@ -7095,7 +7645,10 @@ class Transactions {
                     userWallet: userWallet,
                     position,
                     lbPair,
-                    tokenXMint, tokenYMint, tokenXProgram, tokenYProgram,
+                    tokenXMint,
+                    tokenYMint,
+                    tokenXProgram,
+                    tokenYProgram,
                     activeId,
                     pdaTokenType,
                     maxActiveBinSlippage,
@@ -7127,7 +7680,9 @@ class Transactions {
                 });
             });
             const withdrawFn = (_a) => __awaiter(this, [_a], void 0, function* ({ position, minBinId, maxBinId, compound, origin, }) {
-                const pdaTokenTypeForClaimables = compound ? types_1.TokenType.ATA : types_1.TokenType.STA;
+                const pdaTokenTypeForClaimables = compound
+                    ? types_1.TokenType.ATA
+                    : types_1.TokenType.STA;
                 const ixs = [];
                 if (!skipClaim) {
                     // 1. Claim fees with hawk-side cut (must happen before withdraw+shrink invalidates position)
@@ -7179,7 +7734,7 @@ class Transactions {
                         maxBinId,
                         shouldClaimReward: false,
                         shouldClaimFee: false,
-                        shrinkMode: types_3.ShrinkMode.Default,
+                        shrinkMode: types_3.ShrinkMode.NoShrinkBoth,
                         pdaTokenType: types_1.TokenType.ATA,
                     }),
                 });
@@ -7261,17 +7816,18 @@ class Transactions {
             const ownerFeeReward = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, pool.rewardMint);
             // Mints that need ATAs on userPdaLamport (for withdrawal)
             const withdrawMints = [
-                ...new Set([
-                    pool.tokenMint.toString(),
-                    pool.rewardMint.toString(),
-                ]),
+                ...new Set([pool.tokenMint.toString(), pool.rewardMint.toString()]),
             ].map(v => new web3.PublicKey(v));
             // 1. Init ATAs for output token + reward on user PDA lamport
             const initAtaIxs = withdrawMints.map(mint => {
                 return (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(userWallet, (0, functions_1.generateAta)(userPdaLamport, mint), userPdaLamport, mint);
             });
             // Init ATAs for reward-related tokens on userPda (for harvest)
-            const initHarvestAtaIxs = [pool.lpMint, pool.rewardMint, addresses_1.SABER_IOU_MINT].map(mint => {
+            const initHarvestAtaIxs = [
+                pool.lpMint,
+                pool.rewardMint,
+                addresses_1.SABER_IOU_MINT,
+            ].map(mint => {
                 return (0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(userWallet, (0, functions_1.generateAta)(userPda, mint), userPda, mint);
             });
             // 2. Harvest rewards from Quarry