@hawksightco/hawk-sdk 1.3.265 → 1.3.267

package/dist/ixGenerator/MeteoraDlmmIxGenerator.js

@@ -0,0 +1,3008 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeteoraDlmmIxGenerator = exports.StrategyType = void 0;
+exports.mapOldStrategyTypeToNew = mapOldStrategyTypeToNew;
+exports.buildBaseClosePosition2AutomationIx = buildBaseClosePosition2AutomationIx;
+const web3 = __importStar(require("@solana/web3.js"));
+const anchor_1 = require("../anchor");
+const functions_1 = require("../functions");
+const addresses_1 = require("../addresses");
+const meteora_1 = require("../meteora");
+const dlmm_1 = __importDefault(require("@meteora-ag/dlmm"));
+const types_1 = require("../types");
+const bn_js_1 = __importDefault(require("bn.js"));
+const AccountCache_1 = require("../classes/account-cache/AccountCache");
+const MintCache_1 = require("../classes/account-cache/MintCache");
+const util = __importStar(require("../functions"));
+/**
+ * Meteora event authority
+ */
+const METEORA_EVENT_AUTHORITY = new web3.PublicKey('D1ZN9Wj1fRSUQfCjhvnu1hqDMT7hzjzBBpi12nVniYD6');
+/**
+ * Meteora Program ID
+ */
+const METEORA_DLMM_PROGRAM = new web3.PublicKey('LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo');
+var StrategyType;
+(function (StrategyType) {
+    StrategyType[StrategyType["Spot"] = 0] = "Spot";
+    StrategyType[StrategyType["Curve"] = 1] = "Curve";
+    StrategyType[StrategyType["BidAsk"] = 2] = "BidAsk";
+})(StrategyType || (exports.StrategyType = StrategyType = {}));
+// Backwards-compatible mapping from old StrategyType to new StrategyType
+function mapOldStrategyTypeToNew(oldStrategyType) {
+    // Handle the old enum values (0-8) and map them to the new simplified enum
+    switch (oldStrategyType) {
+        case 0: // SpotOneSide
+        case 3: // SpotBalanced
+        case 6: // SpotImBalanced
+            return StrategyType.Spot;
+        case 1: // CurveOneSide
+        case 4: // CurveBalanced
+        case 7: // CurveImBalanced
+            return StrategyType.Curve;
+        case 2: // BidAskOneSide
+        case 5: // BidAskBalanced
+        case 8: // BidAskImBalanced
+            return StrategyType.BidAsk;
+        default:
+            // Default fallback
+            return StrategyType.Spot;
+    }
+}
+function buildBaseClosePosition2AutomationIx({ userPda, hawksightAuthority, authority, position, lbPair, fuelAccount, isHawkRefund, }) {
+    return new web3.TransactionInstruction({
+        data: Buffer.concat([
+            Buffer.from(util.sighash('meteora_dlmm_base_close_position_automation', undefined, true)),
+            Buffer.from([isHawkRefund ? 1 : 0]),
+        ]),
+        keys: [
+            { pubkey: userPda, isSigner: false, isWritable: false },
+            { pubkey: hawksightAuthority, isSigner: true, isWritable: true },
+            { pubkey: authority, isSigner: false, isWritable: true },
+            { pubkey: position, isSigner: false, isWritable: true },
+            { pubkey: lbPair, isSigner: false, isWritable: true },
+            { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+            { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+            { pubkey: fuelAccount, isSigner: false, isWritable: true },
+        ],
+        programId: addresses_1.IYF_EXTENSION,
+    });
+}
+/**
+ * Meteora related instructions executed via iyf extension or iyf main
+ */
+class MeteoraDlmmIxGenerator {
+    constructor(ix, pda) {
+        this.ix = ix;
+        this.pda = pda;
+    }
+    /**
+     * Initialize a Meteora DLMM position via IYF Main's meteora dynamic CPI.
+     *
+     * This is the raw Meteora initializePosition instruction invoked through IYF Main.
+     *
+     * @param connection - Solana connection
+     * @param params - Initialize position parameters (Meteora-aligned: lowerBinId, width)
+     * @returns TransactionInstruction for initializing the position
+     */
+    initializePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, lowerBinId, width, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Build instruction data: sighash + lowerBinId (i32) + width (i32)
+            const lowerBinIdBuffer = Buffer.alloc(4);
+            lowerBinIdBuffer.writeInt32LE(lowerBinId, 0);
+            const widthBuffer = Buffer.alloc(4);
+            widthBuffer.writeInt32LE(width, 0);
+            // Build raw Meteora instruction (accounts only - no hawksight wrapper accounts)
+            // meteoraDynamicCpi will prepend userPda and authority
+            const meteoraIx = new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    Buffer.from(util.sighash('initialize_position')),
+                    lowerBinIdBuffer,
+                    widthBuffer,
+                ]),
+                keys: [
+                    { pubkey: userWallet, isSigner: false, isWritable: true }, // payer (Mutable, Signer - signed by IYF Main)
+                    { pubkey: position, isSigner: true, isWritable: true }, // position (Mutable, Signer)
+                    { pubkey: lbPair, isSigner: false, isWritable: false }, // lbPair
+                    { pubkey: userPda, isSigner: false, isWritable: false }, // owner (Signer - signed by IYF Main)
+                    {
+                        pubkey: web3.SystemProgram.programId,
+                        isSigner: false,
+                        isWritable: false,
+                    }, // systemProgram
+                    { pubkey: web3.SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }, // rent
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false }, // eventAuthority (PDA)
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false }, // program
+                ],
+                programId: METEORA_DLMM_PROGRAM,
+            });
+            return yield this.ix.iyfMain.meteoraDynamicCpi({
+                connection,
+                userWallet,
+                meteoraIx,
+            });
+        });
+    }
+    initializePositionAutomation(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, lowerBinId, upperBinId, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user pda
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate instruction
+            const width = upperBinId - lowerBinId + 1;
+            // @ts-ignore
+            const iyfExtensionIx = yield anchor_1.Anchor.instance()
+                .iyfExtension.methods.meteoraDlmmInitializePositionAutomation(lowerBinId, width)
+                .accounts({
+                farm: addresses_1.USDC_FARM,
+                userPda,
+                authority: userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                hawksightAuthority: addresses_1.HS_AUTHORITY,
+                position,
+                lbPair,
+                systemProgram: web3.SystemProgram.programId,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                eventAuthority: METEORA_EVENT_AUTHORITY,
+                meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+            })
+                .instruction();
+            // Set position to writable
+            iyfExtensionIx.keys = iyfExtensionIx.keys.map(meta => {
+                if (meta.pubkey === position) {
+                    meta.isWritable = true;
+                }
+                return meta;
+            });
+            return this.ix.iyfMain.iyfExtensionExecute(connection, {
+                userWallet,
+                iyfExtensionIx,
+            });
+        });
+    }
+    initializePositionRelativeAutomation(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, relativeLowerBinId, width, useFuelAccount, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Width > 70 is invalid (will error on-chain)
+            if (width > 70) {
+                throw new Error('Width exceeds maximum allowed 70 bins');
+            }
+            // Generate user pda
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate instruction
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        Buffer.from(util.sighash('meteora_dlmm_initialize_position_relative_automation')),
+                        new bn_js_1.default(relativeLowerBinId).toTwos(16).toArrayLike(Buffer, 'le', 2),
+                        Buffer.from([width]),
+                    ]),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: false },
+                        { pubkey: position, isSigner: true, isWritable: true },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        {
+                            pubkey: web3.SystemProgram.programId,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        {
+                            pubkey: web3.SYSVAR_RENT_PUBKEY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: true,
+                        },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: true },
+                        ...(useFuelAccount
+                            ? [
+                                {
+                                    pubkey: (0, functions_1.generateFuelAccount)(userWallet),
+                                    isSigner: false,
+                                    isWritable: true,
+                                },
+                            ]
+                            : []),
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    /**
+     * Add liquidity to an existing Meteora DLMM position using strategy parameters.
+     * This is the automation version that uses V2 execution (meteora_dlmm_deposit_2_automation).
+     *
+     * Key differences from depositAutomation:
+     * - Uses iyfExtensionExecuteV2 with Anchor-based instruction building
+     * - Supports remainingAccountsInfo for Token2022 transfer hooks
+     * - Authority is HS_AUTHORITY (automation wallet)
+     * - Does not require binArrayLower/binArrayUpper (bin arrays are auto-derived or created separately)
+     *
+     * @param connection - Solana connection
+     * @param params - AddLiquidityByStrategy2AutomationParams parameters
+     * @returns TransactionInstruction for adding liquidity
+     */
+    meteoraDlmmDepositRelativeAutomation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, activeId, relativeBinRange, strategyType, optionalTokenXAmount, optionalTokenYAmount, checkRange, remainingAccountsInfo, pdaTokenType, positionIsSigner = false, }) {
+            var _b, _c, _d, _e;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Derive reserves from the ACTUAL lbPair (not the one passed in, which may be incorrect)
+            const reserveX = this.pda.meteora.deriveReserve(tokenXMint, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenYMint, lbPair);
+            // Derive bin array bitmap extension from actual lb_pair and check if it exists
+            const derivedBinArrayBitmapExtension = this.pda.meteora.deriveBinArrayBitmapExtension(lbPair);
+            const binArrayBitmapExtensionInfo = yield connection.getAccountInfo(derivedBinArrayBitmapExtension);
+            const actualBinArrayBitmapExtension = binArrayBitmapExtensionInfo
+                ? derivedBinArrayBitmapExtension
+                : METEORA_DLMM_PROGRAM;
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Determine user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else {
+                // Default: ATA
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            // Serialize RemainingAccountsInfo as Vec<u8> (Borsh format)
+            // This is passed directly to the on-chain instruction which forwards it to Meteora
+            // For SPL tokens (non-Token2022), we still need to provide the slices structure with length=0
+            // This matches what Meteora SDK's getPotentialToken2022IxDataAndAccounts returns
+            // AccountsType enum: 0=TransferHookX, 1=TransferHookY, 2=TransferHookReward
+            const defaultSlices = [
+                { accountsType: 0, length: 0 }, // TransferHookX with 0 accounts
+                { accountsType: 1, length: 0 }, // TransferHookY with 0 accounts
+            ];
+            const remainingAccountsInfoSerialized = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.slices) !== null && _b !== void 0 ? _b : defaultSlices,
+            });
+            const lowerBinId = activeId + relativeBinRange.lowerRange;
+            const upperBinId = activeId + relativeBinRange.upperRange;
+            // Derive bin arrays needed for the deposit range using the lbPair from position
+            const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, lowerBinId, upperBinId);
+            const binArrayAccounts = binArrays.map(binArray => ({
+                pubkey: binArray,
+                isSigner: false,
+                isWritable: true,
+            }));
+            // Build remaining accounts: Token2022 transfer hook accounts first (described by remainingAccountsInfo),
+            // then bin arrays (not described - Meteora expects them at the end after transfer hooks)
+            const remainingAccounts = [
+                ...((_c = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.accounts) !== null && _c !== void 0 ? _c : []),
+                ...binArrayAccounts,
+            ];
+            const remainingAccountsInfoLength = Buffer.alloc(4);
+            remainingAccountsInfoLength.writeUInt32LE(remainingAccountsInfoSerialized.length, 0);
+            const relativeLowerRange = Buffer.alloc(2);
+            relativeLowerRange.writeInt16LE(relativeBinRange.lowerRange, 0);
+            const relativeUpperRange = Buffer.alloc(2);
+            relativeUpperRange.writeInt16LE(relativeBinRange.upperRange, 0);
+            const checkLowerRange = Buffer.alloc(4);
+            checkLowerRange.writeInt32LE((_d = checkRange === null || checkRange === void 0 ? void 0 : checkRange.lowerRange) !== null && _d !== void 0 ? _d : 0, 0);
+            const checkUpperRange = Buffer.alloc(4);
+            checkUpperRange.writeInt32LE((_e = checkRange === null || checkRange === void 0 ? void 0 : checkRange.upperRange) !== null && _e !== void 0 ? _e : 0, 0);
+            const optionalTokenXAmountBuffer = optionalTokenXAmount
+                ? Buffer.concat([
+                    Buffer.from([1]),
+                    Buffer.from(optionalTokenXAmount.toArrayLike(Buffer, 'le', 8)),
+                ])
+                : Buffer.from([0]);
+            const optionalTokenYAmountBuffer = optionalTokenYAmount
+                ? Buffer.concat([
+                    Buffer.from([1]),
+                    Buffer.from(optionalTokenYAmount.toArrayLike(Buffer, 'le', 8)),
+                ])
+                : Buffer.from([0]);
+            const remainingAccountsInfoSerializedWithLength = Buffer.concat([
+                remainingAccountsInfoLength,
+                remainingAccountsInfoSerialized,
+            ]);
+            // Use Anchor to serialize the instruction (ensures proper Borsh serialization)
+            // @ts-ignore
+            const depositIx = new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    Buffer.from(util.sighash('meteora_dlmm_deposit_relative_automation')),
+                    relativeLowerRange,
+                    relativeUpperRange,
+                    Buffer.from([strategyType]),
+                    optionalTokenXAmountBuffer,
+                    optionalTokenYAmountBuffer,
+                    Buffer.from(!!checkRange
+                        ? Buffer.concat([
+                            Buffer.from([1]),
+                            checkLowerRange,
+                            checkUpperRange,
+                        ])
+                        : Buffer.from([0])),
+                    remainingAccountsInfoSerializedWithLength,
+                ]),
+                keys: [
+                    { pubkey: userPda, isSigner: false, isWritable: false },
+                    { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: false },
+                    { pubkey: position, isSigner: positionIsSigner, isWritable: true },
+                    { pubkey: lbPair, isSigner: false, isWritable: true },
+                    { pubkey: userTokenX, isSigner: false, isWritable: true },
+                    { pubkey: userTokenY, isSigner: false, isWritable: true },
+                    { pubkey: reserveX, isSigner: false, isWritable: true },
+                    { pubkey: reserveY, isSigner: false, isWritable: true },
+                    { pubkey: tokenXMint, isSigner: false, isWritable: false },
+                    { pubkey: tokenYMint, isSigner: false, isWritable: false },
+                    { pubkey: tokenXProgram, isSigner: false, isWritable: false },
+                    { pubkey: tokenYProgram, isSigner: false, isWritable: false },
+                    {
+                        pubkey: actualBinArrayBitmapExtension,
+                        isSigner: false,
+                        isWritable: true,
+                    },
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: true },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: true },
+                    ...remainingAccounts,
+                ],
+                programId: addresses_1.IYF_EXTENSION,
+            });
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: depositIx,
+            });
+        });
+    }
+    redepositAutomation(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, relativeLowerBinId, relativeUpperBinId, strategyType, checkRange, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Meteora utility function
+            const fn = new meteora_1.MeteoraFunctions(this.ix);
+            // Generate user pda
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Get meteora pool
+            const lbPairInfo = yield anchor_1.Anchor.instance().meteoraProgram.account.lbPair.fetch(lbPair);
+            const tokenXMint = lbPairInfo.tokenXMint;
+            const tokenYMint = lbPairInfo.tokenYMint;
+            const reserveX = lbPairInfo.reserveX;
+            const reserveY = lbPairInfo.reserveY;
+            const userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint);
+            const userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint);
+            const activeBinId = lbPairInfo.activeId;
+            const MAX_BIN_ARRAY_SIZE = new bn_js_1.default(anchor_1.Anchor.instance().meteoraProgram.idl.constants[1].value);
+            // Get min and max bin id values from checkRange threshold
+            const { minBinId, maxBinId } = checkRange;
+            let _checkRange = [minBinId, maxBinId];
+            // Note: relative lower & upper bins can be positive or negative
+            const expectedMinBinId = activeBinId + relativeLowerBinId;
+            const expectedMaxBinId = activeBinId + relativeUpperBinId;
+            if (expectedMaxBinId < expectedMinBinId) {
+                throw new Error('Invalid bin range');
+            }
+            // get min and max bin +- 3
+            // this is to ensure that we allow for some buffer
+            let lowerTickArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, expectedMinBinId - 3, expectedMinBinId + 3);
+            let upperTickArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, expectedMaxBinId - 3, expectedMaxBinId + 3);
+            // Merge and remove duplicates
+            // it will handle overlapping tick arrays
+            // if lower is 1 2 3 4 5 6 7 and upper is 3 4 5 6 7 8 9
+            // we want to merge it to 1 2 3 4 5 6 7 8 9
+            const tickArrays = [
+                ...new Set([...lowerTickArrays, ...upperTickArrays]),
+            ];
+            // comment out for reference
+            // const lowerBinArrayIndex = fn.binIdToBinArrayIndex(MAX_BIN_ARRAY_SIZE, new BN(activeBinId - relativeLowerBinId));
+            // const binArrayLower = fn.deriveBinArray(lbPair, lowerBinArrayIndex);
+            // const binArrayUpper = fn.deriveBinArray(lbPair, lowerBinArrayIndex.add(new BN(1)));
+            // comment out for reference
+            // let _checkRange: null | [number, number];
+            // if (!!checkRange) {
+            //   const { minBinId, maxBinId } = checkRange;
+            //   _checkRange = [minBinId, maxBinId];
+            // } else {
+            //   _checkRange = null;
+            // }
+            // Generate instruction
+            return this.ix.iyfMain.iyfExtensionExecute(connection, {
+                userWallet,
+                // @ts-ignore
+                iyfExtensionIx: yield anchor_1.Anchor.instance()
+                    .iyfExtension.methods.meteoraDlmmRedepositAutomation(relativeLowerBinId, relativeUpperBinId, mapOldStrategyTypeToNew(strategyType), _checkRange)
+                    .accounts({
+                    farm: addresses_1.USDC_FARM,
+                    userPda,
+                    authority: userWallet,
+                    iyfProgram: addresses_1.IYF_MAIN,
+                    hawksightAuthority: addresses_1.HS_AUTHORITY,
+                    position,
+                    lbPair,
+                    userTokenX,
+                    userTokenY,
+                    reserveX,
+                    reserveY,
+                    tokenXMint,
+                    tokenYMint,
+                    // binArrayLower,
+                    // binArrayUpper,
+                    systemProgram: web3.SystemProgram.programId,
+                    tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                    rent: web3.SYSVAR_RENT_PUBKEY,
+                    eventAuthority: METEORA_EVENT_AUTHORITY,
+                    meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+                })
+                    .remainingAccounts(tickArrays.map((pubkey) => {
+                    return { pubkey, isSigner: false, isWritable: true };
+                }))
+                    .instruction(),
+            });
+        });
+    }
+    redepositAutomation2(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, relativeLowerBinId, relativeUpperBinId, strategyType, checkRange, targetActiveBin, }) {
+            try {
+                console.log('=== REDEPOSIT AUTOMATION 2 START ===');
+                console.log('Parameters:', {
+                    userWallet: userWallet.toString(),
+                    lbPair: lbPair.toString(),
+                    position: position.toString(),
+                    relativeLowerBinId,
+                    relativeUpperBinId,
+                    strategyType,
+                    checkRange,
+                });
+                // Initialize anchor
+                anchor_1.Anchor.initialize(connection);
+                // Meteora utility function
+                // const fn = new MeteoraFunctions(this.ix);
+                // Generate user pda
+                const userPda = (0, functions_1.generateUserPda)(userWallet);
+                console.log('User PDA generated:', userPda.toString());
+                // Get meteora pool
+                console.log('Fetching LB pair info...');
+                const lbPairInfo = yield anchor_1.Anchor.instance().meteoraProgram.account.lbPair.fetch(lbPair);
+                const tokenXMint = lbPairInfo.tokenXMint;
+                const tokenYMint = lbPairInfo.tokenYMint;
+                const mintAInfo = AccountCache_1.AccountCache.get(tokenXMint);
+                const mintBInfo = AccountCache_1.AccountCache.get(tokenYMint);
+                const tokenProgramA = mintAInfo === null || mintAInfo === void 0 ? void 0 : mintAInfo.info.owner;
+                const tokenProgramB = mintBInfo === null || mintBInfo === void 0 ? void 0 : mintBInfo.info.owner;
+                const reserveX = lbPairInfo.reserveX;
+                const reserveY = lbPairInfo.reserveY;
+                const userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, mintAInfo === null || mintAInfo === void 0 ? void 0 : mintAInfo.info.owner);
+                const userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, mintBInfo === null || mintBInfo === void 0 ? void 0 : mintBInfo.info.owner);
+                let activeBinId = lbPairInfo.activeId;
+                if (!!targetActiveBin) {
+                    activeBinId = targetActiveBin;
+                }
+                console.log('LB pair info:', {
+                    tokenXMint: tokenXMint.toString(),
+                    tokenYMint: tokenYMint.toString(),
+                    activeBinId: activeBinId.toString(),
+                });
+                // const MAX_BIN_ARRAY_SIZE = new BN(Anchor.instance().meteoraProgram.idl.constants[1].value);
+                // Get min and max bin id values from checkRange threshold
+                const { minBinId, maxBinId } = checkRange;
+                let _checkRange = [minBinId, maxBinId];
+                // Note: relative lower & upper bins can be positive or negative
+                const expectedMinBinId = activeBinId + relativeLowerBinId;
+                const expectedMaxBinId = activeBinId + relativeUpperBinId;
+                console.log('Bin calculations:', {
+                    activeBinId: activeBinId.toString(),
+                    relativeLowerBinId,
+                    relativeUpperBinId,
+                    expectedMinBinId,
+                    expectedMaxBinId,
+                });
+                if (expectedMaxBinId < expectedMinBinId) {
+                    throw new Error('Invalid bin range');
+                }
+                // get min and max bin +- 3
+                // this is to ensure that we allow for some buffer
+                // let lowerTickArrays = fn.findMeteoraTickArrays(lbPair, expectedMinBinId - 3, expectedMinBinId + 3);
+                // let upperTickArrays = fn.findMeteoraTickArrays(lbPair, expectedMaxBinId - 3, expectedMaxBinId + 3);
+                // Merge and remove duplicates
+                // it will handle overlapping tick arrays
+                // if lower is 1 2 3 4 5 6 7 and upper is 3 4 5 6 7 8 9
+                // we want to merge it to 1 2 3 4 5 6 7 8 9
+                // const tickArrays: web3.PublicKey[] = [...new Set([...lowerTickArrays, ...upperTickArrays])];
+                // comment out for reference
+                // const lowerBinArrayIndex = fn.binIdToBinArrayIndex(MAX_BIN_ARRAY_SIZE, new BN(activeBinId - relativeLowerBinId));
+                // const binArrayLower = fn.deriveBinArray(lbPair, lowerBinArrayIndex);
+                // const binArrayUpper = fn.deriveBinArray(lbPair, lowerBinArrayIndex.add(new BN(1)));
+                // comment out for reference
+                // let _checkRange: null | [number, number];
+                // if (!!checkRange) {
+                //   const { minBinId, maxBinId } = checkRange;
+                //   _checkRange = [minBinId, maxBinId];
+                // } else {
+                //   _checkRange = null;
+                // }
+                console.log('Creating DLMM instance...');
+                let DLMM = yield this.dlmm(connection, lbPair);
+                console.log('Calling addLiquidityByStrategy...');
+                const addLiquidityByStrategyTx = yield DLMM.dlmm.initializePositionAndAddLiquidityByStrategy({
+                    positionPubKey: position,
+                    totalXAmount: new bn_js_1.default(0),
+                    totalYAmount: new bn_js_1.default(0),
+                    strategy: {
+                        minBinId: expectedMinBinId,
+                        maxBinId: expectedMaxBinId,
+                        strategyType: mapOldStrategyTypeToNew(strategyType),
+                    },
+                    user: userWallet,
+                });
+                console.log('addLiquidityByStrategy completed, instruction count:', addLiquidityByStrategyTx.instructions.length);
+                // const addLiquidityByStrategyIxs = addLiquidityByStrategyTx.instructions.filter((ix) => ix.programId.equals(METEORA_DLMM_PROGRAM))
+                console.log('Filtering instructions for add_liquidity_by_strategy2...');
+                const addLiquidityByStrategyIx = addLiquidityByStrategyTx.instructions.filter(ix => {
+                    return (ix.programId.equals(METEORA_DLMM_PROGRAM) &&
+                        ix.data
+                            .subarray(0, 8)
+                            .equals(Buffer.from([3, 221, 149, 218, 111, 141, 118, 213])));
+                })[0];
+                const binArrayBitmapExtension = addLiquidityByStrategyIx.keys[2].pubkey;
+                if (!addLiquidityByStrategyIx) {
+                    throw new Error('add_liquidity_by_strategy2 instruction not found in transaction');
+                }
+                console.log('Found add_liquidity_by_strategy2 instruction');
+                // Log the instruction structure for debugging
+                console.log('Instruction keys count:', addLiquidityByStrategyIx.keys.length);
+                console.log('Instruction data length:', addLiquidityByStrategyIx.data.length);
+                // Find the correct slice point for remaining accounts
+                // The remaining accounts typically start after the main accounts (usually around index 10-15)
+                const remainingAccountStartIndex = Math.min(14, addLiquidityByStrategyIx.keys.length);
+                const remainingAccountMeta = addLiquidityByStrategyIx.keys.slice(remainingAccountStartIndex);
+                const strategyParametersStrategyType = addLiquidityByStrategyIx.data[32];
+                // const strategyParametersParameters: number[] = new Array(64).fill(0);
+                // index 97 onwards are remaining accounts info
+                const remainingAccountsInfo = addLiquidityByStrategyIx.data.subarray(97);
+                console.log('Remaining accounts start index:', remainingAccountStartIndex);
+                console.log('Remaining accounts count:', remainingAccountMeta.length);
+                console.log('Remaining accounts info length:', remainingAccountsInfo.length);
+                // // Generate IX via extension contract
+                // const data = this.ix.data.subarray(8);
+                // const activeId = data.subarray(16, 20).readInt32LE();
+                // const maxActiveBinSlippage = data.subarray(20, 24).readInt32LE();
+                // const strategyParametersMinBinId = data.subarray(24, 28).readInt32LE();
+                // const strategyParametersMaxBinId = data.subarray(28, 32).readInt32LE();
+                // const strategyParametersStrategyType = data[32];
+                // const strategyParametersParameters = Array.from(data.subarray(33, 97));
+                // const remainingAccountsInfo = this.ix.data.subarray(97);
+                console.log('old strategy type', strategyType);
+                console.log('new strategy type', mapOldStrategyTypeToNew(strategyType));
+                console.log('strategyParametersStrategyType', strategyParametersStrategyType);
+                // Log the first few keys to understand the structure
+                console.log('First 5 instruction keys:', addLiquidityByStrategyIx.keys.slice(0, 5).map((key, i) => ({
+                    index: i,
+                    pubkey: key.pubkey.toString(),
+                    isSigner: key.isSigner,
+                    isWritable: key.isWritable,
+                })));
+                console.log('Creating extension instruction...');
+                // @ts-ignore
+                const extensionIx = yield anchor_1.Anchor.instance()
+                    .iyfExtension.methods.meteoraDlmmRedepositAutomation2(relativeLowerBinId, relativeUpperBinId, strategyType, _checkRange, 
+                // strategyParametersParameters,
+                remainingAccountsInfo)
+                    .accounts({
+                    userPda,
+                    hawksightAuthority: addresses_1.HS_AUTHORITY,
+                    position,
+                    lbPair,
+                    userTokenX,
+                    userTokenY,
+                    reserveX,
+                    reserveY,
+                    tokenXMint,
+                    tokenYMint,
+                    systemProgram: web3.SystemProgram.programId,
+                    tokenXProgram: tokenProgramA,
+                    tokenYProgram: tokenProgramB,
+                    rent: web3.SYSVAR_RENT_PUBKEY,
+                    eventAuthority: METEORA_EVENT_AUTHORITY,
+                    meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+                    binArrayBitmapExtension,
+                })
+                    .remainingAccounts(remainingAccountMeta.length > 0 ? remainingAccountMeta : [])
+                    .instruction();
+                // Patch binArrayBitmapExtension writable flag: writable only when it's a real PDA, not the program ID placeholder
+                const bitmapKey = extensionIx.keys.find(k => k.pubkey.equals(binArrayBitmapExtension));
+                if (bitmapKey) {
+                    bitmapKey.isWritable =
+                        !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM);
+                }
+                console.log('Extension instruction created:', {
+                    keysCount: extensionIx.keys.length,
+                    dataLength: extensionIx.data.length,
+                    programId: extensionIx.programId.toString(),
+                });
+                // Generate instruction
+                console.log('Calling iyfExtensionExecuteV2 with:', {
+                    authority: userWallet.toString(),
+                    extensionIxKeysCount: extensionIx.keys.length,
+                    extensionIxProgramId: extensionIx.programId.toString(),
+                });
+                const sighash = util.sighash('meteora_dlmm_redeposit_automation_2');
+                extensionIx.data.set(sighash, 0);
+                const ix = yield this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                    userPda,
+                    authority: addresses_1.HS_AUTHORITY,
+                    ix: extensionIx,
+                });
+                console.log('ix data length:', ix.data.length);
+                return ix;
+                console.log('=== REDEPOSIT AUTOMATION 2 SUCCESS ===');
+            }
+            catch (error) {
+                console.error('=== REDEPOSIT AUTOMATION 2 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 REDEPOSIT ERROR LOG ===');
+                throw error;
+            }
+        });
+    }
+    relativeOpenAutomation(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, relativeLowerBinId, relativeUpperBinId, strategyType, checkRange, targetActiveBin, userTokenXAmount, userTokenYAmount, useFuelAccount, pdaTokenType, }) {
+            try {
+                // Initialize anchor
+                anchor_1.Anchor.initialize(connection);
+                // Generate user pda
+                const userPda = (0, functions_1.generateUserPda)(userWallet);
+                // Get meteora pool
+                const lbPairInfo = yield anchor_1.Anchor.instance().meteoraProgram.account.lbPair.fetch(lbPair);
+                const tokenXMint = lbPairInfo.tokenXMint;
+                const tokenYMint = lbPairInfo.tokenYMint;
+                // Fetch and cache mint accounts so AccountCache.get() returns the token programs
+                yield MintCache_1.MintCache.instance(connection)
+                    .getBatchedMultipleAccountsInfo([tokenXMint, tokenYMint])
+                    .waitForResult();
+                const mintAInfo = AccountCache_1.AccountCache.get(tokenXMint);
+                const mintBInfo = AccountCache_1.AccountCache.get(tokenYMint);
+                const tokenProgramA = mintAInfo === null || mintAInfo === void 0 ? void 0 : mintAInfo.info.owner;
+                const tokenProgramB = mintBInfo === null || mintBInfo === void 0 ? void 0 : mintBInfo.info.owner;
+                const reserveX = lbPairInfo.reserveX;
+                const reserveY = lbPairInfo.reserveY;
+                // Generate user token accounts based on pdaTokenType
+                let userTokenX;
+                let userTokenY;
+                if (pdaTokenType === types_1.TokenType.STA) {
+                    userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                    userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+                }
+                else if (pdaTokenType === types_1.TokenType.LTA) {
+                    userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                    userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+                }
+                else {
+                    userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenProgramA);
+                    userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenProgramB);
+                }
+                let activeBinId = lbPairInfo.activeId;
+                if (!!targetActiveBin) {
+                    activeBinId = targetActiveBin;
+                }
+                // Get min and max bin id values from checkRange threshold
+                const { minBinId, maxBinId } = checkRange;
+                let _checkRange = [minBinId, maxBinId];
+                // Note: relative lower & upper bins can be positive or negative
+                const expectedMinBinId = activeBinId + relativeLowerBinId;
+                const expectedMaxBinId = activeBinId + relativeUpperBinId;
+                if (expectedMaxBinId < expectedMinBinId) {
+                    throw new Error('Invalid bin range');
+                }
+                let DLMM = yield this.dlmm(connection, lbPair);
+                const addLiquidityByStrategyTx = yield DLMM.dlmm.initializePositionAndAddLiquidityByStrategy({
+                    positionPubKey: position,
+                    totalXAmount: new bn_js_1.default(0),
+                    totalYAmount: new bn_js_1.default(0),
+                    strategy: {
+                        minBinId: expectedMinBinId,
+                        maxBinId: expectedMaxBinId,
+                        strategyType: mapOldStrategyTypeToNew(strategyType),
+                    },
+                    user: userWallet,
+                });
+                const addLiquidityByStrategyIx = addLiquidityByStrategyTx.instructions.filter(ix => {
+                    return (ix.programId.equals(METEORA_DLMM_PROGRAM) &&
+                        ix.data
+                            .subarray(0, 8)
+                            .equals(Buffer.from([3, 221, 149, 218, 111, 141, 118, 213])));
+                })[0];
+                const binArrayBitmapExtension = addLiquidityByStrategyIx.keys[2].pubkey;
+                if (!addLiquidityByStrategyIx) {
+                    throw new Error('add_liquidity_by_strategy2 instruction not found in transaction');
+                }
+                const remainingAccountStartIndex = Math.min(14, addLiquidityByStrategyIx.keys.length);
+                const remainingAccountMeta = addLiquidityByStrategyIx.keys.slice(remainingAccountStartIndex);
+                const remainingAccountsInfo = addLiquidityByStrategyIx.data.subarray(97);
+                const fuelAccount = useFuelAccount
+                    ? (0, functions_1.generateFuelAccount)(userWallet)
+                    : web3.SystemProgram.programId;
+                // @ts-ignore
+                const extensionIx = yield anchor_1.Anchor.instance()
+                    .iyfExtension.methods.meteoraDlmmRelativeOpenAutomation(relativeLowerBinId, relativeUpperBinId, strategyType, userTokenXAmount !== null && userTokenXAmount !== void 0 ? userTokenXAmount : null, userTokenYAmount !== null && userTokenYAmount !== void 0 ? userTokenYAmount : null, _checkRange, remainingAccountsInfo)
+                    .accounts({
+                    userPda,
+                    hawksightAuthority: addresses_1.HS_AUTHORITY,
+                    position,
+                    lbPair,
+                    userTokenX,
+                    userTokenY,
+                    reserveX,
+                    reserveY,
+                    tokenXMint,
+                    tokenYMint,
+                    systemProgram: web3.SystemProgram.programId,
+                    tokenXProgram: tokenProgramA,
+                    tokenYProgram: tokenProgramB,
+                    rent: web3.SYSVAR_RENT_PUBKEY,
+                    eventAuthority: METEORA_EVENT_AUTHORITY,
+                    meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+                    binArrayBitmapExtension,
+                    fuelAccount,
+                })
+                    .remainingAccounts(remainingAccountMeta.length > 0 ? remainingAccountMeta : [])
+                    .instruction();
+                // Patch binArrayBitmapExtension writable flag: writable only when it's a real PDA, not the program ID placeholder
+                const bitmapKey = extensionIx.keys.find(k => k.pubkey.equals(binArrayBitmapExtension));
+                if (bitmapKey) {
+                    bitmapKey.isWritable =
+                        !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM);
+                }
+                // Set the correct sighash for the new instruction
+                const sighash = util.sighash('meteora_dlmm_relative_open_automation');
+                extensionIx.data.set(sighash, 0);
+                const ix = yield this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                    userPda,
+                    authority: addresses_1.HS_AUTHORITY,
+                    ix: extensionIx,
+                });
+                return ix;
+            }
+            catch (error) {
+                console.error('=== RELATIVE OPEN AUTOMATION ERROR ===');
+                console.error('Error message:', error instanceof Error ? error.message : String(error));
+                throw error;
+            }
+        });
+    }
+    claimFee(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            return new web3.TransactionInstruction({
+                data: Buffer.from([]),
+                keys: [],
+                programId: web3.SystemProgram.programId,
+            });
+        });
+    }
+    claimFee2(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, lowerBinId, upperBinId, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const reserveX = this.pda.meteora.deriveReserve(tokenMintX, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenMintY, lbPair);
+            const userTokenX = (0, functions_1.generateAta)(userPda, tokenMintX, tokenProgramX);
+            const userTokenY = (0, functions_1.generateAta)(userPda, tokenMintY, tokenProgramY);
+            const ownerFeeX = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, tokenMintX, tokenProgramX);
+            const ownerFeeY = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, tokenMintY, tokenProgramY);
+            const binArrays = this.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+            const sighash = util.sighash('meteora_dlmm_claim_fee_2');
+            const minBinId = Buffer.alloc(4);
+            const maxBinId = Buffer.alloc(4);
+            const remainingAccountsInfo = Buffer.from(new Uint8Array([0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
+            minBinId.writeInt32LE(lowerBinId, 0);
+            maxBinId.writeInt32LE(upperBinId, 0);
+            return yield this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: userWallet,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        new Uint8Array(sighash),
+                        new Uint8Array(minBinId),
+                        new Uint8Array(maxBinId),
+                        new Uint8Array(remainingAccountsInfo),
+                    ]),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: userWallet, isSigner: true, isWritable: false },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        { pubkey: reserveX, isSigner: false, isWritable: true },
+                        { pubkey: reserveY, isSigner: false, isWritable: true },
+                        { pubkey: userTokenX, isSigner: false, isWritable: true },
+                        { pubkey: userTokenY, isSigner: false, isWritable: true },
+                        { pubkey: tokenMintX, isSigner: false, isWritable: false },
+                        { pubkey: tokenMintY, isSigner: false, isWritable: false },
+                        { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+                        { pubkey: tokenProgramY, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: ownerFeeX, isSigner: false, isWritable: true },
+                        { pubkey: ownerFeeY, isSigner: false, isWritable: true },
+                        ...binArrays.map(binArray => ({
+                            pubkey: binArray,
+                            isSigner: false,
+                            isWritable: true,
+                        })),
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    claimReward(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            return new web3.TransactionInstruction({
+                data: Buffer.from([]),
+                keys: [],
+                programId: web3.SystemProgram.programId,
+            });
+        });
+    }
+    claimReward2(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, rewardIndex, rewardMint, rewardVault, tokenProgram, lowerBinId, upperBinId, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const userTokenAccount = (0, functions_1.generateAta)(userPda, rewardMint);
+            const ownerFee = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, rewardMint, tokenProgram);
+            const binArrays = this.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+            const sighash = util.sighash('meteora_dlmm_claim_reward_2');
+            const minBinId = Buffer.alloc(4);
+            const maxBinId = Buffer.alloc(4);
+            const remainingAccountsInfo = Buffer.from(new Uint8Array([
+                0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00,
+            ]));
+            minBinId.writeInt32LE(lowerBinId, 0);
+            maxBinId.writeInt32LE(upperBinId, 0);
+            return yield this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: userWallet,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        new Uint8Array(sighash),
+                        new Uint8Array([rewardIndex]),
+                        new Uint8Array(minBinId),
+                        new Uint8Array(maxBinId),
+                        new Uint8Array(remainingAccountsInfo),
+                    ]),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: userWallet, isSigner: true, isWritable: false },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        { pubkey: rewardVault, isSigner: false, isWritable: true },
+                        { pubkey: rewardMint, isSigner: false, isWritable: true },
+                        { pubkey: userTokenAccount, isSigner: false, isWritable: true },
+                        { pubkey: tokenProgram, isSigner: false, isWritable: true },
+                        { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: ownerFee, isSigner: false, isWritable: true },
+                        ...binArrays.map(binArray => ({
+                            pubkey: binArray,
+                            isSigner: false,
+                            isWritable: true,
+                        })),
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    /**
+     * Claim fees from a Meteora DLMM position via IYF Extension for automation.
+     *
+     * This is the automation version that uses HS_AUTHORITY as the signer.
+     *
+     * @param connection - Solana connection
+     * @param params - ClaimFee2AutomationParams parameters
+     * @returns TransactionInstruction for the claim_fee2 automation operation
+     */
+    claimFee2Automation(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, lowerBinId, upperBinId, pdaTokenType, remainingAccountsInfo, }) {
+            var _b, _c;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const reserveX = this.pda.meteora.deriveReserve(tokenMintX, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenMintY, lbPair);
+            // Generate user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenMintX);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenMintY);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenMintX);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenMintY);
+            }
+            else {
+                // Default: ATA
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenMintX, tokenProgramX);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenMintY, tokenProgramY);
+            }
+            const ownerFeeX = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, tokenMintX, tokenProgramX);
+            const ownerFeeY = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, tokenMintY, tokenProgramY);
+            const binArrays = this.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+            const sighash = util.sighash('meteora_dlmm_claim_fee_2_automation');
+            const minBinId = Buffer.alloc(4);
+            const maxBinId = Buffer.alloc(4);
+            minBinId.writeInt32LE(lowerBinId, 0);
+            maxBinId.writeInt32LE(upperBinId, 0);
+            // Serialize RemainingAccountsInfo with Vec<u8> length prefix for Anchor
+            const remainingAccountsInfoContent = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.slices) !== null && _b !== void 0 ? _b : [],
+            });
+            // For Anchor Vec<u8> parameter, we need to prepend the length as u32 LE
+            const remainingAccountsInfoVec = Buffer.alloc(4 + remainingAccountsInfoContent.length);
+            remainingAccountsInfoVec.writeUInt32LE(remainingAccountsInfoContent.length, 0);
+            remainingAccountsInfoContent.copy(remainingAccountsInfoVec, 4);
+            return yield this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        new Uint8Array(sighash),
+                        new Uint8Array(minBinId),
+                        new Uint8Array(maxBinId),
+                        new Uint8Array(remainingAccountsInfoVec),
+                    ]),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: false },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        { pubkey: reserveX, isSigner: false, isWritable: true },
+                        { pubkey: reserveY, isSigner: false, isWritable: true },
+                        { pubkey: userTokenX, isSigner: false, isWritable: true },
+                        { pubkey: userTokenY, isSigner: false, isWritable: true },
+                        { pubkey: tokenMintX, isSigner: false, isWritable: false },
+                        { pubkey: tokenMintY, isSigner: false, isWritable: false },
+                        { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+                        { pubkey: tokenProgramY, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        { pubkey: ownerFeeX, isSigner: false, isWritable: true },
+                        { pubkey: ownerFeeY, isSigner: false, isWritable: true },
+                        ...binArrays.map(binArray => ({
+                            pubkey: binArray,
+                            isSigner: false,
+                            isWritable: true,
+                        })),
+                        // Transfer hook accounts (if any)
+                        ...((_c = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.accounts) !== null && _c !== void 0 ? _c : []),
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    /**
+     * Claim rewards from a Meteora DLMM position via IYF Extension for automation.
+     *
+     * This is the automation version that uses HS_AUTHORITY as the signer.
+     *
+     * @param connection - Solana connection
+     * @param params - ClaimReward2AutomationParams parameters
+     * @returns TransactionInstruction for the claim_reward2 automation operation
+     */
+    claimReward2Automation(connection_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (connection, { userWallet, lbPair, position, rewardIndex, rewardMint, rewardVault, tokenProgram, lowerBinId, upperBinId, pdaTokenType, remainingAccountsInfo, }) {
+            var _b, _c;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate user token account based on pdaTokenType
+            let userTokenAccount;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenAccount = (0, functions_1.generateLimitToken)(userPda, rewardMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenAccount = (0, functions_1.generateUserPdaStorageAccount)(userPda, rewardMint);
+            }
+            else {
+                // Default: ATA
+                userTokenAccount = (0, functions_1.generateAta)(userPda, rewardMint, tokenProgram);
+            }
+            const ownerFee = (0, functions_1.generateAta)(addresses_1.SITE_FEE_OWNER, rewardMint, tokenProgram);
+            const binArrays = this.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+            const sighash = util.sighash('meteora_dlmm_claim_reward_2_automation');
+            const minBinId = Buffer.alloc(4);
+            const maxBinId = Buffer.alloc(4);
+            minBinId.writeInt32LE(lowerBinId, 0);
+            maxBinId.writeInt32LE(upperBinId, 0);
+            // Serialize RemainingAccountsInfo with Vec<u8> length prefix for Anchor
+            const remainingAccountsInfoContent = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.slices) !== null && _b !== void 0 ? _b : [],
+            });
+            // For Anchor Vec<u8> parameter, we need to prepend the length as u32 LE
+            const remainingAccountsInfoVec = Buffer.alloc(4 + remainingAccountsInfoContent.length);
+            remainingAccountsInfoVec.writeUInt32LE(remainingAccountsInfoContent.length, 0);
+            remainingAccountsInfoContent.copy(remainingAccountsInfoVec, 4);
+            // Serialize rewardIndex as u64 (8 bytes, little endian)
+            const rewardIndexBuffer = Buffer.alloc(8);
+            rewardIndexBuffer.writeBigUInt64LE(BigInt(rewardIndex), 0);
+            return yield this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        new Uint8Array(sighash),
+                        new Uint8Array(rewardIndexBuffer),
+                        new Uint8Array(minBinId),
+                        new Uint8Array(maxBinId),
+                        new Uint8Array(remainingAccountsInfoVec),
+                    ]),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: false },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        { pubkey: rewardVault, isSigner: false, isWritable: true },
+                        { pubkey: rewardMint, isSigner: false, isWritable: true },
+                        { pubkey: userTokenAccount, isSigner: false, isWritable: true },
+                        { pubkey: tokenProgram, isSigner: false, isWritable: true },
+                        { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        { pubkey: ownerFee, isSigner: false, isWritable: true },
+                        ...binArrays.map(binArray => ({
+                            pubkey: binArray,
+                            isSigner: false,
+                            isWritable: true,
+                        })),
+                        // Transfer hook accounts (if any)
+                        ...((_c = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.accounts) !== null && _c !== void 0 ? _c : []),
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    depositAutomation(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+            let userTokenX;
+            let userTokenY;
+            if (params.tokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, params.tokenYMint);
+            }
+            else if (params.tokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, params.tokenYMint);
+            }
+            else {
+                userTokenX = (0, functions_1.generateAta)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateAta)(userPda, params.tokenYMint);
+            }
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance()
+                .iyfExtension.methods.meteoraDlmmDepositAutomation(params.activeId, params.maxActiveBinSlippage, params.strategyParametersMinBinId, params.strategyParametersMaxBinId, params.strategyParametersStrategyType, params.strategyParametersParameters)
+                .accounts({
+                farm: addresses_1.USDC_FARM,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                hawksightAuthority: addresses_1.HS_AUTHORITY,
+                position: params.position,
+                lbPair: params.lbPair,
+                binArrayBitmapExtension: params.binArrayBitmapExtension,
+                userTokenX,
+                userTokenY,
+                reserveX: params.reserveX,
+                reserveY: params.reserveY,
+                tokenXMint: params.tokenXMint,
+                tokenYMint: params.tokenYMint,
+                binArrayLower: params.binArrayLower,
+                binArrayUpper: params.binArrayUpper,
+                tokenXProgram: params.tokenXProgram,
+                tokenYProgram: params.tokenYProgram,
+                eventAuthority: METEORA_EVENT_AUTHORITY,
+                meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+            })
+                .instruction();
+            // Patch binArrayBitmapExtension writable flag: writable only when it's a real PDA, not the program ID placeholder
+            const bitmapKey = ix.keys.find(k => k.pubkey.equals(params.binArrayBitmapExtension));
+            if (bitmapKey) {
+                bitmapKey.isWritable =
+                    !params.binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM);
+            }
+            return yield this.ix.iyfMain.iyfExtensionExecute(connection, {
+                userWallet: params.userWallet,
+                iyfExtensionIx: ix,
+            });
+        });
+    }
+    depositWithAmountAutomation(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+            let userTokenX;
+            let userTokenY;
+            if (params.tokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, params.tokenYMint);
+            }
+            else if (params.tokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, params.tokenYMint);
+            }
+            else {
+                userTokenX = (0, functions_1.generateAta)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateAta)(userPda, params.tokenYMint);
+            }
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance()
+                .iyfExtension.methods.meteoraDlmmDepositWithAmountAutomation(params.activeId, params.maxActiveBinSlippage, params.strategyParametersMinBinId, params.strategyParametersMaxBinId, params.strategyParametersStrategyType, params.strategyParametersParameters, params.userTokenXAmount, params.userTokenYAmount)
+                .accounts({
+                farm: addresses_1.USDC_FARM,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                hawksightAuthority: addresses_1.HS_AUTHORITY,
+                position: params.position,
+                lbPair: params.lbPair,
+                binArrayBitmapExtension: params.binArrayBitmapExtension,
+                userTokenX,
+                userTokenY,
+                reserveX: params.reserveX,
+                reserveY: params.reserveY,
+                tokenXMint: params.tokenXMint,
+                tokenYMint: params.tokenYMint,
+                binArrayLower: params.binArrayLower,
+                binArrayUpper: params.binArrayUpper,
+                tokenXProgram: params.tokenXProgram,
+                tokenYProgram: params.tokenYProgram,
+                eventAuthority: METEORA_EVENT_AUTHORITY,
+                meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+            })
+                .instruction();
+            // Patch binArrayBitmapExtension writable flag: writable only when it's a real PDA, not the program ID placeholder
+            const bitmapKey = ix.keys.find(k => k.pubkey.equals(params.binArrayBitmapExtension));
+            if (bitmapKey) {
+                bitmapKey.isWritable =
+                    !params.binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM);
+            }
+            return yield this.ix.iyfMain.iyfExtensionExecute(connection, {
+                userWallet: params.userWallet,
+                iyfExtensionIx: ix,
+            });
+        });
+    }
+    /**
+     * Add liquidity to an existing Meteora DLMM position using strategy parameters.
+     * This is the automation version that uses V2 execution (meteora_dlmm_deposit_2_automation).
+     *
+     * Key differences from depositAutomation:
+     * - Uses iyfExtensionExecuteV2 with Anchor-based instruction building
+     * - Supports remainingAccountsInfo for Token2022 transfer hooks
+     * - Authority is HS_AUTHORITY (automation wallet)
+     * - Does not require binArrayLower/binArrayUpper (bin arrays are auto-derived or created separately)
+     *
+     * @param connection - Solana connection
+     * @param params - AddLiquidityByStrategy2AutomationParams parameters
+     * @returns TransactionInstruction for adding liquidity
+     */
+    addLiquidityByStrategy2Automation(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Derive reserves from the ACTUAL lbPair (not the one passed in, which may be incorrect)
+            const actualReserveX = this.pda.meteora.deriveReserve(params.tokenXMint, params.lbPair);
+            const actualReserveY = this.pda.meteora.deriveReserve(params.tokenYMint, params.lbPair);
+            const userPda = (0, functions_1.generateUserPda)(params.userWallet);
+            // Determine user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (params.pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, params.tokenYMint);
+            }
+            else if (params.pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, params.tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, params.tokenYMint);
+            }
+            else {
+                // Default: ATA
+                userTokenX = (0, functions_1.generateAta)(userPda, params.tokenXMint, params.tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, params.tokenYMint, params.tokenYProgram);
+            }
+            // Derive bin array bitmap extension
+            const lowerBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(params.strategyParametersMinBinId));
+            const upperBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(params.strategyParametersMaxBinId));
+            const binArrayBitmapExtension = this.isOverflowDefaultBinArrayBitmap(lowerBinArrayIndex) ||
+                this.isOverflowDefaultBinArrayBitmap(upperBinArrayIndex)
+                ? this.pda.meteora.deriveBinArrayBitmapExtension(params.lbPair)
+                : METEORA_DLMM_PROGRAM;
+            // Serialize RemainingAccountsInfo as Vec<u8> (Borsh format)
+            // This is passed directly to the on-chain instruction which forwards it to Meteora
+            // For SPL tokens (non-Token2022), we still need to provide the slices structure with length=0
+            // This matches what Meteora SDK's getPotentialToken2022IxDataAndAccounts returns
+            // AccountsType enum: 0=TransferHookX, 1=TransferHookY, 2=TransferHookReward
+            const defaultSlices = [
+                { accountsType: 0, length: 0 }, // TransferHookX with 0 accounts
+                { accountsType: 1, length: 0 }, // TransferHookY with 0 accounts
+            ];
+            const remainingAccountsInfoSerialized = this.serializeRemainingAccountsInfo({
+                slices: (_b = (_a = params.remainingAccountsInfo) === null || _a === void 0 ? void 0 : _a.slices) !== null && _b !== void 0 ? _b : defaultSlices,
+            });
+            // Use strategy parameters directly as absolute bin IDs
+            // strategyParametersMinBinId and strategyParametersMaxBinId are ABSOLUTE bin IDs, not deltas from activeId
+            const lowerBinId = params.strategyParametersMinBinId;
+            const upperBinId = params.strategyParametersMaxBinId;
+            // Derive bin arrays needed for the deposit range using the lbPair from position
+            const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(params.lbPair, lowerBinId, upperBinId);
+            const binArrayAccounts = binArrays.map(binArray => ({
+                pubkey: binArray,
+                isSigner: false,
+                isWritable: true,
+            }));
+            // Build remaining accounts: Token2022 transfer hook accounts first (described by remainingAccountsInfo),
+            // then bin arrays (not described - Meteora expects them at the end after transfer hooks)
+            const remainingAccounts = [
+                ...((_d = (_c = params.remainingAccountsInfo) === null || _c === void 0 ? void 0 : _c.accounts) !== null && _d !== void 0 ? _d : []),
+                ...binArrayAccounts,
+            ];
+            // Use Anchor to serialize the instruction (ensures proper Borsh serialization)
+            // @ts-ignore
+            const depositIx = yield anchor_1.Anchor.instance()
+                .iyfExtension.methods.meteoraDlmmDeposit2Automation((_e = params.userTokenXAmount) !== null && _e !== void 0 ? _e : null, // Option<u64>
+            (_f = params.userTokenYAmount) !== null && _f !== void 0 ? _f : null, // Option<u64>
+            params.activeId, params.maxActiveBinSlippage, params.strategyParametersMinBinId, params.strategyParametersMaxBinId, params.strategyParametersStrategyType, params.strategyParametersParameters, Buffer.from(remainingAccountsInfoSerialized))
+                .accounts({
+                userPda,
+                hawksightAuthority: addresses_1.HS_AUTHORITY,
+                position: params.position,
+                lbPair: params.lbPair,
+                binArrayBitmapExtension,
+                userTokenX,
+                userTokenY,
+                reserveX: actualReserveX,
+                reserveY: actualReserveY,
+                tokenXMint: params.tokenXMint,
+                tokenYMint: params.tokenYMint,
+                tokenXProgram: params.tokenXProgram,
+                tokenYProgram: params.tokenYProgram,
+                eventAuthority: METEORA_EVENT_AUTHORITY,
+                meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+                memoProgram: addresses_1.MEMO_PROGRAM,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            // Patch binArrayBitmapExtension writable flag: writable only when it's a real PDA, not the program ID placeholder
+            const bitmapKey = depositIx.keys.find(k => k.pubkey.equals(binArrayBitmapExtension));
+            if (bitmapKey) {
+                bitmapKey.isWritable =
+                    !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM);
+            }
+            // Override sighash: Anchor's TypeScript client generates a different sighash than what
+            // the on-chain program expects. We need to manually set the correct sighash.
+            const sighash = util.sighash('meteora_dlmm_deposit_2_automation');
+            depositIx.data.set(sighash, 0);
+            // Generate instruction via IYF Main ExecuteV2
+            // @ts-ignore
+            const ix = yield anchor_1.Anchor.instance()
+                .iyfMain.methods.iyfExtensionExecuteV2(depositIx.data)
+                .accounts({
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                iyfExtensionProgram: addresses_1.IYF_EXTENSION,
+            })
+                .remainingAccounts(depositIx.keys.slice(2))
+                .instruction();
+            return ix;
+        });
+    }
+    oneSideDeposit(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            return new web3.TransactionInstruction({
+                data: Buffer.from([]),
+                keys: [],
+                programId: web3.SystemProgram.programId,
+            });
+        });
+    }
+    withdrawAutomation(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            return new web3.TransactionInstruction({
+                data: Buffer.from([]),
+                keys: [],
+                programId: web3.SystemProgram.programId,
+            });
+        });
+    }
+    closePositionAutomation(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            return new web3.TransactionInstruction({
+                data: Buffer.from([]),
+                keys: [],
+                programId: web3.SystemProgram.programId,
+            });
+        });
+    }
+    /**
+     * Close an empty Meteora DLMM position via IYF Extension for automation.
+     *
+     * This is the automation version that uses HS_AUTHORITY as the signer.
+     *
+     * @param params - ClosePositionIfEmptyAutomationParams parameters
+     * @returns TransactionInstruction for the close_position_if_empty automation operation
+     */
+    closePosition2Automation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, lbPair, useFuelAccount, }) {
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Optional fuel account - use userPda as placeholder if not using fuel account
+            // (userPda is already writable, while System Program cannot be writable)
+            const fuelAccount = useFuelAccount
+                ? (0, functions_1.generateFuelAccount)(userWallet)
+                : userPda;
+            // Generate instruction via IYF Extension
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.from(util.sighash('meteora_dlmm_close_position_automation_v2', undefined, true)),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: true },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        { pubkey: fuelAccount, isSigner: false, isWritable: true },
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    baseClosePosition2Automation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, lbPair, useFuelAccount, isHawkRefund = false, }) {
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const fuelAccount = useFuelAccount
+                ? (0, functions_1.generateFuelAccount)(userWallet)
+                : userPda;
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: buildBaseClosePosition2AutomationIx({
+                    userPda,
+                    hawksightAuthority: addresses_1.HS_AUTHORITY,
+                    authority: userWallet,
+                    position,
+                    lbPair,
+                    fuelAccount,
+                    isHawkRefund,
+                }),
+            });
+        });
+    }
+    limitCloseAutomation(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            return new web3.TransactionInstruction({
+                data: Buffer.from([]),
+                keys: [],
+                programId: web3.SystemProgram.programId,
+            });
+        });
+    }
+    /**
+     * Meteora IDL
+     *
+     * @param connection
+     * @returns
+     */
+    meteora(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield meteora_1.MeteoraDLMM.program(connection);
+        });
+    }
+    /**
+     * Meteora IDL
+     *
+     * @param connection
+     * @returns
+     */
+    dlmm(connection, poolAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('dlmm method called with:', {
+                connection: connection ? 'valid' : 'undefined',
+                poolAddress: poolAddress.toString(),
+                ix: this.ix ? 'valid' : 'undefined',
+            });
+            if (!connection) {
+                throw new Error('Connection is undefined in dlmm method');
+            }
+            if (!this.ix) {
+                throw new Error('this.ix is undefined in dlmm method');
+            }
+            return yield meteora_1.MeteoraDLMM.create(connection, poolAddress, this.ix);
+        });
+    }
+    limitOrderCloseV2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, lbPair, tokenXMint, tokenYMint, reserveX, reserveY, tokenXProgram, tokenYProgram, useFuelAccount, param, minBinId, maxBinId, binArrays, }) {
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate limit tokens
+            const limitTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+            const limitTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            // Generate authority token accounts
+            const authorityTokenX = (0, functions_1.generateAta)(userWallet, tokenXMint, tokenXProgram);
+            const authorityTokenY = (0, functions_1.generateAta)(userWallet, tokenYMint, tokenYProgram);
+            // Generate fee accounts
+            const { ownerFeeX, ownerFeeY } = (0, functions_1.generateHawksightFeeAccounts)(tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+            // Create instruction
+            // @ts-ignore
+            const limitOrderCloseV2Ix = yield anchor_1.Anchor.instance()
+                .iyfExtension.methods.limitOrderClose2(param, minBinId, maxBinId)
+                .accounts({
+                userPda,
+                hawksightAuthority: addresses_1.HS_AUTHORITY,
+                authority: userWallet,
+                position,
+                lbPair,
+                binArrayBitmapExtension: METEORA_DLMM_PROGRAM,
+                limitTokenX,
+                limitTokenY,
+                authorityTokenX,
+                authorityTokenY,
+                systemProgram: web3.SystemProgram.programId,
+                reserveX,
+                reserveY,
+                tokenXMint,
+                tokenYMint,
+                tokenXProgram,
+                tokenYProgram,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                eventAuthority: METEORA_EVENT_AUTHORITY,
+                memoProgram: addresses_1.MEMO_PROGRAM,
+                meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+                ownerFeeX,
+                ownerFeeY,
+                fuelAccount: useFuelAccount
+                    ? (0, functions_1.generateFuelAccount)(userWallet)
+                    : web3.SystemProgram.programId,
+            })
+                .remainingAccounts(binArrays.map(pubkey => ({
+                pubkey,
+                isSigner: false,
+                isWritable: true,
+            })))
+                .instruction();
+            const sighash = util.sighash('limit_order_close_2', undefined, true);
+            limitOrderCloseV2Ix.data.set(sighash, 0);
+            // Return the instruction directly (no wrapper needed for Meteora IX Generator)
+            return limitOrderCloseV2Ix;
+        });
+    }
+    meteoraDlmmLimitCloseAutomationV2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, lbPair, tokenXMint, tokenYMint, reserveX, reserveY, tokenXProgram, tokenYProgram, pdaTokenType, param, minBinId, maxBinId, isHawkRefund, useFuelAccount, binArrays, }) {
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            const authority = userWallet;
+            const hawksightAuthority = addresses_1.HS_AUTHORITY;
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet, addresses_1.USDC_FARM);
+            // Generate user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else {
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            // Generate fee accounts
+            const { ownerFeeX, ownerFeeY } = (0, functions_1.generateHawksightFeeAccounts)(tokenXMint, tokenYMint, tokenXProgram, tokenYProgram);
+            // Create instruction
+            // @ts-ignore
+            const meteoraDlmmLimitCloseAutomationV2Ix = yield anchor_1.Anchor.instance()
+                .iyfExtension.methods.meteoraDlmmLimitCloseAutomationV2(param, minBinId, maxBinId, isHawkRefund)
+                .accounts({
+                userPda,
+                hawksightAuthority,
+                authority,
+                position,
+                lbPair,
+                binArrayBitmapExtension: METEORA_DLMM_PROGRAM,
+                userTokenX,
+                userTokenY,
+                reserveX,
+                reserveY,
+                tokenXMint,
+                tokenYMint,
+                tokenXProgram,
+                tokenYProgram,
+                eventAuthority: METEORA_EVENT_AUTHORITY,
+                memoProgram: addresses_1.MEMO_PROGRAM,
+                meteoraDlmmProgram: METEORA_DLMM_PROGRAM,
+                ownerFeeX,
+                ownerFeeY,
+                fuelAccount: useFuelAccount
+                    ? (0, functions_1.generateFuelAccount)(userWallet)
+                    : web3.SystemProgram.programId,
+            })
+                .remainingAccounts(binArrays.map(pubkey => ({
+                pubkey,
+                isSigner: false,
+                isWritable: true,
+            })))
+                .instruction();
+            // Return the instruction directly (no wrapper needed for Meteora IX Generator)
+            return meteoraDlmmLimitCloseAutomationV2Ix;
+        });
+    }
+    /**
+     * Generates raw meteora instruction that initializes a meteora pool
+     *
+     * @param param0
+     * @returns
+     */
+    initializeLbPair2Raw(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, funder, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, presetParameter, activeId, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const tokenX = tokenMintX;
+            const tokenY = tokenMintY;
+            const lbPair = this.pda.meteora.deriveLbPairWithPresetParamWithIndexKey(presetParameter, tokenX, tokenY);
+            const reserveX = this.pda.meteora.deriveReserve(tokenX, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenY, lbPair);
+            const oracle = this.pda.meteora.deriveOracle(lbPair);
+            const activeBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(activeId));
+            const binArrayBitmapExtension = this.isOverflowDefaultBinArrayBitmap(activeBinArrayIndex)
+                ? this.pda.meteora.deriveBinArrayBitmapExtension(lbPair)
+                : METEORA_DLMM_PROGRAM;
+            return new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    Buffer.from(util.sighash('initialize_lb_pair_2')),
+                    Buffer.from([activeId]),
+                    Buffer.from(Array(96).fill(0)),
+                ]),
+                keys: [
+                    { pubkey: funder, isSigner: true, isWritable: true },
+                    { pubkey: lbPair, isSigner: false, isWritable: true },
+                    { pubkey: reserveX, isSigner: false, isWritable: true },
+                    { pubkey: reserveY, isSigner: false, isWritable: true },
+                    {
+                        pubkey: binArrayBitmapExtension,
+                        isSigner: false,
+                        isWritable: !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM),
+                    },
+                    { pubkey: tokenMintX, isSigner: false, isWritable: false },
+                    { pubkey: tokenMintY, isSigner: false, isWritable: false },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                    { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+                    { pubkey: tokenProgramY, isSigner: false, isWritable: false },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                ],
+                programId: METEORA_DLMM_PROGRAM,
+            });
+        });
+    }
+    isOverflowDefaultBinArrayBitmap(binArrayIndex) {
+        const [minBinArrayIndex, maxBinArrayIndex] = this.internalBitmapRange();
+        return (binArrayIndex.gt(maxBinArrayIndex) || binArrayIndex.lt(minBinArrayIndex));
+    }
+    internalBitmapRange() {
+        const lowerBinArrayIndex = new bn_js_1.default(512).neg();
+        const upperBinArrayIndex = new bn_js_1.default(512).sub(new bn_js_1.default(1));
+        return [lowerBinArrayIndex, upperBinArrayIndex];
+    }
+    binIdToBinArrayIndex(binId) {
+        const { div: idx, mod } = binId.divmod(new bn_js_1.default(70));
+        return binId.isNeg() && !mod.isZero() ? idx.sub(new bn_js_1.default(1)) : idx;
+    }
+    meteoraDlmmCreatePoolAndPosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, presetParameter, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, activeId, lowerBinId, upperBinId, strategyType, binStep, baseFactor, baseFeePowerFactor, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            const userTokenX = (0, functions_1.generateAta)(userPda, tokenMintX, tokenProgramX);
+            const userTokenY = (0, functions_1.generateAta)(userPda, tokenMintY, tokenProgramY);
+            // Try to get existing LB pair first
+            let lbPair;
+            try {
+                lbPair = yield dlmm_1.default.getPairPubkeyIfExists(connection, tokenMintX, tokenMintY, binStep, baseFactor, baseFeePowerFactor);
+            }
+            catch (error) {
+                // If getPairPubkeyIfExists fails, set lbPair to null to trigger fallback
+                lbPair = null;
+            }
+            // If no existing pair found or error occurred, derive it with preset parameters
+            if (!lbPair) {
+                lbPair = this.pda.meteora.deriveLbPairWithPresetParamWithIndexKey(presetParameter, tokenMintX, tokenMintY);
+            }
+            const reserveX = this.pda.meteora.deriveReserve(tokenMintX, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenMintY, lbPair);
+            const oracle = this.pda.meteora.deriveOracle(lbPair);
+            const hawkfiPayer = this.pda.hawksight.generateHawkfiPayer();
+            return new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    Buffer.from(util.sighash('meteora_dlmm_create_pool_and_position')),
+                    new bn_js_1.default(activeId).toTwos(32).toArrayLike(Buffer, 'le', 4),
+                    new bn_js_1.default(lowerBinId).toTwos(32).toArrayLike(Buffer, 'le', 4),
+                    new bn_js_1.default(upperBinId).toTwos(32).toArrayLike(Buffer, 'le', 4),
+                    Buffer.from([strategyType]),
+                ]),
+                keys: [
+                    { pubkey: userPda, isSigner: false, isWritable: false },
+                    { pubkey: userWallet, isSigner: true, isWritable: true },
+                    { pubkey: hawkfiPayer, isSigner: false, isWritable: true },
+                    { pubkey: position, isSigner: true, isWritable: true },
+                    { pubkey: lbPair, isSigner: false, isWritable: true },
+                    { pubkey: userTokenX, isSigner: false, isWritable: true },
+                    { pubkey: userTokenY, isSigner: false, isWritable: true },
+                    { pubkey: reserveX, isSigner: false, isWritable: true },
+                    { pubkey: reserveY, isSigner: false, isWritable: true },
+                    { pubkey: oracle, isSigner: false, isWritable: true },
+                    { pubkey: presetParameter, isSigner: false, isWritable: false },
+                    { pubkey: tokenMintX, isSigner: false, isWritable: false },
+                    { pubkey: tokenMintY, isSigner: false, isWritable: false },
+                    { pubkey: tokenProgramX, isSigner: false, isWritable: false },
+                    { pubkey: tokenProgramY, isSigner: false, isWritable: false },
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false },
+                    { pubkey: web3.SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+                    {
+                        pubkey: web3.SystemProgram.programId,
+                        isSigner: false,
+                        isWritable: false,
+                    },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                    ...(() => {
+                        const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, lowerBinId, upperBinId);
+                        return binArrays.map(pubkey => ({
+                            pubkey,
+                            isSigner: false,
+                            isWritable: true,
+                        }));
+                    })(),
+                ],
+                programId: addresses_1.IYF_MAIN,
+            });
+        });
+    }
+    meteoraDlmmInitializeBinArray(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, lowerBinId, upperBinId, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate hawkfi payer
+            const hawkfiPayer = this.pda.hawksight.generateHawkfiPayer();
+            return new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    Buffer.from(util.sighash('meteora_dlmm_init_bin_arrays')),
+                    new bn_js_1.default(lowerBinId).toTwos(32).toArrayLike(Buffer, 'le', 4),
+                    new bn_js_1.default(upperBinId).toTwos(32).toArrayLike(Buffer, 'le', 4),
+                ]),
+                keys: [
+                    { pubkey: userPda, isSigner: false, isWritable: false },
+                    { pubkey: userWallet, isSigner: true, isWritable: true },
+                    { pubkey: hawkfiPayer, isSigner: false, isWritable: true },
+                    { pubkey: lbPair, isSigner: false, isWritable: true },
+                    {
+                        pubkey: web3.SystemProgram.programId,
+                        isSigner: false,
+                        isWritable: false,
+                    },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                    ...(() => {
+                        const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, lowerBinId, upperBinId);
+                        return binArrays.map(pubkey => ({
+                            pubkey,
+                            isSigner: false,
+                            isWritable: true,
+                        }));
+                    })(),
+                ],
+                programId: addresses_1.IYF_MAIN,
+            });
+        });
+    }
+    /**
+     * Initialize bin arrays for Meteora DLMM pool, invoked through meteora dlmm program
+     * which means initialization is paid by the user.
+     *
+     * @param connection - Solana connection
+     * @param userWallet - User wallet public key
+     * @param lbPair - LB pair public key
+     * @param lowerBinId - Lower bin ID
+     * @param upperBinId - Upper bin ID
+     * @returns
+     */
+    meteoraDlmmInitializeBinArrayDefault(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, lowerBinId, upperBinId, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const funder = userWallet;
+            const systemProgram = web3.SystemProgram.programId;
+            const tickIndices = meteora_1.MeteoraFunctions.findMeteoraTickArrayIndices(lowerBinId, upperBinId);
+            const upperTickIndex = tickIndices[tickIndices.length - 1].add(new bn_js_1.default(1));
+            const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, lowerBinId, upperBinId);
+            const ixs = binArrays.map((binArray, i) => {
+                const index = tickIndices[i] !== undefined ? tickIndices[i] : upperTickIndex;
+                return new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        Buffer.from(util.sighash('initialize_bin_array')),
+                        new bn_js_1.default(index).toTwos(64).toArrayLike(Buffer, 'le', 8),
+                    ]),
+                    keys: [
+                        { pubkey: lbPair, isSigner: false, isWritable: false },
+                        { pubkey: binArray, isSigner: false, isWritable: true },
+                        { pubkey: funder, isSigner: true, isWritable: true },
+                        { pubkey: systemProgram, isSigner: false, isWritable: true },
+                    ],
+                    programId: METEORA_DLMM_PROGRAM,
+                });
+            });
+            return ixs;
+        });
+    }
+    syncWithMarketPrice(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, lbPair, marketPrice, owner, skipCanSyncCheck = false, }) {
+            var _b;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Create DLMM instance
+            const dlmmInstance = yield this.dlmm(connection, lbPair);
+            // Get active bin
+            const activeBin = yield dlmmInstance.dlmm.getActiveBin();
+            // Check if sync is possible
+            if (!skipCanSyncCheck) {
+                const canSync = dlmmInstance.dlmm.canSyncWithMarketPrice(marketPrice, activeBin.binId);
+                if (!canSync) {
+                    return { canSync: false, instruction: null };
+                }
+            }
+            // Get sync transaction
+            const tx = yield dlmmInstance.dlmm.syncWithMarketPrice(marketPrice, owner);
+            // Extract the goToABin instruction (raw Meteora instruction)
+            const instruction = (_b = tx.instructions.find(ix => ix.programId.equals(METEORA_DLMM_PROGRAM))) !== null && _b !== void 0 ? _b : null;
+            return { canSync: true, instruction };
+        });
+    }
+    /**
+     * Increase the length of a Meteora DLMM position via IYF Main's meteora dynamic CPI.
+     *
+     * This instruction can only extend for up to 10kb in size, thus this instruction needs to be called
+     * multiple times.
+     *
+     * This is the raw Meteora initializePosition instruction invoked through IYF Main.
+     *
+     * @param connection - Solana connection
+     * @param params - Increase position length parameters
+     * @returns TransactionInstruction for initializing the position
+     */
+    increasePositionLength(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, lengthToAdd, side, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Build instruction data: sighash + lengthToAdd (u16) + side (u8)
+            const lengthToAddBuffer = Buffer.alloc(2);
+            lengthToAddBuffer.writeUInt16LE(lengthToAdd, 0);
+            const sideBuffer = Buffer.alloc(1);
+            sideBuffer.writeUInt8(side, 0);
+            // Build raw Meteora instruction (accounts only - no hawksight wrapper accounts)
+            // meteoraDynamicCpi will prepend userPda and authority
+            const meteoraIx = new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    Buffer.from(util.sighash('increase_position_length')),
+                    lengthToAddBuffer,
+                    sideBuffer,
+                ]),
+                keys: [
+                    { pubkey: userWallet, isSigner: false, isWritable: true }, // funder (Mutable, Signer - signed by IYF Main)
+                    { pubkey: lbPair, isSigner: false, isWritable: false }, // lbPair
+                    { pubkey: position, isSigner: true, isWritable: true }, // position (Mutable, Signer)
+                    { pubkey: userPda, isSigner: false, isWritable: false }, // owner (Signer - signed by IYF Main)
+                    {
+                        pubkey: web3.SystemProgram.programId,
+                        isSigner: false,
+                        isWritable: false,
+                    }, // systemProgram (required for realloc)
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false }, // eventAuthority (PDA)
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false }, // Meteora DLMM program
+                ],
+                programId: METEORA_DLMM_PROGRAM,
+            });
+            return yield this.ix.iyfMain.meteoraDynamicCpi({
+                connection,
+                userWallet,
+                meteoraIx,
+            });
+        });
+    }
+    increasePositionLengthAutomation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, lengthToAdd, side, useFuelAccount, }) {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Build instruction data: sighash + lengthToAdd (u16) + side (u8)
+            const lengthToAddBuffer = Buffer.alloc(2);
+            lengthToAddBuffer.writeUInt16LE(lengthToAdd, 0);
+            const sideBuffer = Buffer.alloc(1);
+            sideBuffer.writeUInt8(side, 0);
+            const fuelAccount = useFuelAccount
+                ? (0, functions_1.generateFuelAccount)(userWallet)
+                : web3.SystemProgram.programId;
+            // Generate instruction
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        Buffer.from(util.sighash('meteora_dlmm_increase_position_length_automation')),
+                        lengthToAddBuffer,
+                        sideBuffer,
+                    ]),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: true },
+                        { pubkey: lbPair, isSigner: false, isWritable: false },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        {
+                            pubkey: web3.SystemProgram.programId,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        {
+                            pubkey: fuelAccount,
+                            isSigner: false,
+                            isWritable: useFuelAccount !== null && useFuelAccount !== void 0 ? useFuelAccount : false,
+                        },
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    /**
+     * Create a Meteora DLMM rebalance_liquidity instruction via IYF Main's meteora dynamic CPI.
+     *
+     * The rebalance_liquidity instruction allows for complex liquidity management including:
+     * - Removing liquidity from specific bin ranges
+     * - Adding liquidity to new bin ranges
+     * - Claiming fees and rewards
+     * - All in a single atomic transaction
+     *
+     * @param params - RebalanceLiquidityIxParams containing all necessary accounts and parameters
+     * @returns TransactionInstruction for the rebalance_liquidity operation
+     */
+    rebalanceLiquidity(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, lbPair, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, activeId, pdaTokenType, maxActiveBinSlippage, shouldClaimFee, shouldClaimReward, minWithdrawXAmount, maxDepositXAmount, minWithdrawYAmount, maxDepositYAmount, removeLiquidityParams, addLiquidityParams, shrinkMode, }) {
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else {
+                // Default: ATA
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            // Derive bin array bitmap extension
+            const lowerBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(activeId + addLiquidityParams[0].minDeltaId));
+            const upperBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(activeId + addLiquidityParams[0].maxDeltaId));
+            const binArrayBitmapExtension = this.isOverflowDefaultBinArrayBitmap(lowerBinArrayIndex) ||
+                this.isOverflowDefaultBinArrayBitmap(upperBinArrayIndex)
+                ? this.pda.meteora.deriveBinArrayBitmapExtension(lbPair)
+                : METEORA_DLMM_PROGRAM;
+            // Derive reserves
+            const reserveX = this.pda.meteora.deriveReserve(tokenXMint, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenYMint, lbPair);
+            // Derive bin arrays based on activeId, minDeltaId, and maxDeltaId
+            const lowerBinId = activeId + addLiquidityParams[0].minDeltaId;
+            const upperBinId = activeId + addLiquidityParams[0].maxDeltaId;
+            const binArrays = this.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+            // Serialize RebalanceLiquidityParams
+            const rebalanceParamsData = this.serializeRebalanceLiquidityParams({
+                activeId,
+                maxActiveBinSlippage,
+                shouldClaimFee,
+                shouldClaimReward,
+                minWithdrawXAmount,
+                maxDepositXAmount,
+                minWithdrawYAmount,
+                maxDepositYAmount,
+                shrinkMode,
+                removeLiquidityParams,
+                addLiquidityParams,
+            });
+            // Serialize RemainingAccountsInfo (default empty for now - no transfer hooks)
+            const remainingAccountsInfo = this.serializeRemainingAccountsInfo({
+                slices: [],
+            });
+            // Build instruction data: sighash + RebalanceLiquidityParams + RemainingAccountsInfo
+            const instructionData = Buffer.concat([
+                Buffer.from(util.sighash('rebalance_liquidity')),
+                rebalanceParamsData,
+                remainingAccountsInfo,
+            ]);
+            // Build raw Meteora instruction
+            const meteoraIx = new web3.TransactionInstruction({
+                data: instructionData,
+                keys: [
+                    { pubkey: position, isSigner: false, isWritable: true }, // position (Mutable)
+                    { pubkey: lbPair, isSigner: false, isWritable: true }, // lbPair (Mutable)
+                    {
+                        pubkey: binArrayBitmapExtension,
+                        isSigner: false,
+                        isWritable: !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM),
+                    }, // binArrayBitmapExtension
+                    { pubkey: userTokenX, isSigner: false, isWritable: true }, // userTokenX (Mutable)
+                    { pubkey: userTokenY, isSigner: false, isWritable: true }, // userTokenY (Mutable)
+                    { pubkey: reserveX, isSigner: false, isWritable: true }, // reserveX (Mutable)
+                    { pubkey: reserveY, isSigner: false, isWritable: true }, // reserveY (Mutable)
+                    { pubkey: tokenXMint, isSigner: false, isWritable: false }, // tokenXMint
+                    { pubkey: tokenYMint, isSigner: false, isWritable: false }, // tokenYMint
+                    { pubkey: userPda, isSigner: false, isWritable: false }, // sender (Signer - signed by IYF Main)
+                    { pubkey: userWallet, isSigner: false, isWritable: true }, // rentReceiver (Mutable)
+                    { pubkey: tokenXProgram, isSigner: false, isWritable: false }, // tokenXProgram
+                    { pubkey: tokenYProgram, isSigner: false, isWritable: false }, // tokenYProgram
+                    { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false }, // memoProgram
+                    {
+                        pubkey: web3.SystemProgram.programId,
+                        isSigner: false,
+                        isWritable: false,
+                    }, // systemProgram
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false }, // eventAuthority
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false }, // program
+                    // Bin arrays as remaining accounts
+                    ...binArrays.map(pubkey => ({
+                        pubkey,
+                        isSigner: false,
+                        isWritable: true,
+                    })),
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false }, // program
+                ],
+                programId: METEORA_DLMM_PROGRAM,
+            });
+            return yield this.ix.iyfMain.meteoraDynamicCpi({
+                connection,
+                userWallet,
+                meteoraIx,
+            });
+        });
+    }
+    /**
+     * Serialize RebalanceLiquidityParams to match Rust struct layout
+     */
+    serializeRebalanceLiquidityParams(params) {
+        var _a;
+        const buffers = [];
+        // activeId (i32)
+        const activeIdBuf = Buffer.alloc(4);
+        activeIdBuf.writeInt32LE(params.activeId, 0);
+        buffers.push(activeIdBuf);
+        // maxActiveBinSlippage (u16)
+        const slippageBuf = Buffer.alloc(2);
+        slippageBuf.writeUInt16LE(params.maxActiveBinSlippage, 0);
+        buffers.push(slippageBuf);
+        // shouldClaimFee (bool as u8)
+        buffers.push(Buffer.from([params.shouldClaimFee ? 1 : 0]));
+        // shouldClaimReward (bool as u8)
+        buffers.push(Buffer.from([params.shouldClaimReward ? 1 : 0]));
+        // minWithdrawXAmount (u64)
+        buffers.push(params.minWithdrawXAmount.toArrayLike(Buffer, 'le', 8));
+        // maxDepositXAmount (u64)
+        buffers.push(params.maxDepositXAmount.toArrayLike(Buffer, 'le', 8));
+        // minWithdrawYAmount (u64)
+        buffers.push(params.minWithdrawYAmount.toArrayLike(Buffer, 'le', 8));
+        // maxDepositYAmount (u64)
+        buffers.push(params.maxDepositYAmount.toArrayLike(Buffer, 'le', 8));
+        // shrink_mode (u8) + padding [u8; 31]
+        const paddingBuf = Buffer.alloc(32, 0);
+        paddingBuf[0] = (_a = params.shrinkMode) !== null && _a !== void 0 ? _a : types_1.ShrinkMode.NoShrinkBoth;
+        buffers.push(paddingBuf);
+        // removeLiquidityParams Vec (length as u32, then each RemoveLiquidityParams)
+        const removeLenBuf = Buffer.alloc(4);
+        removeLenBuf.writeUInt32LE(params.removeLiquidityParams.length, 0);
+        buffers.push(removeLenBuf);
+        for (const removeParam of params.removeLiquidityParams) {
+            // minBinId: Option<i32>
+            if (removeParam.minBinId !== undefined) {
+                buffers.push(Buffer.from([1])); // Some
+                const minBinIdBuf = Buffer.alloc(4);
+                minBinIdBuf.writeInt32LE(removeParam.minBinId, 0);
+                buffers.push(minBinIdBuf);
+            }
+            else {
+                buffers.push(Buffer.from([0])); // None
+            }
+            // maxBinId: Option<i32>
+            if (removeParam.maxBinId !== undefined) {
+                buffers.push(Buffer.from([1])); // Some
+                const maxBinIdBuf = Buffer.alloc(4);
+                maxBinIdBuf.writeInt32LE(removeParam.maxBinId, 0);
+                buffers.push(maxBinIdBuf);
+            }
+            else {
+                buffers.push(Buffer.from([0])); // None
+            }
+            // bps (u16)
+            const bpsBuf = Buffer.alloc(2);
+            bpsBuf.writeUInt16LE(removeParam.bps, 0);
+            buffers.push(bpsBuf);
+            // padding [u8; 16]
+            buffers.push(Buffer.alloc(16, 0));
+        }
+        // addLiquidityParams Vec (length as u32, then each AddLiquidityParams)
+        const addLenBuf = Buffer.alloc(4);
+        addLenBuf.writeUInt32LE(params.addLiquidityParams.length, 0);
+        buffers.push(addLenBuf);
+        for (const addParam of params.addLiquidityParams) {
+            // minDeltaId (i32)
+            const minDeltaIdBuf = Buffer.alloc(4);
+            minDeltaIdBuf.writeInt32LE(addParam.minDeltaId, 0);
+            buffers.push(minDeltaIdBuf);
+            // maxDeltaId (i32)
+            const maxDeltaIdBuf = Buffer.alloc(4);
+            maxDeltaIdBuf.writeInt32LE(addParam.maxDeltaId, 0);
+            buffers.push(maxDeltaIdBuf);
+            // x0 (u64)
+            buffers.push(addParam.x0.toArrayLike(Buffer, 'le', 8));
+            // y0 (u64)
+            buffers.push(addParam.y0.toArrayLike(Buffer, 'le', 8));
+            // deltaX (u64)
+            buffers.push(addParam.deltaX.toArrayLike(Buffer, 'le', 8));
+            // deltaY (u64)
+            buffers.push(addParam.deltaY.toArrayLike(Buffer, 'le', 8));
+            // bitFlag (u8)
+            buffers.push(Buffer.from([addParam.bitFlag]));
+            // favorXInActiveId (bool as u8)
+            buffers.push(Buffer.from([addParam.favorXInActiveId ? 1 : 0]));
+            // padding [u8; 16]
+            buffers.push(Buffer.alloc(16, 0));
+        }
+        return Buffer.concat(buffers);
+    }
+    /**
+     * Serialize RemainingAccountsInfo to match Rust struct layout
+     *
+     * The format is a Borsh Vec of AccountsTypeSlice:
+     * - [slices_count: u32] - number of slices
+     * - For each slice: [accountsType: u8 (or u8+u8 for TransferHookMultiReward)][length: u8]
+     *
+     * This is passed directly to Anchor methods which wrap it in another Vec<u8>.
+     */
+    serializeRemainingAccountsInfo(info) {
+        const buffers = [];
+        // Vec length (u32) - number of slices
+        const lenBuf = Buffer.alloc(4);
+        lenBuf.writeUInt32LE(info.slices.length, 0);
+        buffers.push(lenBuf);
+        // Serialize each slice
+        for (const slice of info.slices) {
+            // AccountsType enum (varies in size)
+            if (slice.accountsType === 3 && slice.multiRewardIndex !== undefined) {
+                // TransferHookMultiReward(u8)
+                buffers.push(Buffer.from([3, slice.multiRewardIndex]));
+            }
+            else {
+                buffers.push(Buffer.from([slice.accountsType]));
+            }
+            // length (u8)
+            buffers.push(Buffer.from([slice.length]));
+        }
+        return Buffer.concat(buffers);
+    }
+    /**
+     * Remove liquidity from a bin range in a Meteora DLMM position via IYF Main's meteora dynamic CPI.
+     *
+     * This instruction withdraws liquidity from the specified bin range.
+     * The bin arrays for the range are automatically derived and included as remaining accounts.
+     *
+     * @param params - RemoveLiquidityByRange2 parameters
+     * @returns TransactionInstruction for the remove_liquidity_by_range2 operation
+     */
+    removeLiquidityByRange2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, fromBinId, toBinId, bpsToRemove, pdaTokenType, remainingAccountsInfo: remainingAccountsInfoParam, }) {
+            var _b, _c;
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else {
+                // Default: ATA
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            // Derive bin array bitmap extension
+            const lowerBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(fromBinId));
+            const upperBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(toBinId));
+            const binArrayBitmapExtension = this.isOverflowDefaultBinArrayBitmap(lowerBinArrayIndex) ||
+                this.isOverflowDefaultBinArrayBitmap(upperBinArrayIndex)
+                ? this.pda.meteora.deriveBinArrayBitmapExtension(lbPair)
+                : METEORA_DLMM_PROGRAM;
+            // Derive reserves
+            const reserveX = this.pda.meteora.deriveReserve(tokenXMint, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenYMint, lbPair);
+            // Derive bin arrays for the range
+            const binArrays = this.pda.meteora.deriveBinArrays(lbPair, fromBinId, toBinId);
+            // Build instruction data: sighash + fromBinId(i32) + toBinId(i32) + bpsToRemove(u16) + remainingAccountsInfo
+            const fromBinIdBuffer = Buffer.alloc(4);
+            fromBinIdBuffer.writeInt32LE(fromBinId, 0);
+            const toBinIdBuffer = Buffer.alloc(4);
+            toBinIdBuffer.writeInt32LE(toBinId, 0);
+            const bpsToRemoveBuffer = Buffer.alloc(2);
+            bpsToRemoveBuffer.writeUInt16LE(bpsToRemove, 0);
+            // Serialize RemainingAccountsInfo
+            // Use provided remainingAccountsInfo or default to empty slices (no transfer hooks)
+            // Note: Bin arrays are passed as regular remaining accounts, NOT in slices
+            const remainingAccountsInfoSerialized = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfoParam === null || remainingAccountsInfoParam === void 0 ? void 0 : remainingAccountsInfoParam.slices) !== null && _b !== void 0 ? _b : [],
+            });
+            const instructionData = Buffer.concat([
+                Buffer.from(util.sighash('remove_liquidity_by_range2', undefined, true)),
+                fromBinIdBuffer,
+                toBinIdBuffer,
+                bpsToRemoveBuffer,
+                remainingAccountsInfoSerialized,
+            ]);
+            // Build raw Meteora instruction
+            // Account order from IDL: position, lbPair, binArrayBitmapExtension, userTokenX, userTokenY,
+            // reserveX, reserveY, tokenXMint, tokenYMint, sender, tokenXProgram, tokenYProgram,
+            // memoProgram, eventAuthority, program + bin arrays as remaining accounts + transfer hook accounts
+            const meteoraIx = new web3.TransactionInstruction({
+                data: instructionData,
+                keys: [
+                    { pubkey: position, isSigner: false, isWritable: true }, // position (Mutable)
+                    { pubkey: lbPair, isSigner: false, isWritable: true }, // lbPair (Mutable)
+                    {
+                        pubkey: binArrayBitmapExtension,
+                        isSigner: false,
+                        isWritable: !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM),
+                    }, // binArrayBitmapExtension (optional, writable when real PDA)
+                    { pubkey: userTokenX, isSigner: false, isWritable: true }, // userTokenX (Mutable)
+                    { pubkey: userTokenY, isSigner: false, isWritable: true }, // userTokenY (Mutable)
+                    { pubkey: reserveX, isSigner: false, isWritable: true }, // reserveX (Mutable)
+                    { pubkey: reserveY, isSigner: false, isWritable: true }, // reserveY (Mutable)
+                    { pubkey: tokenXMint, isSigner: false, isWritable: false }, // tokenXMint
+                    { pubkey: tokenYMint, isSigner: false, isWritable: false }, // tokenYMint
+                    { pubkey: userPda, isSigner: false, isWritable: false }, // sender (Signer - signed by IYF Main)
+                    { pubkey: tokenXProgram, isSigner: false, isWritable: false }, // tokenXProgram
+                    { pubkey: tokenYProgram, isSigner: false, isWritable: false }, // tokenYProgram
+                    { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false }, // memoProgram
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false }, // eventAuthority
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false }, // program
+                    // Bin arrays as remaining accounts
+                    ...binArrays.map(pubkey => ({
+                        pubkey,
+                        isSigner: false,
+                        isWritable: true,
+                    })),
+                    // Transfer hook accounts (if any) - order must match slices order
+                    ...((_c = remainingAccountsInfoParam === null || remainingAccountsInfoParam === void 0 ? void 0 : remainingAccountsInfoParam.accounts) !== null && _c !== void 0 ? _c : []),
+                ],
+                programId: METEORA_DLMM_PROGRAM,
+            });
+            return yield this.ix.iyfMain.meteoraDynamicCpi({
+                connection,
+                userWallet,
+                meteoraIx,
+            });
+        });
+    }
+    /**
+     * Close an empty Meteora DLMM position via IYF Main's meteora dynamic CPI.
+     *
+     * This instruction closes a position and returns the rent to the user.
+     * The position must be empty (no liquidity) for this to succeed.
+     *
+     * @param params - ClosePosition2 parameters
+     * @returns TransactionInstruction for the close_position2 operation
+     */
+    closePosition2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, }) {
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Build instruction data: sighash only (no args)
+            const instructionData = Buffer.from(util.sighash('close_position2', undefined, true));
+            // Build raw Meteora instruction
+            // Account order from IDL: position, sender, rentReceiver, eventAuthority, program
+            const meteoraIx = new web3.TransactionInstruction({
+                data: instructionData,
+                keys: [
+                    { pubkey: position, isSigner: false, isWritable: true }, // position (Mutable)
+                    { pubkey: userPda, isSigner: false, isWritable: false }, // sender (Signer - signed by IYF Main)
+                    { pubkey: userWallet, isSigner: false, isWritable: true }, // rentReceiver (Mutable)
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false }, // eventAuthority
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false }, // program
+                ],
+                programId: METEORA_DLMM_PROGRAM,
+            });
+            return yield this.ix.iyfMain.meteoraDynamicCpi({
+                connection,
+                userWallet,
+                meteoraIx,
+            });
+        });
+    }
+    /**
+     * Close a Meteora DLMM position only if it is empty via IYF Main's meteora dynamic CPI.
+     *
+     * This instruction is similar to closePosition2 but will fail silently if the position
+     * still has liquidity. This is useful for safely attempting to close a position without
+     * knowing its current state.
+     *
+     * @param params - ClosePositionIfEmpty parameters
+     * @returns TransactionInstruction for the close_position_if_empty operation
+     */
+    closePositionIfEmpty(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, }) {
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Build instruction data: sighash only (no args)
+            const instructionData = Buffer.from(util.sighash('close_position_if_empty'));
+            // Build raw Meteora instruction
+            // Account order from IDL: position, sender, rentReceiver, eventAuthority, program
+            const meteoraIx = new web3.TransactionInstruction({
+                data: instructionData,
+                keys: [
+                    { pubkey: position, isSigner: false, isWritable: true }, // position (Mutable)
+                    { pubkey: userPda, isSigner: false, isWritable: false }, // sender (Signer - signed by IYF Main)
+                    { pubkey: userWallet, isSigner: false, isWritable: true }, // rentReceiver (Mutable)
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: false }, // eventAuthority
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false }, // program
+                ],
+                programId: METEORA_DLMM_PROGRAM,
+            });
+            return yield this.ix.iyfMain.meteoraDynamicCpi({
+                connection,
+                userWallet,
+                meteoraIx,
+            });
+        });
+    }
+    /**
+     * Rebalance liquidity in a Meteora DLMM position via IYF Extension for automation.
+     *
+     * This is the automation version that uses HS_AUTHORITY as the signer.
+     * Wraps via iyfExtensionExecuteV2 instead of meteoraDynamicCpi.
+     *
+     * @param params - RebalanceLiquidityIxParams containing all necessary accounts and parameters
+     * @returns TransactionInstruction for the rebalance_liquidity automation operation
+     */
+    rebalanceLiquidityAutomation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, position, lbPair, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, activeId, pdaTokenType, maxActiveBinSlippage, shouldClaimFee, shouldClaimReward, minWithdrawXAmount, maxDepositXAmount, minWithdrawYAmount, maxDepositYAmount, removeLiquidityParams, addLiquidityParams, shrinkMode, rewardInfos, remainingAccountsInfo, }) {
+            var _b, _c;
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else {
+                // Default: ATA
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            // Collect all bin IDs from both remove and add params
+            const allBinIds = [];
+            for (const p of removeLiquidityParams) {
+                if (p.minBinId !== undefined && p.maxBinId !== undefined) {
+                    allBinIds.push(p.minBinId, p.maxBinId);
+                }
+                else {
+                    if (p.minBinId === undefined) {
+                        throw new Error(`rebalanceLiquidityAutomation: removeLiquidityParams.minBinid is not optional.`);
+                    }
+                    else {
+                        throw new Error(`rebalanceLiquidityAutomation: removeLiquidityParams.maxBinId is not optional.`);
+                    }
+                }
+            }
+            for (const p of addLiquidityParams) {
+                allBinIds.push(activeId + p.minDeltaId, activeId + p.maxDeltaId);
+            }
+            if (allBinIds.length === 0) {
+                throw new Error('rebalanceLiquidityAutomation: both removeLiquidityParams and addLiquidityParams are empty');
+            }
+            const minBinId = Math.min(...allBinIds);
+            const maxBinId = Math.max(...allBinIds);
+            // Derive bin array bitmap extension
+            const lowerBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(minBinId));
+            const upperBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(maxBinId));
+            const binArrayBitmapExtension = this.isOverflowDefaultBinArrayBitmap(lowerBinArrayIndex) ||
+                this.isOverflowDefaultBinArrayBitmap(upperBinArrayIndex)
+                ? this.pda.meteora.deriveBinArrayBitmapExtension(lbPair)
+                : METEORA_DLMM_PROGRAM;
+            // Derive reserves
+            const reserveX = this.pda.meteora.deriveReserve(tokenXMint, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenYMint, lbPair);
+            let binArrays;
+            const lowerBinId = minBinId;
+            const upperBinId = maxBinId;
+            binArrays = this.pda.meteora.deriveBinArrays(lbPair, lowerBinId, upperBinId);
+            // Build reward remaining accounts if shouldClaimReward and rewardInfos provided
+            const rewardRemainingAccounts = [];
+            if (shouldClaimReward && rewardInfos && rewardInfos.length > 0) {
+                console.log(`[rebalanceLiquidityAutomation] Building reward accounts for ${rewardInfos.length} reward(s)`);
+                for (const reward of rewardInfos) {
+                    // User reward token account (ATA or STA based on pdaTokenType)
+                    let userRewardToken = (0, functions_1.generateUserPdaStorageAccount)(userPda, reward.rewardMint);
+                    console.log(`[rebalanceLiquidityAutomation] Reward: vault=${reward.rewardVault.toString()}, userToken=${userRewardToken.toString()}, mint=${reward.rewardMint.toString()}, program=${reward.rewardTokenProgram.toString()}`);
+                    // Add reward accounts in order: vault, userToken, mint, tokenProgram
+                    rewardRemainingAccounts.push({ pubkey: reward.rewardVault, isSigner: false, isWritable: true }, { pubkey: userRewardToken, isSigner: false, isWritable: true }, { pubkey: reward.rewardMint, isSigner: false, isWritable: false }, {
+                        pubkey: reward.rewardTokenProgram,
+                        isSigner: false,
+                        isWritable: false,
+                    });
+                }
+                console.log(`[rebalanceLiquidityAutomation] Total reward remaining accounts: ${rewardRemainingAccounts.length}`);
+            }
+            else if (shouldClaimReward) {
+                console.log(`[rebalanceLiquidityAutomation] shouldClaimReward=true but no rewardInfos provided!`);
+            }
+            // Serialize RebalanceLiquidityParams
+            const rebalanceParamsData = this.serializeRebalanceLiquidityParams({
+                activeId,
+                maxActiveBinSlippage,
+                shouldClaimFee,
+                shouldClaimReward,
+                minWithdrawXAmount,
+                maxDepositXAmount,
+                minWithdrawYAmount,
+                maxDepositYAmount,
+                shrinkMode,
+                removeLiquidityParams,
+                addLiquidityParams,
+            });
+            // Serialize RemainingAccountsInfo from passed parameter or use empty slices
+            const serializedRemainingAccountsInfo = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.slices) !== null && _b !== void 0 ? _b : [],
+            });
+            // Build instruction data: sighash + RebalanceLiquidityParams + RemainingAccountsInfo
+            // The handler takes two typed Anchor args (not Vec<u8>), so no length prefix needed.
+            const instructionData = Buffer.concat([
+                Buffer.from(util.sighash('meteora_dlmm_rebalance_liquidity_automation')),
+                rebalanceParamsData,
+                serializedRemainingAccountsInfo,
+            ]);
+            // Generate instruction via IYF Extension
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: new web3.TransactionInstruction({
+                    data: instructionData,
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: true },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        {
+                            pubkey: binArrayBitmapExtension,
+                            isSigner: false,
+                            isWritable: !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM),
+                        },
+                        { pubkey: userTokenX, isSigner: false, isWritable: true },
+                        { pubkey: userTokenY, isSigner: false, isWritable: true },
+                        { pubkey: reserveX, isSigner: false, isWritable: true },
+                        { pubkey: reserveY, isSigner: false, isWritable: true },
+                        { pubkey: tokenXMint, isSigner: false, isWritable: false },
+                        { pubkey: tokenYMint, isSigner: false, isWritable: false },
+                        { pubkey: tokenXProgram, isSigner: false, isWritable: false },
+                        { pubkey: tokenYProgram, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                        {
+                            pubkey: web3.SystemProgram.programId,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        // Transfer hook accounts (from fetchRemainingAccountsInfo)
+                        ...((_c = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.accounts) !== null && _c !== void 0 ? _c : []),
+                        // Bin arrays as remaining accounts
+                        ...binArrays.map(pubkey => ({
+                            pubkey,
+                            isSigner: false,
+                            isWritable: true,
+                        })),
+                        // Boundary account
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        // Reward accounts after boundary account
+                        ...rewardRemainingAccounts,
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    /**
+     * Remove liquidity from a bin range in a Meteora DLMM position via IYF Extension for automation.
+     *
+     * This is the automation version that uses HS_AUTHORITY as the signer.
+     * Supports larger bin ranges (not limited to 70-bin chunks).
+     *
+     * @param params - RemoveLiquidityByRange2AutomationParams parameters
+     * @returns TransactionInstruction for the remove_liquidity_by_range2 automation operation
+     */
+    removeLiquidityByRange2Automation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, fromBinId, toBinId, bpsToRemove, pdaTokenType, remainingAccountsInfo, }) {
+            var _b, _c;
+            // Initialize Anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate user PDA
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            // Generate user token accounts based on pdaTokenType
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else {
+                // Default: ATA
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            // Derive bin array bitmap extension
+            const lowerBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(fromBinId));
+            const upperBinArrayIndex = this.binIdToBinArrayIndex(new bn_js_1.default(toBinId));
+            const binArrayBitmapExtension = this.isOverflowDefaultBinArrayBitmap(lowerBinArrayIndex) ||
+                this.isOverflowDefaultBinArrayBitmap(upperBinArrayIndex)
+                ? this.pda.meteora.deriveBinArrayBitmapExtension(lbPair)
+                : METEORA_DLMM_PROGRAM;
+            // Derive reserves
+            const reserveX = this.pda.meteora.deriveReserve(tokenXMint, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenYMint, lbPair);
+            // Derive bin arrays for the range
+            const binArrays = this.pda.meteora.deriveBinArrays(lbPair, fromBinId, toBinId);
+            // Build instruction data: fromBinId(i32) + toBinId(i32) + bpsToRemove(u16) + remainingAccountsInfo
+            const fromBinIdBuffer = Buffer.alloc(4);
+            fromBinIdBuffer.writeInt32LE(fromBinId, 0);
+            const toBinIdBuffer = Buffer.alloc(4);
+            toBinIdBuffer.writeInt32LE(toBinId, 0);
+            const bpsToRemoveBuffer = Buffer.alloc(2);
+            bpsToRemoveBuffer.writeUInt16LE(bpsToRemove, 0);
+            // Serialize RemainingAccountsInfo
+            const remainingAccountsInfoSerialized = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.slices) !== null && _b !== void 0 ? _b : [],
+            });
+            const instructionData = Buffer.concat([
+                fromBinIdBuffer,
+                toBinIdBuffer,
+                bpsToRemoveBuffer,
+                remainingAccountsInfoSerialized,
+            ]);
+            // For Anchor Vec<u8> parameter, we need to prepend the length as u32 LE
+            const instructionDataVec = Buffer.alloc(4 + instructionData.length);
+            instructionDataVec.writeUInt32LE(instructionData.length, 0);
+            instructionData.copy(instructionDataVec, 4);
+            // Generate instruction via IYF Extension
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix: new web3.TransactionInstruction({
+                    data: Buffer.concat([
+                        Buffer.from(util.sighash('meteora_dlmm_withdraw_2_automation')),
+                        instructionDataVec,
+                    ]),
+                    keys: [
+                        { pubkey: userPda, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: true },
+                        { pubkey: position, isSigner: false, isWritable: true },
+                        { pubkey: lbPair, isSigner: false, isWritable: true },
+                        {
+                            pubkey: binArrayBitmapExtension,
+                            isSigner: false,
+                            isWritable: !binArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM),
+                        },
+                        { pubkey: userTokenX, isSigner: false, isWritable: true },
+                        { pubkey: userTokenY, isSigner: false, isWritable: true },
+                        { pubkey: reserveX, isSigner: false, isWritable: true },
+                        { pubkey: reserveY, isSigner: false, isWritable: true },
+                        { pubkey: tokenXMint, isSigner: false, isWritable: false },
+                        { pubkey: tokenYMint, isSigner: false, isWritable: false },
+                        { pubkey: tokenXProgram, isSigner: false, isWritable: false },
+                        { pubkey: tokenYProgram, isSigner: false, isWritable: false },
+                        {
+                            pubkey: METEORA_EVENT_AUTHORITY,
+                            isSigner: false,
+                            isWritable: false,
+                        },
+                        { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: false },
+                        { pubkey: addresses_1.MEMO_PROGRAM, isSigner: false, isWritable: false },
+                        // Bin arrays as remaining accounts
+                        ...binArrays.map(pubkey => ({
+                            pubkey,
+                            isSigner: false,
+                            isWritable: true,
+                        })),
+                        // Transfer hook accounts (if any)
+                        ...((_c = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.accounts) !== null && _c !== void 0 ? _c : []),
+                    ],
+                    programId: addresses_1.IYF_EXTENSION,
+                }),
+            });
+        });
+    }
+    addLiquidity2Automation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, layers, checkRange, userTokenXAmount, userTokenYAmount, chunkLowerOffset, chunkUpperOffset, remainingAccountsInfo, pdaTokenType, lowerBinId, upperBinId, }) {
+            var _b, _c;
+            anchor_1.Anchor.initialize(connection);
+            const reserveX = this.pda.meteora.deriveReserve(tokenXMint, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenYMint, lbPair);
+            const derivedBinArrayBitmapExtension = this.pda.meteora.deriveBinArrayBitmapExtension(lbPair);
+            const binArrayBitmapExtensionInfo = yield connection.getAccountInfo(derivedBinArrayBitmapExtension);
+            const actualBinArrayBitmapExtension = binArrayBitmapExtensionInfo
+                ? derivedBinArrayBitmapExtension
+                : METEORA_DLMM_PROGRAM;
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else {
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            // --- Serialize instruction data ---
+            const sighash = Buffer.from(util.sighash('meteora_dlmm_add_liquidity_2_automation'));
+            layers.forEach((layer, index) => {
+                const validateByteField = (fieldName, value, maxValue) => {
+                    if (!Number.isInteger(value) || value < 0 || value > maxValue) {
+                        throw new Error(`layers[${index}].${fieldName} must be an integer between 0 and ${maxValue}`);
+                    }
+                };
+                validateByteField('strategyTypeX', layer.strategyTypeX, 255);
+                validateByteField('strategyTypeY', layer.strategyTypeY, 255);
+                validateByteField('percentageX', layer.percentageX, 100);
+                validateByteField('percentageY', layer.percentageY, 100);
+            });
+            // Vec<HybridLayer>: u32 length + 4 u8s per layer
+            const layersLenBuf = Buffer.alloc(4);
+            layersLenBuf.writeUInt32LE(layers.length, 0);
+            const layersBuf = Buffer.concat([
+                layersLenBuf,
+                ...layers.map(l => Buffer.from([
+                    l.strategyTypeX,
+                    l.strategyTypeY,
+                    l.percentageX,
+                    l.percentageY,
+                ])),
+            ]);
+            // Option<[i32; 2]> check_range
+            const checkRangeBuf = checkRange
+                ? (() => {
+                    const buf = Buffer.alloc(9);
+                    buf.writeUInt8(1, 0);
+                    buf.writeInt32LE(checkRange.lowerRange, 1);
+                    buf.writeInt32LE(checkRange.upperRange, 5);
+                    return buf;
+                })()
+                : Buffer.from([0]);
+            // Option<u64> user_token_x_amount
+            const xAmountBuf = userTokenXAmount
+                ? Buffer.concat([
+                    Buffer.from([1]),
+                    Buffer.from(userTokenXAmount.toArrayLike(Buffer, 'le', 8)),
+                ])
+                : Buffer.from([0]);
+            // Option<u64> user_token_y_amount
+            const yAmountBuf = userTokenYAmount
+                ? Buffer.concat([
+                    Buffer.from([1]),
+                    Buffer.from(userTokenYAmount.toArrayLike(Buffer, 'le', 8)),
+                ])
+                : Buffer.from([0]);
+            // Option<i32> chunk_lower_offset
+            const chunkLowerBuf = chunkLowerOffset !== undefined
+                ? (() => {
+                    const b = Buffer.alloc(5);
+                    b.writeUInt8(1, 0);
+                    b.writeInt32LE(chunkLowerOffset, 1);
+                    return b;
+                })()
+                : Buffer.from([0]);
+            // Option<i32> chunk_upper_offset
+            const chunkUpperBuf = chunkUpperOffset !== undefined
+                ? (() => {
+                    const b = Buffer.alloc(5);
+                    b.writeUInt8(1, 0);
+                    b.writeInt32LE(chunkUpperOffset, 1);
+                    return b;
+                })()
+                : Buffer.from([0]);
+            // Vec<u8> remaining_accounts_info — needs u32 Vec length prefix (like depositRelativeAutomation)
+            const defaultSlices = [
+                { accountsType: 0, length: 0 },
+                { accountsType: 1, length: 0 },
+            ];
+            const remainingAccountsInfoSerialized = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.slices) !== null && _b !== void 0 ? _b : defaultSlices,
+            });
+            const raiLenBuf = Buffer.alloc(4);
+            raiLenBuf.writeUInt32LE(remainingAccountsInfoSerialized.length, 0);
+            const remainingAccountsInfoWithLength = Buffer.concat([
+                raiLenBuf,
+                remainingAccountsInfoSerialized,
+            ]);
+            // --- Bin arrays ---
+            const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, lowerBinId, upperBinId);
+            const binArrayAccounts = binArrays.map(binArray => ({
+                pubkey: binArray,
+                isSigner: false,
+                isWritable: true,
+            }));
+            const transferHookAccounts = (_c = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.accounts) !== null && _c !== void 0 ? _c : [];
+            // --- Assemble instruction ---
+            // Account order matches contract MeteoraDlmmAddLiquidity2Automation (meteora.rs:3699)
+            // Same order as meteoraDlmmDepositRelativeAutomation (line 809)
+            const ix = new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    sighash,
+                    layersBuf,
+                    checkRangeBuf,
+                    xAmountBuf,
+                    yAmountBuf,
+                    chunkLowerBuf,
+                    chunkUpperBuf,
+                    remainingAccountsInfoWithLength,
+                ]),
+                keys: [
+                    { pubkey: userPda, isSigner: false, isWritable: false },
+                    { pubkey: addresses_1.HS_AUTHORITY, isSigner: true, isWritable: true },
+                    { pubkey: position, isSigner: false, isWritable: true },
+                    { pubkey: lbPair, isSigner: false, isWritable: true },
+                    { pubkey: userTokenX, isSigner: false, isWritable: true },
+                    { pubkey: userTokenY, isSigner: false, isWritable: true },
+                    { pubkey: reserveX, isSigner: false, isWritable: true },
+                    { pubkey: reserveY, isSigner: false, isWritable: true },
+                    { pubkey: tokenXMint, isSigner: false, isWritable: false },
+                    { pubkey: tokenYMint, isSigner: false, isWritable: false },
+                    { pubkey: tokenXProgram, isSigner: false, isWritable: false },
+                    { pubkey: tokenYProgram, isSigner: false, isWritable: false },
+                    {
+                        pubkey: actualBinArrayBitmapExtension,
+                        isSigner: false,
+                        isWritable: !actualBinArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM),
+                    },
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: true },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: true },
+                    ...transferHookAccounts,
+                    ...binArrayAccounts,
+                ],
+                programId: addresses_1.IYF_EXTENSION,
+            });
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: addresses_1.HS_AUTHORITY,
+                ix,
+            });
+        });
+    }
+    /**
+     * FE-callable mirror of addLiquidity2Automation.
+     * Same hybrid-layer add-liquidity flow, but signed by the user's wallet
+     * instead of HS_AUTHORITY (sighash: meteora_dlmm_add_liquidity_2).
+     */
+    addLiquidity2(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, userWallet, lbPair, position, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, layers, checkRange, userTokenXAmount, userTokenYAmount, chunkLowerOffset, chunkUpperOffset, remainingAccountsInfo, pdaTokenType, lowerBinId, upperBinId, }) {
+            var _b, _c;
+            anchor_1.Anchor.initialize(connection);
+            const reserveX = this.pda.meteora.deriveReserve(tokenXMint, lbPair);
+            const reserveY = this.pda.meteora.deriveReserve(tokenYMint, lbPair);
+            const derivedBinArrayBitmapExtension = this.pda.meteora.deriveBinArrayBitmapExtension(lbPair);
+            const binArrayBitmapExtensionInfo = yield connection.getAccountInfo(derivedBinArrayBitmapExtension);
+            const actualBinArrayBitmapExtension = binArrayBitmapExtensionInfo
+                ? derivedBinArrayBitmapExtension
+                : METEORA_DLMM_PROGRAM;
+            const userPda = (0, functions_1.generateUserPda)(userWallet);
+            let userTokenX;
+            let userTokenY;
+            if (pdaTokenType === types_1.TokenType.LTA) {
+                userTokenX = (0, functions_1.generateLimitToken)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateLimitToken)(userPda, tokenYMint);
+            }
+            else if (pdaTokenType === types_1.TokenType.STA) {
+                userTokenX = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenXMint);
+                userTokenY = (0, functions_1.generateUserPdaStorageAccount)(userPda, tokenYMint);
+            }
+            else {
+                userTokenX = (0, functions_1.generateAta)(userPda, tokenXMint, tokenXProgram);
+                userTokenY = (0, functions_1.generateAta)(userPda, tokenYMint, tokenYProgram);
+            }
+            const sighash = Buffer.from(util.sighash('meteora_dlmm_add_liquidity_2'));
+            layers.forEach((layer, index) => {
+                const validateByteField = (fieldName, value, maxValue) => {
+                    if (!Number.isInteger(value) || value < 0 || value > maxValue) {
+                        throw new Error(`layers[${index}].${fieldName} must be an integer between 0 and ${maxValue}`);
+                    }
+                };
+                validateByteField('strategyTypeX', layer.strategyTypeX, 255);
+                validateByteField('strategyTypeY', layer.strategyTypeY, 255);
+                validateByteField('percentageX', layer.percentageX, 100);
+                validateByteField('percentageY', layer.percentageY, 100);
+            });
+            const layersLenBuf = Buffer.alloc(4);
+            layersLenBuf.writeUInt32LE(layers.length, 0);
+            const layersBuf = Buffer.concat([
+                layersLenBuf,
+                ...layers.map(l => Buffer.from([
+                    l.strategyTypeX,
+                    l.strategyTypeY,
+                    l.percentageX,
+                    l.percentageY,
+                ])),
+            ]);
+            const checkRangeBuf = checkRange
+                ? (() => {
+                    const buf = Buffer.alloc(9);
+                    buf.writeUInt8(1, 0);
+                    buf.writeInt32LE(checkRange.lowerRange, 1);
+                    buf.writeInt32LE(checkRange.upperRange, 5);
+                    return buf;
+                })()
+                : Buffer.from([0]);
+            const xAmountBuf = userTokenXAmount
+                ? Buffer.concat([
+                    Buffer.from([1]),
+                    Buffer.from(userTokenXAmount.toArrayLike(Buffer, 'le', 8)),
+                ])
+                : Buffer.from([0]);
+            const yAmountBuf = userTokenYAmount
+                ? Buffer.concat([
+                    Buffer.from([1]),
+                    Buffer.from(userTokenYAmount.toArrayLike(Buffer, 'le', 8)),
+                ])
+                : Buffer.from([0]);
+            const chunkLowerBuf = chunkLowerOffset !== undefined
+                ? (() => {
+                    const b = Buffer.alloc(5);
+                    b.writeUInt8(1, 0);
+                    b.writeInt32LE(chunkLowerOffset, 1);
+                    return b;
+                })()
+                : Buffer.from([0]);
+            const chunkUpperBuf = chunkUpperOffset !== undefined
+                ? (() => {
+                    const b = Buffer.alloc(5);
+                    b.writeUInt8(1, 0);
+                    b.writeInt32LE(chunkUpperOffset, 1);
+                    return b;
+                })()
+                : Buffer.from([0]);
+            const defaultSlices = [
+                { accountsType: 0, length: 0 },
+                { accountsType: 1, length: 0 },
+            ];
+            const remainingAccountsInfoSerialized = this.serializeRemainingAccountsInfo({
+                slices: (_b = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.slices) !== null && _b !== void 0 ? _b : defaultSlices,
+            });
+            const raiLenBuf = Buffer.alloc(4);
+            raiLenBuf.writeUInt32LE(remainingAccountsInfoSerialized.length, 0);
+            const remainingAccountsInfoWithLength = Buffer.concat([
+                raiLenBuf,
+                remainingAccountsInfoSerialized,
+            ]);
+            const binArrays = meteora_1.MeteoraFunctions.findMeteoraTickArrays(lbPair, lowerBinId, upperBinId);
+            const binArrayAccounts = binArrays.map(binArray => ({
+                pubkey: binArray,
+                isSigner: false,
+                isWritable: true,
+            }));
+            const transferHookAccounts = (_c = remainingAccountsInfo === null || remainingAccountsInfo === void 0 ? void 0 : remainingAccountsInfo.accounts) !== null && _c !== void 0 ? _c : [];
+            const ix = new web3.TransactionInstruction({
+                data: Buffer.concat([
+                    sighash,
+                    layersBuf,
+                    checkRangeBuf,
+                    xAmountBuf,
+                    yAmountBuf,
+                    chunkLowerBuf,
+                    chunkUpperBuf,
+                    remainingAccountsInfoWithLength,
+                ]),
+                keys: [
+                    { pubkey: userPda, isSigner: false, isWritable: false },
+                    { pubkey: userWallet, isSigner: true, isWritable: true },
+                    { pubkey: position, isSigner: false, isWritable: true },
+                    { pubkey: lbPair, isSigner: false, isWritable: true },
+                    { pubkey: userTokenX, isSigner: false, isWritable: true },
+                    { pubkey: userTokenY, isSigner: false, isWritable: true },
+                    { pubkey: reserveX, isSigner: false, isWritable: true },
+                    { pubkey: reserveY, isSigner: false, isWritable: true },
+                    { pubkey: tokenXMint, isSigner: false, isWritable: false },
+                    { pubkey: tokenYMint, isSigner: false, isWritable: false },
+                    { pubkey: tokenXProgram, isSigner: false, isWritable: false },
+                    { pubkey: tokenYProgram, isSigner: false, isWritable: false },
+                    {
+                        pubkey: actualBinArrayBitmapExtension,
+                        isSigner: false,
+                        isWritable: !actualBinArrayBitmapExtension.equals(METEORA_DLMM_PROGRAM),
+                    },
+                    { pubkey: METEORA_EVENT_AUTHORITY, isSigner: false, isWritable: true },
+                    { pubkey: METEORA_DLMM_PROGRAM, isSigner: false, isWritable: true },
+                    ...transferHookAccounts,
+                    ...binArrayAccounts,
+                ],
+                programId: addresses_1.IYF_EXTENSION,
+            });
+            return this.ix.iyfMain.iyfExtensionExecuteV2(connection, {
+                userPda,
+                authority: userWallet,
+                ix,
+            });
+        });
+    }
+}
+exports.MeteoraDlmmIxGenerator = MeteoraDlmmIxGenerator;