@hawksightco/hawk-sdk 1.3.265 → 1.3.267

package/dist/classes/TxGenerator.js

@@ -0,0 +1,1957 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxGenerator = void 0;
+const web3 = __importStar(require("@solana/web3.js"));
+const types_1 = require("../types");
+const functions_1 = require("../functions");
+const anchor_1 = require("../anchor");
+const Transactions_1 = require("./Transactions");
+const bn_js_1 = __importDefault(require("bn.js"));
+const Logging_1 = require("./Logging");
+const SimpleIxGenerator_1 = require("./SimpleIxGenerator");
+const SimplePdaGenerator_1 = require("./SimplePdaGenerator");
+/**
+ * The `TxGenerator` class encapsulates methods to generate transactions with various trading operations
+ * on decentralized market making platforms like Meteora and Orca within the Solana ecosystem. It allows
+ * setting custom transaction priority and fees to manage transaction processing speed and cost.
+ */
+class TxGenerator {
+    /**
+     * Initializes a new instance of the TxGenerator class with a specified client.
+     *
+     * @param client An instance of Client used to interact with various APIs for transaction generation.
+     */
+    constructor(client, generalUtility) {
+        this.client = client;
+        this.generalUtility = generalUtility;
+        this.ix = new SimpleIxGenerator_1.SimpleIxGenerator();
+        this.pda = new SimplePdaGenerator_1.SimplePdaGenerator();
+    }
+    /**
+     * Claim token from STA. Fallbacks to ATA if STA is not yet initialized.
+     * @param connection A Solana web3 connection for interacting with the blockchain.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required.
+     * Note: Subject to refactor. Dirty implementation.
+     *
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse or TransactionMetadata.
+     */
+    claimTokenFromSta(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.claimTokenFromSta({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Claim token from ATA.
+     * @param connection A Solana web3 connection for interacting with the blockchain.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required.
+     *
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse or TransactionMetadata.
+     */
+    claimTokenFromAta(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.claimTokenFromAta({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Claim tokens from STA.
+     * @param connection A Solana web3 connection for interacting with the blockchain.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required.
+     * Note: Subject to refactor. Dirty implementation.
+     *
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse or TransactionMetadata.
+     */
+    claimTokensFromSta(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.claimTokensFromSta({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Creates instructions to initialize storage token accounts
+     *
+     * @param connection A Solana web3 connection for interacting with the blockchain.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params Parameters required.
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse or TransactionMetadata.
+     */
+    initializeStorageTokenAccounts(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.initializeStorageTokenAccounts({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    createLimitToken(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate instructions
+            const ixs = [];
+            // Create limit token account
+            ixs.push(yield this.ix.iyfMain.createLimitToken({
+                connection,
+                userWallet: params.userWallet,
+                payer: params.payer,
+                mint: params.mint,
+            }));
+            // Return executable instructions
+            return yield (0, functions_1.legacyTxMetadata)({
+                connection,
+                generalUtility: this.generalUtility,
+                payer: params.payer,
+                description: 'Create Limit Token',
+                ixs,
+            });
+        });
+    }
+    closeLimitToken(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Generate instructions
+            const ixs = [];
+            // Close limit token account
+            ixs.push(yield this.ix.iyfMain.closeLimitToken({
+                connection,
+                userWallet: params.userWallet,
+                mint: params.mint,
+            }));
+            // Return executable instructions
+            return yield (0, functions_1.legacyTxMetadata)({
+                connection,
+                generalUtility: this.generalUtility,
+                payer: params.userWallet,
+                description: 'Close Limit Token',
+                ixs,
+            });
+        });
+    }
+    /**
+     * Create executable instructions to initialize and deposit to limit token accounts.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse or TransactionMetadata.
+     */
+    depositToLta(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Instructions
+            const ixs = [];
+            // Idempotently create limit token accounts (generate instruction)
+            for (const deposit of params.deposit) {
+                ixs.push(yield this.ix.iyfMain.createLimitToken({
+                    connection,
+                    userWallet: params.userWallet,
+                    payer: params.userWallet,
+                    mint: deposit.mint,
+                }));
+            }
+            // Deposit to limit token accounts
+            ixs.push(yield this.ix.iyfMain.depositMultipleTokenV2({
+                connection,
+                payer: params.userWallet,
+                deposit: params.deposit,
+                pdaTokenType: types_1.TokenType.LTA,
+            }));
+            // Return executable instructions
+            return yield (0, functions_1.legacyTxMetadata)({
+                connection,
+                generalUtility: this.generalUtility,
+                payer: params.userWallet,
+                description: 'Deposit to limit token accounts',
+                ixs,
+            });
+        });
+    }
+    /**
+     * Creates executable instruction to withdraw from limit token accounts.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param params Parameters required
+     * @returns A ResponseWithStatus containing either TransactionMetadataResponse or TransactionMetadata.
+     */
+    withdrawFromLta(connection, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            // Instructions
+            const ixs = [];
+            // Withdraw from limit token accounts
+            ixs.push(yield this.ix.iyfMain.withdrawMultipleTokenV2({
+                connection,
+                payer: params.userWallet,
+                withdraw: params.withdraw,
+                pdaTokenType: types_1.TokenType.LTA,
+                hasAmount: params.hasAmount,
+            }));
+            // Return executable instructions
+            return yield (0, functions_1.legacyTxMetadata)({
+                connection,
+                generalUtility: this.generalUtility,
+                payer: params.userWallet,
+                description: 'Withdraw from limit token accounts',
+                ixs,
+            });
+        });
+    }
+    /**
+     * Creates meteora instruction that creates new position and deposit.
+     *
+     * @deprecated Use meteoraCreatePositionAndDepositToLargePosition instead
+     *
+     * @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 or TransactionMetadata.
+     */
+    meteoraCreatePositionAndDeposit(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraCreatePositionAndDeposit({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        pool: new web3.PublicKey(params.pool),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        totalXAmount: new bn_js_1.default(params.totalXAmount),
+                        totalYAmount: new bn_js_1.default(params.totalYAmount),
+                        binRange: {
+                            lowerRange: params.lowerBinRange,
+                            upperRange: params.upperBinRange,
+                        },
+                        slippage: params.slippage,
+                        distribution: params.distribution,
+                        skipInputTokenCheck: true,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    meteoraCreatePositionAndDepositPda(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraCreatePositionAndDepositPda({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        pool: new web3.PublicKey(params.pool),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        binRange: {
+                            lowerRange: params.binRange.lowerRange,
+                            upperRange: params.binRange.upperRange,
+                        },
+                        slippage: params.slippage,
+                        distribution: params.distribution,
+                        skipInputTokenCheck: true,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Creates meteora instruction that deposits to position.
+     *
+     * @deprecated Use meteoraDepositToLargePosition instead
+     *
+     * @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 or TransactionMetadata.
+     */
+    meteoraDeposit(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraDeposit({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        totalXAmount: new bn_js_1.default(params.totalXAmount),
+                        totalYAmount: new bn_js_1.default(params.totalYAmount),
+                        distribution: params.distribution,
+                        slippage: params.slippage,
+                        skipInputTokenCheck: params.skipInputTokenCheck,
+                        fastGeneration: params.fastGeneration
+                            ? Object.assign(Object.assign({}, params.fastGeneration), { pool: new web3.PublicKey(params.fastGeneration.pool) }) : undefined,
+                        pdaTokenType: (_a = params.pdaTokenType) !== null && _a !== void 0 ? _a : types_1.TokenType.ATA,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Creates meteora instruction withdraws from a position.
+     *
+     * @deprecated Use meteoraWithdrawLargerPosition instead
+     *
+     * @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 or TransactionMetadata.
+     */
+    meteoraWithdraw(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraWithdraw({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        amountBps: new bn_js_1.default(params.amountBps),
+                        shouldClaimAndClose: params.shouldClaimAndClose,
+                        fastGeneration: params.fastGeneration
+                            ? {
+                                pool: new web3.PublicKey(params.fastGeneration.pool),
+                                lowerBinId: params.fastGeneration.lowerBinId,
+                                upperBinId: params.fastGeneration.upperBinId,
+                            }
+                            : undefined,
+                        pdaTokenType: (_a = params.pdaTokenType) !== null && _a !== void 0 ? _a : types_1.TokenType.ATA,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    meteoraWithdrawPda(connection, payer, params, pdaTokenType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraWithdrawPda({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        amountBps: new bn_js_1.default(params.amountBps),
+                        shouldClaimAndClose: params.shouldClaimAndClose,
+                        fastGeneration: params.fastGeneration
+                            ? {
+                                pool: new web3.PublicKey(params.fastGeneration.pool),
+                                lowerBinId: params.fastGeneration.lowerBinId,
+                                upperBinId: params.fastGeneration.upperBinId,
+                            }
+                            : undefined,
+                        useAta: params.useAta,
+                        pdaTokenType: pdaTokenType !== null && pdaTokenType !== void 0 ? pdaTokenType : types_1.TokenType.ATA,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Withdraw liquidity from a large Meteora DLMM position (up to 1400 bins).
+     * For ≤149 bins: single tx. For ≥150 bins: multi-tx with chunked withdrawals.
+     */
+    meteoraWithdrawLargePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const results = yield Transactions_1.txgen.meteoraWithdrawLargePosition({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        amountBps: new bn_js_1.default(params.amountBps),
+                        shouldClaimAndClose: params.shouldClaimAndClose,
+                        fastGeneration: params.fastGeneration
+                            ? {
+                                pool: new web3.PublicKey(params.fastGeneration.pool),
+                                lowerBinId: params.fastGeneration.lowerBinId,
+                                upperBinId: params.fastGeneration.upperBinId,
+                            }
+                            : undefined,
+                        useAta: params.useAta,
+                        pdaTokenType: (_a = params.pdaTokenType) !== null && _a !== void 0 ? _a : types_1.TokenType.ATA,
+                    },
+                });
+                const txMetadatas = [];
+                for (const result of results) {
+                    const txMeta = yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result);
+                    txMetadatas.push(txMeta);
+                }
+                return {
+                    status: 200,
+                    data: txMetadatas,
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    meteoraClaim(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const startTime = new Date().getTime() / 1000;
+                (0, Logging_1.Log)('meteoraClaim: Benchmarking txgen.meteoraClaim');
+                const result = yield Transactions_1.txgen.meteoraClaim({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        fastGeneration: params.fastGeneration
+                            ? {
+                                pool: new web3.PublicKey(params.fastGeneration.pool),
+                            }
+                            : undefined,
+                        pdaTokenType: params.pdaTokenType,
+                    },
+                    fetch: undefined,
+                });
+                (0, Logging_1.Log)(`meteoraClaim: await txgen.meteoraClaim elapsed time: ${new Date().getTime() / 1000 - startTime}`);
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: `${e.message} at ${e.stack}`,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Claim fees and rewards from a large Meteora DLMM position (up to 1400 bins).
+     *
+     * For ≤149 bins, delegates to single-TX meteoraClaim.
+     * For ≥150 bins, chunks the bin range into ≤149-bin pieces, returning multiple TXs.
+     *
+     * @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 an array of TransactionMetadata.
+     */
+    meteoraClaimLargePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const results = yield Transactions_1.txgen.meteoraClaimLargePosition({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        fastGeneration: params.fastGeneration
+                            ? {
+                                pool: new web3.PublicKey(params.fastGeneration.pool),
+                            }
+                            : undefined,
+                        pdaTokenType: params.pdaTokenType,
+                    },
+                });
+                const txMetadatas = [];
+                for (const result of results) {
+                    const txMeta = yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result);
+                    txMetadatas.push(txMeta);
+                }
+                return {
+                    status: 200,
+                    data: txMetadatas,
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            stack: (_a = e.stack) === null || _a === void 0 ? void 0 : _a.split('\n'),
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    meteoraClaimAll(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            const startTime = new Date().getTime() / 1000;
+            (0, Logging_1.Log)('meteoraClaimAll: Benchmarking txgen.meteoraClaimAll');
+            const result = yield Transactions_1.txgen.meteoraClaimAll({
+                connection,
+                params,
+                fetch: undefined,
+            }, new web3.PublicKey(payer), this.generalUtility);
+            (0, Logging_1.Log)(`meteoraClaim: await txgen.meteoraClaimAll elapsed time: ${new Date().getTime() / 1000 - startTime}`);
+            return result;
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    meteoraClosePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const startTime = new Date().getTime() / 1000;
+                const result = yield Transactions_1.txgen.meteoraClosePosition({
+                    connection,
+                    params: {
+                        position: new web3.PublicKey(params.position),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Creates meteora instruction that initializes bin arrays (via hawkfi program -- main iyf)
+     *
+     * @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 or TransactionMetadata.
+     */
+    meteoraInitializeBinArrays(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraInitializeBinArrays({
+                    connection,
+                    params: {
+                        pool: new web3.PublicKey(params.pool),
+                        userWallet: new web3.PublicKey(params.userWallet),
+                        minBinId: params.minBinId,
+                        maxBinId: params.maxBinId,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    meteoraInitializeBinArrays2(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraInitializeBinArrays2({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    meteoraCreatePoolAndPosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraCreatePoolAndPosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Creates meteora instruction that initializes a large position.
+     * Supports up to 1400 bins, splitting across multiple transactions if needed.
+     *
+     * @param connection - Solana connection
+     * @param payer - Public key of the payer for transaction fees.
+     * @param params - Parameters required
+     * @returns A ResponseWithStatus containing an array of TransactionMetadata.
+     */
+    meteoraInitializeLargePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const results = yield Transactions_1.txgen.meteoraInitializeLargePosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                const txMetadatas = [];
+                for (const result of results) {
+                    const txMeta = yield (0, functions_1.createTxMetadataWithActions)(this.generalUtility, connection, payer, result);
+                    txMetadatas.push(txMeta);
+                }
+                return {
+                    status: 200,
+                    data: txMetadatas,
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Deposit liquidity to a large Meteora DLMM position.
+     * Generates a single rebalanceLiquidity instruction for the entire position range.
+     *
+     * Uses rebalance_liquidity to chunk the deposit into multiple transactions.
+     * Author note: Do not use yet. No infra support yet for automations.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params MeteoraDeposit parameters
+     * @returns A ResponseWithStatus containing an array of TransactionMetadata.
+     */
+    meteoraDepositToLargePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const results = yield Transactions_1.txgen.meteoraDepositToLargePosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                const txMetadatas = [];
+                for (const result of results) {
+                    const txMeta = yield (0, functions_1.createTxMetadataWithActions)(this.generalUtility, connection, payer, result);
+                    txMetadatas.push(txMeta);
+                }
+                return {
+                    status: 200,
+                    data: txMetadatas,
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Create a position and deposit liquidity for any bin count.
+     * For ≤149 bins: single tx. For ≥150 bins: multi-tx with init + deposit.
+     */
+    meteoraCreatePositionAndDepositToLargePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const results = yield Transactions_1.txgen.meteoraCreatePositionAndDepositToLargePosition({
+                    connection,
+                    params,
+                });
+                const txMetadatas = [];
+                for (const result of results) {
+                    const txMeta = yield (0, functions_1.createTxMetadataWithActions)(this.generalUtility, connection, payer, result);
+                    txMetadatas.push(txMeta);
+                }
+                return {
+                    status: 200,
+                    data: txMetadatas,
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    meteoraDepositHybridToLargePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const results = yield Transactions_1.txgen.meteoraDepositHybridToLargePosition({
+                    connection,
+                    params,
+                });
+                const txMetadatas = [];
+                for (const result of results) {
+                    const txMeta = yield (0, functions_1.createTxMetadataWithActions)(this.generalUtility, connection, payer, result);
+                    txMetadatas.push(txMeta);
+                }
+                return {
+                    status: 200,
+                    data: txMetadatas,
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    meteoraCreatePositionAndDepositHybridToLargePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const results = yield Transactions_1.txgen.meteoraCreatePositionAndDepositHybridToLargePosition({
+                    connection,
+                    params,
+                });
+                const txMetadatas = [];
+                for (const result of results) {
+                    const txMeta = yield (0, functions_1.createTxMetadataWithActions)(this.generalUtility, connection, payer, result);
+                    txMetadatas.push(txMeta);
+                }
+                return {
+                    status: 200,
+                    data: txMetadatas,
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Deposit liquidity to a Meteora DLMM position (up to 70 bins) with optional position initialization.
+     *
+     * This method combines:
+     * - Initialize bin arrays (idempotent)
+     * - Optionally initialize position (if initializePosition is true)
+     * - Add liquidity using addLiquidityByStrategy
+     *
+     * Designed for automation compatibility - all operations in a single transaction.
+     * Note: Number of bins limited to 70 due to Meteora InitializePosition width constraint.
+     *
+     * @param connection The Solana web3 connection object for blockchain interactions.
+     * @param payer The public key of the payer for transaction fees.
+     * @param params MeteoraDepositLargerPosition parameters
+     * @returns A ResponseWithStatus containing TransactionMetadata.
+     */
+    meteoraDepositLargerPosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.meteoraDepositLargerPosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadataWithActions)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaOpenPosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaOpenPosition({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        positionMint: params.positionMint,
+                        whirlpool: params.whirlpool,
+                        tickLowerIndex: params.tickLowerIndex,
+                        tickUpperIndex: params.tickUpperIndex,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaClosePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaClosePosition({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        position: params.position,
+                        farm: params.farm,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaDeposit(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaDeposit({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        mintOrPosition: params.mintOrPosition,
+                        totalXAmount: params.totalXAmount,
+                        totalYAmount: params.totalYAmount,
+                        newPosition: params.newPosition,
+                        is2022Position: params.is2022Position,
+                        farm: params.farm,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaDepositPda(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaDepositPda({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        mintOrPosition: params.mintOrPosition,
+                        totalXAmount: params.totalXAmount,
+                        totalYAmount: params.totalYAmount,
+                        newPosition: params.newPosition,
+                        farm: params.farm,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaWithdraw(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaWithdraw({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        position: params.position,
+                        percentage: params.percentage,
+                        is2022Position: params.is2022Position,
+                        farm: params.farm,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaWithdrawPda(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaWithdrawPda({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        position: params.position,
+                        percentage: params.percentage,
+                        farm: params.farm,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaSweepDust(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaSweepDust({
+                    connection,
+                    params: params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * 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 or TransactionMetadata.
+     */
+    orcaClaimRewards(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.orcaClaimRewards({
+                    connection,
+                    params: {
+                        userWallet: params.userWallet,
+                        position: params.position,
+                        is2022Position: params.is2022Position,
+                        farm: params.farm,
+                    },
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    raydiumOpenPosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.raydiumOpenPosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    raydiumClosePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.raydiumClosePosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    raydiumWithdrawAndClosePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.raydiumWithdrawAndClosePosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    raydiumIncreaseLiquidity(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.raydiumIncreaseLiquidity({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    raydiumDecreaseLiquidity(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Initialize anchor
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.raydiumDecreaseLiquidity({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+    saberWithdrawAndClosePosition(connection, payer, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            anchor_1.Anchor.initialize(connection);
+            try {
+                const result = yield Transactions_1.txgen.saberWithdrawAndClosePosition({
+                    connection,
+                    params,
+                    fetch: undefined,
+                });
+                return {
+                    status: 200,
+                    data: yield (0, functions_1.createTxMetadata)(this.generalUtility, connection, payer, result),
+                };
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return {
+                        status: 400,
+                        data: {
+                            code: 'custom',
+                            message: e.message,
+                            path: [],
+                        },
+                    };
+                }
+                return {
+                    status: 400,
+                    data: {
+                        code: 'custom',
+                        message: e,
+                        path: [],
+                    },
+                };
+            }
+        });
+    }
+}
+exports.TxGenerator = TxGenerator;