@hawksightco/hawk-sdk 1.3.169 → 1.3.171

package/dist/src/ixGenerator/MeteoraDlmmIxGenerator.js

@@ -100,6 +100,53 @@ class MeteoraDlmmIxGenerator {
         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
@@ -994,6 +1041,45 @@ class MeteoraDlmmIxGenerator {
             });
         });
     }
+    /**
+     * 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;
@@ -1017,5 +1103,436 @@ class MeteoraDlmmIxGenerator {
             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,
+            });
+        });
+    }
+    /**
+     * 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, }) {
+            // 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 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,
+                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: false }, // 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) {
+        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));
+        // padding [u8; 32] - first byte is shrinkMode (3 = no shrink both sides)
+        const paddingBuf = Buffer.alloc(32, 0);
+        paddingBuf[0] = 3; // shrinkMode: 3 = no shrink both
+        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
+     */
+    serializeRemainingAccountsInfo(info) {
+        const buffers = [];
+        // Vec length (u32)
+        const lenBuf = Buffer.alloc(4);
+        lenBuf.writeUInt32LE(info.slices.length, 0);
+        buffers.push(lenBuf);
+        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 (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: 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: true }, // binArrayBitmapExtension (optional, writable)
+                    { 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,
+            });
+        });
+    }
 }
 exports.MeteoraDlmmIxGenerator = MeteoraDlmmIxGenerator;

package/dist/src/meteora/index.d.ts

@@ -0,0 +1,2 @@
+export * from './liquidityStrategy';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/meteora/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/meteora/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/src/meteora/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./liquidityStrategy"), exports);