@hawksightco/hawk-sdk 0.0.71 → 1.0.1

package/dist/src/classes/Transactions.js

@@ -0,0 +1,1068 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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.txgen = exports.Transactions = void 0;
+const dlmm_1 = require("@meteora-ag/dlmm");
+const web3 = __importStar(require("@solana/web3.js"));
+const bn_js_1 = __importDefault(require("bn.js"));
+const addresses_1 = require("../addresses");
+const functions_1 = require("../functions");
+const types_1 = require("../types");
+const functions_2 = require("../functions");
+const hsToMeteora_1 = require("../hsToMeteora");
+const meteora_1 = require("../meteora");
+const anchor_1 = require("../anchor");
+// import { PDAUtil } from "@orca-so/whirlpools-sdk";
+const hawksight_1 = require("../hawksight");
+const types_2 = require("../types");
+const whirlpools_sdk_1 = require("@orca-so/whirlpools-sdk");
+class Transactions {
+    /**
+     * Generate UserPDA
+     *
+     * @param userWallet
+     * @param farm
+     * @returns
+     */
+    generateUserPda(userWallet, farm = addresses_1.USDC_FARM) {
+        return (0, functions_2.generateUserPda)(userWallet, farm);
+    }
+    /**s
+     * Registers a new entity or user with the necessary parameters, handling transaction creation and response.
+     *
+     * @param connection A Solana web3 connection for interacting with the blockchain.
+     * @param payer The public key of the payer, responsible for transaction fees.
+     * @param params Registration parameters required by the API.
+     * @returns A Promise resolving to the transaction metadata or an error response, depending on the outcome of the registration.
+     */
+    register(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const farm = addresses_1.USDC_FARM;
+            const user = (0, functions_2.generateUserPda)(params.authority, farm);
+            const [stableToken] = web3.PublicKey.findProgramAddressSync([
+                Buffer.from("index-token", "utf-8"),
+                addresses_1.STABLEMINT_1.toBuffer(),
+                farm.toBuffer(),
+                user.toBuffer(),
+            ], anchor_1.Anchor.instance().iyfMain.programId);
+            const [stableToken2] = web3.PublicKey.findProgramAddressSync([
+                Buffer.from("index-token", "utf-8"),
+                addresses_1.STABLEMINT_2.toBuffer(),
+                farm.toBuffer(),
+                user.toBuffer(),
+            ], anchor_1.Anchor.instance().iyfMain.programId);
+            // check if user pda is already registered:
+            try {
+                yield anchor_1.Anchor.instance().iyfMain.account.userAccountMulti.fetch(user, "confirmed");
+                throw new Error(`User PDA for wallet: ${params.authority} is already registered.`);
+            }
+            catch (_b) {
+                return (0, functions_2.createTransactionMeta)({
+                    payer: params.authority,
+                    description: "Register User",
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions: [
+                        yield anchor_1.Anchor.instance().iyfMain.methods
+                            .newUser()
+                            .accounts({
+                            farm,
+                            user,
+                            authority: params.authority,
+                            stableToken: stableToken,
+                            stableMint: addresses_1.STABLEMINT_1,
+                            stableToken2: stableToken2,
+                            stableMint2: addresses_1.STABLEMINT_2,
+                            systemProgram: web3.SystemProgram.programId,
+                            tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                            rent: web3.SYSVAR_RENT_PUBKEY,
+                        })
+                            .instruction(),
+                    ],
+                });
+            }
+        });
+    }
+    /**
+     * Creates meteora instruction that creates new position and deposit.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraCreatePositionAndDeposit(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, new web3.PublicKey(params.pool));
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            const mainInstructions = (yield dlmmPool.initializePositionAndAddLiquidityByStrategy(params.userWallet, params.userWallet, {
+                positionPubKey: params.position,
+                user: userPda,
+                totalXAmount: params.totalXAmount,
+                totalYAmount: params.totalYAmount,
+                strategy: {
+                    maxBinId: params.binRange.upperRange,
+                    minBinId: params.binRange.lowerRange,
+                    strategyType: types_1.StrategyTypeMap[params.distribution],
+                },
+                slippage: params.slippage,
+                skipInputTokenCheck: params.skipInputTokenCheck,
+            }, hsToMeteora_1.meteoraToHawksight)).default();
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Create position and deposit to Meteora DLMM",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates meteora instruction that initializes bin arrays.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraInitializeBinArrays(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const poolAddress = new web3.PublicKey(params.pool);
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, poolAddress);
+            const binArraysRequired = yield (0, dlmm_1.getBinArraysRequiredByPositionRange)(poolAddress, new bn_js_1.default(params.minBinId), new bn_js_1.default(params.maxBinId), dlmmPool.dlmm.program.programId);
+            const mainInstructions = yield dlmmPool.dlmm.initializeBinArrays(binArraysRequired.map((b) => b.index), new web3.PublicKey(params.userWallet));
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Initialize bin arrays for Meteora DLMM pool",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates meteora instruction that deposits to position.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraDeposit(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            let lbPair, maxBinId, minBinId;
+            if (params.fastGeneration !== undefined) {
+                lbPair = params.fastGeneration.pool;
+                maxBinId = params.fastGeneration.upperBinId;
+                minBinId = params.fastGeneration.lowerBinId;
+            }
+            else {
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+                maxBinId = position.upperBinId;
+                minBinId = position.lowerBinId;
+            }
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, new web3.PublicKey(lbPair));
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            const mainInstructions = (yield dlmmPool.addLiquidityByStrategy(params.userWallet, params.userWallet, {
+                positionPubKey: params.position,
+                user: userPda,
+                totalXAmount: params.totalXAmount,
+                totalYAmount: params.totalYAmount,
+                strategy: {
+                    maxBinId,
+                    minBinId,
+                    strategyType: types_1.StrategyTypeMap[params.distribution],
+                },
+                slippage: params.slippage,
+                skipInputTokenCheck: params.skipInputTokenCheck,
+            }, hsToMeteora_1.meteoraToHawksight)).default();
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Deposit to existing position in Meteora DLMM",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates meteora instruction withdraws from a position.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraWithdraw(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            let lbPair, binIdsToRemove;
+            if (params.fastGeneration !== undefined) {
+                lbPair = params.fastGeneration.pool;
+            }
+            else {
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+            }
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair);
+            if (params.fastGeneration === undefined) {
+                const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+                const userPosition = userPositions.find((userPosition) => userPosition.publicKey.toString() === params.position.toString());
+                if (userPosition === undefined) {
+                    throw new Error("Position does not exist."); // this error should not happen...
+                }
+                binIdsToRemove = userPosition.positionData.positionBinData.map((bin) => bin.binId);
+            }
+            else {
+                binIdsToRemove = params.fastGeneration.binIdsToRemove;
+            }
+            const amountBps = params.shouldClaimAndClose
+                ? new bn_js_1.default(10000)
+                : params.amountBps;
+            const mainInstructions = (yield dlmmPool.removeLiquidity(params.userWallet, params.userWallet, {
+                user: userPda,
+                position: params.position,
+                binIds: binIdsToRemove,
+                bps: amountBps,
+                shouldClaimAndClose: params.shouldClaimAndClose,
+            }, hsToMeteora_1.meteoraToHawksight)).default();
+            let description;
+            if (params.shouldClaimAndClose) {
+                description =
+                    "Full position withdrawal with claim and close instructisons from Meteora DLMM";
+            }
+            else if (amountBps.eq(new bn_js_1.default(10000))) {
+                description =
+                    "Full position withdrawal without claim and close instructions from Meteora DLMM";
+            }
+            else {
+                description = "Partial position withdrawal from Meteora DLMM";
+            }
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description,
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates meteora instruction that claims fees and rewards.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraClaim(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            let lbPair;
+            if (params.fastGeneration !== undefined) {
+                lbPair = params.fastGeneration.pool;
+            }
+            else {
+                const position = yield program.account.positionV2.fetch(params.position);
+                lbPair = position.lbPair;
+            }
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, lbPair);
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+            const index = userPositions.findIndex((v) => v.publicKey.equals(params.position));
+            const mainInstructions = (yield dlmmPool.claimAllRewardsByPosition(params.userWallet, params.userWallet, {
+                owner: userPda,
+                position: userPositions[index],
+            }, hsToMeteora_1.meteoraToHawksight)).default();
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Claim fees / rewards from Meteora DLMM Position",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates meteora instruction that closes position.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    meteoraClosePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            const position = yield program.account.positionV2.fetch(params.position);
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, position.lbPair);
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+            const index = userPositions.findIndex((v) => v.publicKey.equals(params.position));
+            yield dlmmPool.getActiveBin();
+            const mainInstructions = yield dlmmPool.closePosition(params.userWallet, {
+                owner: userPda,
+                position: userPositions[index],
+            }, hsToMeteora_1.meteoraToHawksight);
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Close Meteora DLMM Position",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    compoundAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            const position = yield program.account.positionV2.fetch(params.position);
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, position.lbPair);
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+            const index = userPositions.findIndex((v) => v.publicKey.equals(params.position));
+            // Claim fee and claim reward ixs
+            const claimBuilder = yield dlmmPool.claimAllRewardsByPosition(params.userWallet, addresses_1.HS_AUTHORITY, {
+                owner: userPda,
+                position: userPositions[index],
+            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
+            // Re-deposit fees (TODO: How to re-deposit reward tokens that is not X or Y token?)
+            const addLiquidityBuilder = yield dlmmPool.addLiquidityByStrategy(params.userWallet, addresses_1.HS_AUTHORITY, {
+                positionPubKey: params.position,
+                user: userPda,
+                totalXAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                totalYAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                strategy: {
+                    maxBinId: position.upperBinId,
+                    minBinId: position.lowerBinId,
+                    strategyType: types_1.StrategyTypeMap["SPOT-IMBALANCED"], // TODO: how to get the right distribution from chain??
+                },
+                skipInputTokenCheck: true,
+            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
+            const mainInstructions = [
+                // Step 1: Initialize ATA
+                ...claimBuilder.createAtaIxs,
+                // Step 2: Claim rewards and fees
+                ...claimBuilder.mainIxs,
+                // Step 3: Re-deposit fees
+                ...addLiquidityBuilder.mainIxs,
+            ];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Automation IX: Meteora Auto-compound instructions (claim fee, reward, and deposit to position)",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    rebalanceAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            const position = yield program.account.positionV2.fetch(params.currentPosition);
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, position.lbPair);
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            // Step 1: Claim all fees/rewards, remove all liquidity and close current position
+            const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+            const binIdsToRemove = userPositions[0].positionData.positionBinData.map((bin) => bin.binId);
+            const removeLiquidityBuilder = yield dlmmPool.removeLiquidity(params.userWallet, addresses_1.HS_AUTHORITY, {
+                user: userPda,
+                position: params.currentPosition,
+                binIds: binIdsToRemove,
+                bps: new bn_js_1.default(10000),
+                shouldClaimAndClose: true,
+            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
+            // Re-deposit fees (TODO: How to re-deposit reward tokens that is not X or Y token?)
+            const initPositionAndAddLiquidityBuilder = yield dlmmPool.initializePositionAndAddLiquidityByStrategy(params.userWallet, addresses_1.HS_AUTHORITY, {
+                positionPubKey: params.newPosition,
+                user: userPda,
+                totalXAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                totalYAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                strategy: {
+                    maxBinId: params.binRange.upperRange,
+                    minBinId: params.binRange.lowerRange,
+                    strategyType: types_1.StrategyTypeMap[params.distribution],
+                },
+            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
+            // Sweep dust
+            const sweepLiquidityBuilder = yield dlmmPool.addLiquidityByStrategy(params.userWallet, addresses_1.HS_AUTHORITY, {
+                positionPubKey: params.newPosition,
+                user: userPda,
+                totalXAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                totalYAmount: new bn_js_1.default(100000), // This is overriden on-chain, so value here do not matter
+                strategy: {
+                    maxBinId: params.binRange.upperRange,
+                    minBinId: params.binRange.lowerRange,
+                    strategyType: types_1.StrategyTypeMap["SPOT-IMBALANCED"],
+                },
+                skipInputTokenCheck: true,
+            }, hsToMeteora_1.meteoraToHawksightAutomationIxs);
+            const mainInstructions = [
+                // Initialize required ATA
+                ...removeLiquidityBuilder.createAtaIxs,
+                // Remove liquidity
+                ...removeLiquidityBuilder.mainIxs,
+                // Re-deposit liquidity
+                ...initPositionAndAddLiquidityBuilder.mainIxs,
+                // Sweep dust
+                ...sweepLiquidityBuilder.mainIxs,
+            ];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Automation IX: Meteora Auto-rebalance instructions (Close position and deposit to new position)",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates instructions to initialize storage token accounts
+     *
+     * @param connection A Solana web3 connection for interacting with the blockchain.
+     * @param params Parameters required.
+     * @returns A Promise resolving to the transaction metadata or an error response, depending on the outcome of the registration.
+     */
+    initializeStorageTokenAccounts(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const activePoolRewards = [];
+            const mainInstructions = [];
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            if (params.protocol === types_2.Protocol.Meteora && params.pool) {
+                const poolInfo = yield (0, functions_1.getMeteoraPool)(params.pool);
+                if (poolInfo.reward_mint_x !== "11111111111111111111111111111111") {
+                    activePoolRewards.push(new web3.PublicKey(poolInfo.reward_mint_x));
+                }
+                if (poolInfo.reward_mint_y !== "11111111111111111111111111111111") {
+                    activePoolRewards.push(new web3.PublicKey(poolInfo.reward_mint_y));
+                }
+            }
+            const combinedMints = [...params.mints, ...activePoolRewards];
+            const filteredMints = combinedMints.filter((m, i) => combinedMints.findIndex((mint) => mint.equals(m)) === i);
+            const storageAddresses = filteredMints.map((mint) => (0, functions_2.generateUserPdaStorageAccount)(userPda, mint));
+            const accountsData = yield connection.getMultipleAccountsInfo(storageAddresses, "processed");
+            for (let i = 0; i < accountsData.length; i++) {
+                if (!accountsData[i]) {
+                    console.log(`initializing STA: ${filteredMints[i].toBase58()}`);
+                    mainInstructions.push(yield anchor_1.Anchor.instance().iyfMain.methods
+                        .initializeStorageTokenAccountAutomation()
+                        .accounts({
+                        userPda: userPda,
+                        payer: params.userWallet,
+                        mint: filteredMints[i],
+                        storageTokenAccount: storageAddresses[i],
+                        rent: web3.SYSVAR_RENT_PUBKEY,
+                        tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                        systemProgram: web3.SystemProgram.programId,
+                    })
+                        .instruction());
+                }
+            }
+            if (mainInstructions.length) {
+                return (0, functions_2.createTransactionMeta)({
+                    payer: params.userWallet,
+                    description: "Initialize STAs",
+                    addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                    mainInstructions,
+                });
+            }
+            return [];
+        });
+    }
+    limitCloseAutomationIx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params, }) {
+            const program = yield meteora_1.MeteoraDLMM.program(connection);
+            const position = yield program.account.positionV2.fetch(params.position);
+            const dlmmPool = yield meteora_1.MeteoraDLMM.create(connection, position.lbPair);
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet);
+            // Step 1: Claim all fees/rewards, remove all liquidity and close current position
+            const { userPositions } = yield dlmmPool.getPositionsByUserAndLbPair(userPda);
+            const binIdsToRemove = userPositions[0].positionData.positionBinData.map((bin) => bin.binId);
+            // Claim fees and/or rewards, remove liquidity, and possibly close position from Meteora API (if set)
+            const txn = yield dlmmPool.dlmm.removeLiquidity({
+                user: userPda,
+                position: params.position,
+                binIds: binIdsToRemove,
+                bps: new bn_js_1.default(10000),
+                shouldClaimAndClose: true,
+            });
+            // Filter out non-meteora instructions
+            const ixs = (0, functions_2.getIxs)(txn).filter((ix) => ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM));
+            const farm = addresses_1.USDC_FARM;
+            const authority = params.userWallet;
+            const iyfProgram = addresses_1.IYF_MAIN;
+            const hawksightAuthority = addresses_1.HS_AUTHORITY;
+            const { params: _params, data } = this.removeLiquidityByRangeInfo(ixs);
+            const { position: _position, lbPair, binArrayBitmapExtension, reserveX, reserveY, tokenXMint, tokenYMint, tokenXProgram, tokenYProgram, binArrayLower, binArrayUpper, eventAuthority, program: meteoraDlmmProgram, } = _params;
+            const limitCloseAutomationIx = yield anchor_1.Anchor.instance().iyfExtension.methods
+                .meteoraDlmmLimitCloseAutomation(data, params.minBinId, params.maxBinId)
+                .accounts({
+                farm,
+                userPda,
+                authority,
+                iyfProgram,
+                hawksightAuthority,
+                position: _position.pubkey,
+                lbPair: lbPair.pubkey,
+                binArrayBitmapExtension: binArrayBitmapExtension.pubkey,
+                userTokenX: (0, functions_2.generateUserPdaStorageAccount)(userPda, tokenXMint.pubkey),
+                userTokenY: (0, functions_2.generateUserPdaStorageAccount)(userPda, tokenYMint.pubkey),
+                reserveX: reserveX.pubkey,
+                reserveY: reserveY.pubkey,
+                tokenXMint: tokenXMint.pubkey,
+                tokenYMint: tokenYMint.pubkey,
+                tokenXProgram: tokenXProgram.pubkey,
+                tokenYProgram: tokenYProgram.pubkey,
+                binArrayLower: binArrayLower.pubkey,
+                binArrayUpper: binArrayUpper.pubkey,
+                eventAuthority: eventAuthority.pubkey,
+                meteoraDlmmProgram: meteoraDlmmProgram.pubkey,
+                ownerFeeX: (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, tokenXMint.pubkey),
+                ownerFeeY: (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, tokenYMint.pubkey),
+            })
+                .instruction();
+            // Instruction via main hawksight contract
+            const ix = yield anchor_1.Anchor.instance().iyfMain.methods
+                .iyfExtensionExecute(limitCloseAutomationIx.data)
+                .accounts({
+                farm,
+                userPda,
+                authority,
+                iyfProgram,
+                iyfExtensionProgram: addresses_1.IYF_EXTENSION,
+            })
+                .remainingAccounts([
+                limitCloseAutomationIx.keys[4],
+                limitCloseAutomationIx.keys[5],
+                limitCloseAutomationIx.keys[6],
+                limitCloseAutomationIx.keys[7],
+                limitCloseAutomationIx.keys[8],
+                limitCloseAutomationIx.keys[9],
+                limitCloseAutomationIx.keys[10],
+                limitCloseAutomationIx.keys[11],
+                limitCloseAutomationIx.keys[12],
+                limitCloseAutomationIx.keys[13],
+                limitCloseAutomationIx.keys[14],
+                limitCloseAutomationIx.keys[15],
+                limitCloseAutomationIx.keys[16],
+                limitCloseAutomationIx.keys[17],
+                limitCloseAutomationIx.keys[18],
+                limitCloseAutomationIx.keys[19],
+                limitCloseAutomationIx.keys[20],
+                limitCloseAutomationIx.keys[21],
+            ])
+                .instruction();
+            const mainInstructions = [
+                // Limit Close Automation Instruction (Hawksight CPI)
+                ix,
+            ];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Automation IX: Meteora limit close instruction (Full withdraw and close on to specific bin id)",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    removeLiquidityByRangeInfo(ixs) {
+        for (const ix of ixs) {
+            const programIdMatch = ix.programId.equals(addresses_1.METEORA_DLMM_PROGRAM);
+            const _sighashMatch = (0, functions_2.sighashMatch)(ix.data, "RemoveLiquidityByRange");
+            if (programIdMatch && _sighashMatch) {
+                return {
+                    data: ix.data,
+                    params: {
+                        position: ix.keys[0],
+                        lbPair: ix.keys[1],
+                        binArrayBitmapExtension: ix.keys[2],
+                        userTokenX: ix.keys[3],
+                        userTokenY: ix.keys[4],
+                        reserveX: ix.keys[5],
+                        reserveY: ix.keys[6],
+                        tokenXMint: ix.keys[7],
+                        tokenYMint: ix.keys[8],
+                        binArrayLower: ix.keys[9],
+                        binArrayUpper: ix.keys[10],
+                        sender: ix.keys[11],
+                        tokenXProgram: ix.keys[12],
+                        tokenYProgram: ix.keys[13],
+                        eventAuthority: ix.keys[14],
+                        program: ix.keys[15],
+                    },
+                };
+            }
+        }
+        throw new Error(`Unexpected error: Cannot find "RemoveLiquidityByRange" instruction from instructions`);
+    }
+    /**
+     * Creates orca instruction that opens new position
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    orcaOpenPosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet, farm);
+            const position = (0, functions_2.generateOrcaPositionPDA)(params.positionMint);
+            const positionTokenAccount = (0, functions_2.generateAta)(userPda, params.positionMint);
+            const orcaOpenPositionIx = yield anchor_1.Anchor.instance().iyfExtension.methods
+                .orcaOpenPosition(params.tickLowerIndex, params.tickUpperIndex)
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                position,
+                positionMint: params.positionMint,
+                positionTokenAccount,
+                whirlpool: params.whirlpool,
+                rent: web3.SYSVAR_RENT_PUBKEY,
+                orcaWhirlpoolProgram: addresses_1.ORCA_WHIRLPOOL_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+                systemProgram: web3.SystemProgram.programId,
+            })
+                .instruction();
+            const orcaOpenPositionIxViaMain = yield anchor_1.Anchor.instance().iyfMain.methods
+                .iyfExtensionExecute(orcaOpenPositionIx.data)
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                iyfExtensionProgram: addresses_1.IYF_EXTENSION,
+            })
+                .remainingAccounts([
+                orcaOpenPositionIx.keys[4],
+                orcaOpenPositionIx.keys[5],
+                orcaOpenPositionIx.keys[6],
+                orcaOpenPositionIx.keys[7],
+                orcaOpenPositionIx.keys[8],
+                orcaOpenPositionIx.keys[9],
+                orcaOpenPositionIx.keys[10],
+                orcaOpenPositionIx.keys[11],
+                orcaOpenPositionIx.keys[12],
+            ])
+                .instruction();
+            const mainInstructions = [orcaOpenPositionIxViaMain];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Create new Orca Position",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates orca instruction that closes position
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    orcaClosePosition(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet, farm);
+            const position = (0, functions_2.generateOrcaPositionPDA)(params.positionMint);
+            const positionTokenAccount = (0, functions_2.generateAta)(userPda, params.positionMint);
+            const orcaOpenPositionIx = yield anchor_1.Anchor.instance().iyfExtension.methods
+                .orcaClosePosition()
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                positionMint: params.positionMint,
+                position,
+                positionTokenAccount,
+                orcaWhirlpoolProgram: addresses_1.ORCA_WHIRLPOOL_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+            })
+                .instruction();
+            const orcaOpenPositionIxViaMain = yield anchor_1.Anchor.instance().iyfMain.methods
+                .iyfExtensionExecute(orcaOpenPositionIx.data)
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                iyfExtensionProgram: addresses_1.IYF_EXTENSION,
+            })
+                .remainingAccounts([
+                orcaOpenPositionIx.keys[4],
+                orcaOpenPositionIx.keys[5],
+                orcaOpenPositionIx.keys[6],
+                orcaOpenPositionIx.keys[7],
+                orcaOpenPositionIx.keys[8],
+                orcaOpenPositionIx.keys[9],
+            ])
+                .instruction();
+            const mainInstructions = [orcaOpenPositionIxViaMain];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: "Close Orca Position",
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates orca instruction that deposits to a position
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    orcaDeposit(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet, farm);
+            const position = (0, functions_2.generateOrcaPositionPDA)(params.positionMint);
+            const positionTokenAccount = (0, functions_2.generateAta)(userPda, params.positionMint);
+            const positionData = yield anchor_1.Anchor.instance().whirlpoolCtx.fetcher.getPosition(position);
+            if (positionData === null) {
+                throw new Error(`Position: ${position} does not exist or already closed. Position mint: ${params.positionMint}`);
+            }
+            const whirlpool = positionData.whirlpool;
+            const whirlpoolData = yield anchor_1.Anchor.instance().whirlpoolCtx.fetcher.getPool(whirlpool);
+            const mintA = whirlpoolData.tokenMintA;
+            const mintB = whirlpoolData.tokenMintB;
+            const tokenSeeds = [
+                { owner: params.userWallet, mint: mintA },
+                { owner: params.userWallet, mint: mintB },
+            ];
+            const resultMap = yield (0, functions_2.tokenAccountExists)(connection, tokenSeeds);
+            resultMap.map((result, index) => {
+                const tokenKey = result.tokenKey;
+                const token = tokenSeeds[index];
+                if (!result.exists) {
+                    throw new Error(`Token: ${tokenKey} owned by ${token.owner} does not exist. Mint: ${token.mint}`);
+                }
+            });
+            const tokenOwnerAccountA = (0, functions_2.generateAta)(userPda, mintA);
+            const tokenOwnerAccountB = (0, functions_2.generateAta)(userPda, mintB);
+            const { publicKey: tickArrayLower } = whirlpools_sdk_1.PDAUtil.getTickArrayFromTickIndex(positionData.tickLowerIndex, whirlpoolData.tickSpacing, whirlpool, addresses_1.ORCA_WHIRLPOOL_PROGRAM);
+            const { publicKey: tickArrayUpper } = whirlpools_sdk_1.PDAUtil.getTickArrayFromTickIndex(positionData.tickUpperIndex, whirlpoolData.tickSpacing, whirlpool, addresses_1.ORCA_WHIRLPOOL_PROGRAM);
+            const ownerFeeA = (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, mintA);
+            const ownerFeeB = (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, mintB);
+            const depositIx = yield (0, hawksight_1.depositMultipleToken)({
+                payer: params.userWallet,
+                deposit: [
+                    {
+                        mint: mintA,
+                        amount: params.totalXAmount,
+                    },
+                    {
+                        mint: mintB,
+                        amount: params.totalYAmount,
+                    },
+                ]
+            });
+            const orcaOpenPositionIx = yield anchor_1.Anchor.instance().iyfExtension.methods
+                .orcaDeposit()
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                positionMint: params.positionMint,
+                whirlpool,
+                position,
+                positionTokenAccount,
+                tokenOwnerAccountA,
+                tokenOwnerAccountB,
+                tokenVaultA: whirlpoolData.tokenVaultA,
+                tokenVaultB: whirlpoolData.tokenVaultB,
+                tickArrayLower,
+                tickArrayUpper,
+                ownerFeeA,
+                ownerFeeB,
+                orcaWhirlpoolProgram: addresses_1.ORCA_WHIRLPOOL_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+            })
+                .instruction();
+            const orcaOpenPositionIxViaMain = yield anchor_1.Anchor.instance().iyfMain.methods
+                .iyfExtensionExecute(orcaOpenPositionIx.data)
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                iyfExtensionProgram: addresses_1.IYF_EXTENSION,
+            })
+                .remainingAccounts([
+                orcaOpenPositionIx.keys[4],
+                orcaOpenPositionIx.keys[5],
+                orcaOpenPositionIx.keys[6],
+                orcaOpenPositionIx.keys[7],
+                orcaOpenPositionIx.keys[8],
+                orcaOpenPositionIx.keys[9],
+                orcaOpenPositionIx.keys[10],
+                orcaOpenPositionIx.keys[11],
+                orcaOpenPositionIx.keys[12],
+                orcaOpenPositionIx.keys[13],
+                orcaOpenPositionIx.keys[14],
+                orcaOpenPositionIx.keys[15],
+                orcaOpenPositionIx.keys[16],
+                orcaOpenPositionIx.keys[17],
+                orcaOpenPositionIx.keys[18],
+            ])
+                .instruction();
+            const clearRemainingTokensIxs = yield (0, hawksight_1.withdrawMultipleToken)({
+                payer: params.userWallet,
+                withdraw: [
+                    { mint: mintA },
+                    { mint: mintB },
+                ],
+            });
+            const mainInstructions = [depositIx, orcaOpenPositionIxViaMain, clearRemainingTokensIxs];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: `Deposit to Orca Position: ${position}`,
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates orca instruction that withdraws from a position
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    orcaWithdraw(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet, farm);
+            const position = (0, functions_2.generateOrcaPositionPDA)(params.positionMint);
+            const positionTokenAccount = (0, functions_2.generateAta)(userPda, params.positionMint);
+            const positionData = yield anchor_1.Anchor.instance().whirlpoolCtx.fetcher.getPosition(position);
+            if (positionData === null) {
+                throw new Error(`Position: ${position} does not exist or already closed. Position mint: ${params.positionMint}`);
+            }
+            const whirlpool = positionData.whirlpool;
+            const whirlpoolData = yield anchor_1.Anchor.instance().whirlpoolCtx.fetcher.getPool(whirlpool);
+            const mintA = whirlpoolData.tokenMintA;
+            const mintB = whirlpoolData.tokenMintB;
+            const tokenOwnerAccountA = (0, functions_2.generateAta)(userPda, mintA);
+            const tokenOwnerAccountB = (0, functions_2.generateAta)(userPda, mintB);
+            const { publicKey: tickArrayLower } = whirlpools_sdk_1.PDAUtil.getTickArrayFromTickIndex(positionData.tickLowerIndex, whirlpoolData.tickSpacing, whirlpool, addresses_1.ORCA_WHIRLPOOL_PROGRAM);
+            const { publicKey: tickArrayUpper } = whirlpools_sdk_1.PDAUtil.getTickArrayFromTickIndex(positionData.tickUpperIndex, whirlpoolData.tickSpacing, whirlpool, addresses_1.ORCA_WHIRLPOOL_PROGRAM);
+            const ownerFeeA = (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, mintA);
+            const ownerFeeB = (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, mintB);
+            const orcaOpenPositionIx = yield anchor_1.Anchor.instance().iyfExtension.methods
+                .orcaWithdraw(params.liquidityAmount)
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                positionMint: params.positionMint,
+                whirlpool,
+                position,
+                positionTokenAccount,
+                tokenOwnerAccountA,
+                tokenOwnerAccountB,
+                tokenVaultA: whirlpoolData.tokenVaultA,
+                tokenVaultB: whirlpoolData.tokenVaultB,
+                tickArrayLower,
+                tickArrayUpper,
+                ownerFeeA,
+                ownerFeeB,
+                orcaWhirlpoolProgram: addresses_1.ORCA_WHIRLPOOL_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+            })
+                .instruction();
+            const orcaOpenPositionIxViaMain = yield anchor_1.Anchor.instance().iyfMain.methods
+                .iyfExtensionExecute(orcaOpenPositionIx.data)
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                iyfExtensionProgram: addresses_1.IYF_EXTENSION,
+            })
+                .remainingAccounts([
+                orcaOpenPositionIx.keys[4],
+                orcaOpenPositionIx.keys[5],
+                orcaOpenPositionIx.keys[6],
+                orcaOpenPositionIx.keys[7],
+                orcaOpenPositionIx.keys[8],
+                orcaOpenPositionIx.keys[9],
+                orcaOpenPositionIx.keys[10],
+                orcaOpenPositionIx.keys[11],
+                orcaOpenPositionIx.keys[12],
+                orcaOpenPositionIx.keys[13],
+                orcaOpenPositionIx.keys[14],
+                orcaOpenPositionIx.keys[15],
+                orcaOpenPositionIx.keys[16],
+                orcaOpenPositionIx.keys[17],
+                orcaOpenPositionIx.keys[18],
+            ])
+                .instruction();
+            const withdrawFromPda = yield (0, hawksight_1.withdrawMultipleToken)({
+                payer: params.userWallet,
+                withdraw: [
+                    { mint: mintA },
+                    { mint: mintB },
+                ],
+            });
+            const mainInstructions = [orcaOpenPositionIxViaMain, withdrawFromPda];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: `Withdraw deposits from Orca Position: ${position}`,
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+    /**
+     * Creates orca instruction that claims fees and rewards
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse.
+     */
+    orcaClaimRewards(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ connection, params }) {
+            const farm = addresses_1.USDC_FARM;
+            const userPda = (0, functions_2.generateUserPda)(params.userWallet, farm);
+            const position = (0, functions_2.generateOrcaPositionPDA)(params.positionMint);
+            const positionTokenAccount = (0, functions_2.generateAta)(userPda, params.positionMint);
+            const positionData = yield anchor_1.Anchor.instance().whirlpoolCtx.fetcher.getPosition(position);
+            if (positionData === null) {
+                throw new Error(`Position: ${position} does not exist or already closed. Position mint: ${params.positionMint}`);
+            }
+            const whirlpool = positionData.whirlpool;
+            const whirlpoolData = yield anchor_1.Anchor.instance().whirlpoolCtx.fetcher.getPool(whirlpool);
+            const mintA = whirlpoolData.tokenMintA;
+            const mintB = whirlpoolData.tokenMintB;
+            const tokenOwnerAccountA = (0, functions_2.generateAta)(userPda, mintA);
+            const tokenOwnerAccountB = (0, functions_2.generateAta)(userPda, mintB);
+            const { publicKey: tickArrayLower } = whirlpools_sdk_1.PDAUtil.getTickArrayFromTickIndex(positionData.tickLowerIndex, whirlpoolData.tickSpacing, whirlpool, addresses_1.ORCA_WHIRLPOOL_PROGRAM);
+            const { publicKey: tickArrayUpper } = whirlpools_sdk_1.PDAUtil.getTickArrayFromTickIndex(positionData.tickUpperIndex, whirlpoolData.tickSpacing, whirlpool, addresses_1.ORCA_WHIRLPOOL_PROGRAM);
+            const ownerFeeA = (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, mintA);
+            const ownerFeeB = (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, mintB);
+            const remainingAccounts = [];
+            for (const rewardInfo of whirlpoolData.rewardInfos) {
+                if (rewardInfo.mint.toString() !== web3.SystemProgram.programId.toString()) {
+                    const rewardOwnerAccount = (0, functions_2.generateAta)(userPda, rewardInfo.mint);
+                    const rewardVault = rewardInfo.vault;
+                    const rewardFee = (0, functions_2.generateAta)(addresses_1.SITE_FEE_OWNER, rewardInfo.mint);
+                    remainingAccounts.push({ pubkey: rewardOwnerAccount, isSigner: false, isWritable: true });
+                    remainingAccounts.push({ pubkey: rewardVault, isSigner: false, isWritable: true });
+                    remainingAccounts.push({ pubkey: rewardFee, isSigner: false, isWritable: true });
+                }
+            }
+            whirlpoolData.rewardInfos[0].mint;
+            const orcaOpenPositionIx = yield anchor_1.Anchor.instance().iyfExtension.methods
+                .orcaClaimRewards()
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                whirlpool,
+                positionMint: params.positionMint,
+                position,
+                tickArrayLower,
+                tickArrayUpper,
+                positionTokenAccount,
+                tokenVaultA: whirlpoolData.tokenVaultA,
+                tokenVaultB: whirlpoolData.tokenVaultB,
+                tokenOwnerAccountA,
+                tokenOwnerAccountB,
+                ownerFeeA,
+                ownerFeeB,
+                orcaWhirlpoolProgram: addresses_1.ORCA_WHIRLPOOL_PROGRAM,
+                tokenProgram: addresses_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: addresses_1.ASSOCIATED_TOKEN_PROGRAM,
+            })
+                .remainingAccounts(remainingAccounts)
+                .instruction();
+            const orcaOpenPositionIxViaMain = yield anchor_1.Anchor.instance().iyfMain.methods
+                .iyfExtensionExecute(orcaOpenPositionIx.data)
+                .accounts({
+                farm,
+                userPda,
+                authority: params.userWallet,
+                iyfProgram: addresses_1.IYF_MAIN,
+                iyfExtensionProgram: addresses_1.IYF_EXTENSION,
+            })
+                .remainingAccounts([
+                orcaOpenPositionIx.keys[4],
+                orcaOpenPositionIx.keys[5],
+                orcaOpenPositionIx.keys[6],
+                orcaOpenPositionIx.keys[7],
+                orcaOpenPositionIx.keys[8],
+                orcaOpenPositionIx.keys[9],
+                orcaOpenPositionIx.keys[10],
+                orcaOpenPositionIx.keys[11],
+                orcaOpenPositionIx.keys[12],
+                orcaOpenPositionIx.keys[13],
+                orcaOpenPositionIx.keys[14],
+                orcaOpenPositionIx.keys[15],
+                orcaOpenPositionIx.keys[16],
+                orcaOpenPositionIx.keys[17],
+                orcaOpenPositionIx.keys[18],
+            ])
+                .instruction();
+            const withdrawFromPda = yield (0, hawksight_1.withdrawMultipleToken)({
+                payer: params.userWallet,
+                withdraw: [
+                    { mint: mintA },
+                    { mint: mintB },
+                ],
+            });
+            const mainInstructions = [orcaOpenPositionIxViaMain, withdrawFromPda];
+            return (0, functions_2.createTransactionMeta)({
+                payer: params.userWallet,
+                description: `Claim rewards from Orca Position: ${position}`,
+                addressLookupTableAddresses: addresses_1.GLOBAL_ALT,
+                mainInstructions,
+            });
+        });
+    }
+}
+exports.Transactions = Transactions;
+exports.txgen = new Transactions();