@hawksightco/hawk-sdk 1.3.180 → 1.3.182

package/dist/src/ixGenerator/MeteoraDlmmIxGenerator.js

@@ -156,27 +156,199 @@ class MeteoraDlmmIxGenerator {
             const userPda = (0, functions_1.generateUserPda)(userWallet);
             // Generate instruction
             const width = upperBinId - lowerBinId + 1;
-            return this.ix.iyfMain.iyfExtensionExecute(connection, {
-                userWallet,
-                // @ts-ignore
-                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()
+            // @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 }) {
+            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: 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: 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) {
@@ -701,25 +873,167 @@ class MeteoraDlmmIxGenerator {
             });
         });
     }
-    claimFeeAutomation(connection, params) {
-        return __awaiter(this, void 0, void 0, function* () {
+    /**
+     * 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);
-            return new web3.TransactionInstruction({
-                data: Buffer.from([]),
-                keys: [],
-                programId: web3.SystemProgram.programId,
+            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,
+                })
             });
         });
     }
-    claimRewardAutomation(connection, params) {
-        return __awaiter(this, void 0, void 0, function* () {
+    /**
+     * 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);
-            return new web3.TransactionInstruction({
-                data: Buffer.from([]),
-                keys: [],
-                programId: web3.SystemProgram.programId,
+            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,
+                })
             });
         });
     }
@@ -824,6 +1138,125 @@ class MeteoraDlmmIxGenerator {
             });
         });
     }
+    /**
+     * 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);
+            // Derive bin array bitmap extension from actual lb_pair and check if it exists
+            const derivedBinArrayBitmapExtension = this.pda.meteora.deriveBinArrayBitmapExtension(params.lbPair);
+            const binArrayBitmapExtensionInfo = yield connection.getAccountInfo(derivedBinArrayBitmapExtension);
+            const actualBinArrayBitmapExtension = binArrayBitmapExtensionInfo
+                ? derivedBinArrayBitmapExtension
+                : METEORA_DLMM_PROGRAM;
+            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);
+            }
+            // 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,
+            ];
+            console.log('remainingAccounts', remainingAccounts);
+            // 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: actualBinArrayBitmapExtension,
+                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();
+            // 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
@@ -857,6 +1290,43 @@ class MeteoraDlmmIxGenerator {
             });
         });
     }
+    /**
+     * 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,
+                })
+            });
+        });
+    }
     limitCloseAutomation(connection, params) {
         return __awaiter(this, void 0, void 0, function* () {
             // Initialize anchor
@@ -1269,6 +1739,43 @@ class MeteoraDlmmIxGenerator {
             });
         });
     }
+    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.
      *
@@ -1460,13 +1967,20 @@ class MeteoraDlmmIxGenerator {
     }
     /**
      * 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)
+        // 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) {
@@ -1651,5 +2165,101 @@ class MeteoraDlmmIxGenerator {
             });
         });
     }
+    /**
+     * 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 (use program ID as placeholder if not needed)
+            const binArrayBitmapExtension = 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: 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: 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,
+                })
+            });
+        });
+    }
 }
 exports.MeteoraDlmmIxGenerator = MeteoraDlmmIxGenerator;