@hawksightco/hawk-sdk 1.3.265 → 1.3.266

package/dist/classes/MultiTransaction.js

@@ -0,0 +1,296 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTransaction = void 0;
+const web3 = __importStar(require("@solana/web3.js"));
+const functions_1 = require("../functions");
+const Transaction2_1 = require("./Transaction2");
+const functions_2 = require("../functions");
+class MultiTransaction {
+    /**
+     * Get transaction count
+     */
+    get count() {
+        return this.txs.length;
+    }
+    constructor(description, generalUtility, latestBlockhash, payerKey) {
+        this.description = description;
+        this.generalUtility = generalUtility;
+        this.latestBlockhash = latestBlockhash;
+        this.payerKey = payerKey;
+        this.txs = [];
+        this.nonceAdvanceIxCount = 0;
+        this.nonceAccounts = [];
+    }
+    push(alts, ixs) {
+        this.txs.push([alts, ixs]);
+        const currentIndex = this.txs.length - 1;
+        const result = this.getNonceIndex(currentIndex);
+        this.nonceAdvanceIxCount += result > -1 ? 1 : 0;
+    }
+    getPayerOwnedNonceAccounts(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.nonceAccounts = yield (0, functions_1.findNonceOwnedBy)(connection, this.payerKey, this.nonceAdvanceIxCount);
+        });
+    }
+    /**
+     * Whether there were enough nonce accounts already initialized on-chain
+     *
+     * @param connection
+     * @returns
+     */
+    hasAvailableNonce(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.nonceAdvanceIxCount === 0) {
+                return true;
+            }
+            else {
+                (0, functions_1.benchmark)({ name: `hasAvailableNonce`, msg: `await this.getPayerOwnedNonceAccounts(connection)` });
+                yield this.getPayerOwnedNonceAccounts(connection);
+                (0, functions_1.benchmark)({ name: `hasAvailableNonce`, msg: `await this.getPayerOwnedNonceAccounts(connection)`, end: true });
+                return this.nonceAccounts.length >= this.nonceAdvanceIxCount;
+            }
+        });
+    }
+    /**
+     * Generate a transaction that creates durable nonce account
+     *
+     * @param connection
+     * @returns
+     */
+    createDurableNonceAccount(connection, signerFn, sendSigned, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const count = this.nonceAdvanceIxCount - this.nonceAccounts.length;
+            const instructions = [];
+            (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await connection.getMinimumBalanceForRentExemption(web3.NONCE_ACCOUNT_LENGTH)` });
+            const rentExempt = yield connection.getMinimumBalanceForRentExemption(web3.NONCE_ACCOUNT_LENGTH);
+            (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await connection.getMinimumBalanceForRentExemption(web3.NONCE_ACCOUNT_LENGTH)`, end: true });
+            for (let i = 0; i < count; i++) {
+                const noncePubkey = yield (0, functions_1.generateNonceAddressFromIndex)(this.payerKey, i);
+                instructions.push(...[
+                    web3.SystemProgram.createAccountWithSeed({
+                        fromPubkey: this.payerKey,
+                        newAccountPubkey: noncePubkey,
+                        basePubkey: this.payerKey,
+                        seed: `hs-nonce-${i}`,
+                        lamports: rentExempt,
+                        space: web3.NONCE_ACCOUNT_LENGTH,
+                        programId: web3.SystemProgram.programId,
+                    }),
+                    web3.SystemProgram.nonceInitialize({
+                        noncePubkey,
+                        authorizedPubkey: this.payerKey,
+                    })
+                ]);
+            }
+            (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await connection.getLatestBlockhash` });
+            const { blockhash: recentBlockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash();
+            (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await connection.getLatestBlockhash`, end: true });
+            const tx = new web3.VersionedTransaction(new web3.TransactionMessage({
+                payerKey: this.payerKey,
+                instructions,
+                recentBlockhash,
+            }).compileToLegacyMessage());
+            const signedTx = yield (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const signedTx = yield signerFn(tx);
+                    opts.userSignedFn();
+                    return signedTx;
+                }
+                catch (_a) {
+                    opts.userDidntSignedFn();
+                    return false;
+                }
+            }))();
+            if (signedTx === false) {
+                return false;
+            }
+            const status = yield (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await sendSigned(signedTx, lastValidBlockHeight)` });
+                    const txid = yield sendSigned(signedTx, lastValidBlockHeight);
+                    (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await sendSigned(signedTx, lastValidBlockHeight)`, end: true });
+                    opts.successFn(txid);
+                    (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await this.hasAvailableNonce(connection)` });
+                    const status = yield this.hasAvailableNonce(connection);
+                    (0, functions_1.benchmark)({ name: `createDurableNonceAccount`, msg: `await this.hasAvailableNonce(connection)`, end: true });
+                    if (status === false) {
+                        opts.failedFn(`Nonce account has been created, but we cannot fetch the account yet on blockchain. Please refresh your browser. Transaction ID: ${txid}`, false);
+                    }
+                    return true;
+                }
+                catch (_a) {
+                    opts.failedFn(`Failed to create nonce account.`, true);
+                    return false;
+                }
+            }))();
+            return status;
+        });
+    }
+    signAndSend(connection, priorityLevel, priorityFeeMaxCap, signMultipleTransactions, sendSignedTx, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, functions_1.benchmark)({ name: `signAndSend`, msg: `await connection.getLatestBlockhash()` });
+            const latestBlockhash = yield connection.getLatestBlockhash();
+            (0, functions_1.benchmark)({ name: `signAndSend`, msg: `await connection.getLatestBlockhash()`, end: true });
+            const txs = yield (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const txs = yield signMultipleTransactions(yield this.generateTransasctions(connection, priorityLevel, priorityFeeMaxCap, latestBlockhash));
+                    opts.userSignedFn();
+                    return txs;
+                }
+                catch (_a) {
+                    opts.userDidntSignedFn();
+                    return false;
+                }
+            }))();
+            // If false, then return
+            if (!!!txs)
+                return;
+            // Otherwise continue
+            const promises = [];
+            let i = -1;
+            for (const tx of txs) {
+                i++;
+                const _tx = this.transactionInstance(this.txs[i][0], this.txs[i][1], latestBlockhash);
+                if (!_tx.hasNonceAdvanceIx) {
+                    promises.push(sendSignedTx(tx, latestBlockhash.lastValidBlockHeight));
+                }
+                else {
+                    // Wait for transactions without nonce to succeed first.
+                    try {
+                        const txids = yield Promise.all(promises);
+                        opts.successFn(txids);
+                        promises.splice(0, promises.length);
+                        const latestBlockhash = yield connection.getLatestBlockhash();
+                        yield sendSignedTx(tx, latestBlockhash.lastValidBlockHeight);
+                    }
+                    catch (_a) {
+                        opts.failedFn(`Transaction #${i} failed.`, true);
+                        return;
+                    }
+                }
+            }
+            const txids = yield Promise.all(promises);
+            opts.successFn(txids);
+        });
+    }
+    generateTransasctions(connection, priorityLevel, priorityFeeMaxCap, latestBlockhash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, functions_1.benchmark)({ name: `generateTransasctions`, msg: `entire function` });
+            const estimate = yield this.getFeeEstimate(priorityLevel);
+            const txs = [];
+            let nonceIndex = 0;
+            for (const tuple of this.txs) {
+                const tx = this.transactionInstance(tuple[0], tuple[1], latestBlockhash);
+                // const simulation = await tx.simulateTransaction(connection);
+                // const computeUnitLimit = Math.round(simulation.unitsConsumed * 1.15) + 100_000; // + 15% + 100,000 additional CU to prevent exceeding CU.
+                tx.feeEstimate = estimate;
+                // await tx.addPriorityFeeIx(connection, computeUnitLimit, false, priorityLevel, priorityFeeMaxCap);
+                if (tx.hasNonceAdvanceIx) {
+                    const nonceAccount = this.nonceAccounts[nonceIndex++];
+                    const blockhash = nonceAccount.data.nonce;
+                    const lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+                    tx.setBlockhash(blockhash, lastValidBlockHeight);
+                }
+                else {
+                    const { blockhash, lastValidBlockHeight } = latestBlockhash;
+                    tx.setBlockhash(blockhash, lastValidBlockHeight);
+                }
+                txs.push(tx.versionedTransaction);
+            }
+            (0, functions_1.benchmark)({ name: `generateTransasctions`, msg: ``, end: true });
+            return txs;
+        });
+    }
+    transactionInstance(alts, ixs, latestBlockhash) {
+        return Transaction2_1.Transaction2.new(this.payerKey, alts, this.generalUtility, ixs, latestBlockhash);
+    }
+    /**
+     * Generate nonde advance instruction (dummy instruction)
+     */
+    nonceAdvanceIx(noncePubkey) {
+        // Generate dummy nonce ix
+        return web3.SystemProgram.nonceAdvance({
+            /** Nonce account */
+            noncePubkey,
+            /** Public key of the nonce authority */
+            authorizedPubkey: this.payerKey,
+        });
+    }
+    /**
+     * Get nonce index
+     *
+     * @returns
+     */
+    getNonceIndex(index) {
+        const referenceIx = this.nonceAdvanceIx(web3.Keypair.generate().publicKey);
+        const i = this.txs[index][1].findIndex(ix => {
+            const isNonceAdvanceIx = ix.data.toString("base64") == referenceIx.data.toString("base64") &&
+                ix.programId.toString() == referenceIx.programId.toString();
+            return isNonceAdvanceIx;
+        });
+        return i;
+    }
+    /**
+     * Get fee estimate
+     *
+     * @param priorityLevel
+     * @returns
+     */
+    getFeeEstimate(priorityLevel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.getFeeEstimate2(priorityLevel, Transaction2_1.Transaction2.new(this.payerKey, this.txs[0][0], this.generalUtility, this.txs[0][1]).txMetadataResponse);
+        });
+    }
+    getFeeEstimate2(priorityLevel, txMetadataResponse) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get fee estimate by simulating the transaction
+            (0, functions_1.benchmark)({ name: `getFeeEstimate2`, msg: `Starting getFeeEstimate function` });
+            let estimate = yield (0, functions_2.getFeeEstimate)(this.generalUtility, priorityLevel, txMetadataResponse);
+            (0, functions_1.benchmark)({ name: `getFeeEstimate2`, msg: `getFeeEstimate function`, end: true });
+            return estimate;
+        });
+    }
+}
+exports.MultiTransaction = MultiTransaction;

package/dist/classes/RaydiumSDK.d.ts

@@ -0,0 +1,67 @@
+import * as web3 from "@solana/web3.js";
+import { Raydium, ApiV3PoolInfoConcentratedItem } from "@raydium-io/raydium-sdk-v2";
+import BN from "bn.js";
+/**
+ * Raydium SDK class
+ *
+ * This class is used to load the Raydium SDK and get the instance
+ */
+export declare class RaydiumSDK {
+    /**
+     * The instance of the Raydium SDK
+     */
+    private static _instance;
+    /**
+     * The Raydium SDK instance
+     */
+    sdk: Raydium;
+    /**
+     * Constructor
+     *
+     * @param sdk The Raydium SDK instance
+     */
+    private constructor();
+    /**
+     * Get the instance of the Raydium SDK
+     *
+     * @returns The Raydium SDK instance
+     */
+    static instance(): RaydiumSDK;
+    /**
+     * Load the Raydium SDK
+     *
+     * @param connection The Solana connection
+     */
+    static load(connection: web3.Connection): Promise<void>;
+    /**
+     * Get pool info from Raydium API v3
+     *
+     * @param poolId The pool id to get the pool info from.
+     * @returns The pool info.
+     */
+    getPoolInfoFromRpc(poolId: web3.PublicKey): Promise<ApiV3PoolInfoConcentratedItem>;
+    getLiquidityFromAmounts(connection: web3.Connection, poolId: web3.PublicKey, amountA: BN, amountB: BN, tickLower: number, tickUpper: number, slippage: number, add: boolean): Promise<{
+        liquidity: BN;
+        amount0Max: BN;
+        amount1Max: BN;
+    }>;
+    getAmountsFromLiquidity(connection: web3.Connection, poolId: web3.PublicKey, liquidity: BN, tickLower: number, tickUpper: number, slippage: number, add: boolean): Promise<{
+        amount0Min: BN;
+        amount1Min: BN;
+        amountA: import("@raydium-io/raydium-sdk-v2").GetTransferAmountFee;
+        amountB: import("@raydium-io/raydium-sdk-v2").GetTransferAmountFee;
+    }>;
+}
+/**
+ * Load the Raydium SDK
+ *
+ * @param connection The Solana connection
+ */
+export declare function load(connection: web3.Connection): Promise<void>;
+/**
+ * Get the Raydium SDK instance
+ *
+ * @returns The Raydium SDK instance
+ */
+export declare function raydium(): Raydium;
+//# sourceMappingURL=RaydiumSDK.d.ts.map

package/dist/classes/RaydiumSDK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RaydiumSDK.d.ts","sourceRoot":"","sources":["../../src/classes/RaydiumSDK.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,EACL,OAAO,EACP,6BAA6B,EAG9B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,MAAM,OAAO,CAAC;AAEvB;;;;GAIG;AACH,qBAAa,UAAU;IAErB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS,CAAa;IAErC;;OAEG;IACI,GAAG,EAAE,OAAO,CAAC;IAEpB;;;;OAIG;IACH,OAAO;IAIP;;;;OAIG;IACH,MAAM,CAAC,QAAQ,IAAI,UAAU;IAI7B;;;;OAIG;WACU,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU;IAiB7C;;;;;OAKG;IACG,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,6BAA6B,CAAC;IAmDlF,uBAAuB,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO;;;;;IAsD3K,uBAAuB,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO;;;;;;CAkDvK;AAED;;;;GAIG;AACH,wBAAsB,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,iBAErD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,YAEtB"}

package/dist/classes/RaydiumSDK.js

@@ -0,0 +1,206 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaydiumSDK = void 0;
+exports.load = load;
+exports.raydium = raydium;
+const raydium_sdk_v2_1 = require("@raydium-io/raydium-sdk-v2");
+const functions_1 = require("../functions");
+/**
+ * Raydium SDK class
+ *
+ * This class is used to load the Raydium SDK and get the instance
+ */
+class RaydiumSDK {
+    /**
+     * Constructor
+     *
+     * @param sdk The Raydium SDK instance
+     */
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    /**
+     * Get the instance of the Raydium SDK
+     *
+     * @returns The Raydium SDK instance
+     */
+    static instance() {
+        return this._instance;
+    }
+    /**
+     * Load the Raydium SDK
+     *
+     * @param connection The Solana connection
+     */
+    static load(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Load the SDK only once
+            if (RaydiumSDK._instance) {
+                return;
+            }
+            // Load the SDK
+            const sdk = yield raydium_sdk_v2_1.Raydium.load({
+                connection,
+                disableLoadToken: false,
+            });
+            // Set the instance
+            RaydiumSDK._instance = new RaydiumSDK(sdk);
+        });
+    }
+    /**
+     * Get pool info from Raydium API v3
+     *
+     * @param poolId The pool id to get the pool info from.
+     * @returns The pool info.
+     */
+    getPoolInfoFromRpc(poolId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _poolInfo = yield fetch(`https://api-v3.raydium.io/pools/info/ids?ids=${poolId.toString()}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            const data = yield _poolInfo.json();
+            const poolInfo = data.data[0];
+            const result = {
+                type: "Concentrated",
+                programId: poolInfo.programId,
+                id: poolInfo.id,
+                mintA: poolInfo.mintA,
+                mintB: poolInfo.mintB,
+                rewardDefaultInfos: poolInfo.rewardDefaultInfos,
+                rewardDefaultPoolInfos: poolInfo.rewardDefaultPoolInfos,
+                price: poolInfo.price,
+                mintAmountA: poolInfo.mintAmountA,
+                mintAmountB: poolInfo.mintAmountB,
+                feeRate: poolInfo.feeRate,
+                openTime: poolInfo.openTime,
+                tvl: poolInfo.tvl,
+                day: poolInfo.day,
+                week: poolInfo.week,
+                month: poolInfo.month,
+                pooltype: poolInfo.pooltype,
+                farmUpcomingCount: poolInfo.farmUpcomingCount,
+                farmOngoingCount: poolInfo.farmOngoingCount,
+                farmFinishedCount: poolInfo.farmFinishedCount,
+                burnPercent: poolInfo.burnPercent,
+                config: {
+                    id: poolInfo.config.id,
+                    index: poolInfo.config.index,
+                    protocolFeeRate: poolInfo.config.protocolFeeRate,
+                    tradeFeeRate: poolInfo.config.tradeFeeRate,
+                    tickSpacing: poolInfo.config.tickSpacing,
+                    fundFeeRate: poolInfo.config.fundFeeRate,
+                    description: poolInfo.config.description,
+                    defaultRange: poolInfo.config.defaultRange,
+                    defaultRangePoint: poolInfo.config.defaultRangePoint,
+                }
+            };
+            return result;
+        });
+    }
+    getLiquidityFromAmounts(connection, poolId, amountA, amountB, tickLower, tickUpper, slippage, add) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Load the Raydium SDK
+            yield RaydiumSDK.load(connection);
+            // Benchmark the getPoolInfoFromRpc function
+            (0, functions_1.benchmark)({ name: `getLiquidityFromAmounts`, msg: `getPoolInfoFromRpc` });
+            // Get the pool info
+            let poolInfo = yield RaydiumSDK.instance().getPoolInfoFromRpc(poolId);
+            // Benchmark the getPoolInfoFromRpc function (end)
+            (0, functions_1.benchmark)({ name: `getLiquidityFromAmounts`, msg: `getPoolInfoFromRpc`, end: true });
+            // Benchmark the getEpochInfo function
+            (0, functions_1.benchmark)({ name: `getLiquidityFromAmounts`, msg: `getEpochInfo` });
+            // Get the epoch info
+            let epochInfo = yield connection.getEpochInfo();
+            // Benchmark the getEpochInfo function (end)
+            (0, functions_1.benchmark)({ name: `getLiquidityFromAmounts`, msg: `getEpochInfo`, end: true });
+            // Benchmark the getLiquidityFromAmounts function
+            (0, functions_1.benchmark)({ name: `getLiquidityFromAmounts`, msg: `getLiquidityFromAmounts` });
+            const { liquidity, amountSlippageA, amountSlippageB, amountA: _amountA, amountB: _amountB, } = (0, raydium_sdk_v2_1.getLiquidityFromAmounts)({
+                poolInfo,
+                tickLower,
+                tickUpper,
+                amountA,
+                amountB,
+                slippage,
+                add: true,
+                epochInfo,
+                amountHasFee: false,
+            });
+            // Benchmark the getLiquidityFromAmounts function (end)
+            (0, functions_1.benchmark)({ name: `getLiquidityFromAmounts`, msg: `getLiquidityFromAmounts`, end: true });
+            return {
+                liquidity,
+                amount0Max: amountSlippageA.amount,
+                amount1Max: amountSlippageB.amount,
+            };
+        });
+    }
+    getAmountsFromLiquidity(connection, poolId, liquidity, tickLower, tickUpper, slippage, add) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Load the Raydium SDK
+            yield RaydiumSDK.load(connection);
+            // Benchmark the getPoolInfoFromRpc function
+            (0, functions_1.benchmark)({ name: `getAmountsFromLiquidity`, msg: `getPoolInfoFromRpc` });
+            // Get the pool info
+            let poolInfo = yield RaydiumSDK.instance().getPoolInfoFromRpc(poolId);
+            (0, functions_1.benchmark)({ name: `getAmountsFromLiquidity`, msg: `getPoolInfoFromRpc`, end: true });
+            // Benchmark the getEpochInfo function
+            (0, functions_1.benchmark)({ name: `getAmountsFromLiquidity`, msg: `getEpochInfo` });
+            // Get the epoch info
+            let epochInfo = yield connection.getEpochInfo();
+            // Benchmark the getEpochInfo function (end)
+            (0, functions_1.benchmark)({ name: `getAmountsFromLiquidity`, msg: `getEpochInfo`, end: true });
+            // Benchmark the getAmountsFromLiquidity function
+            (0, functions_1.benchmark)({ name: `getAmountsFromLiquidity`, msg: `getAmountsFromLiquidity` });
+            // Get the amounts from liquidity
+            const { amountSlippageA, amountSlippageB, amountA, amountB, } = yield raydium_sdk_v2_1.PoolUtils.getAmountsFromLiquidity({
+                epochInfo,
+                poolInfo,
+                tickLower,
+                tickUpper,
+                liquidity,
+                slippage,
+                add,
+            });
+            // Benchmark the getAmountsFromLiquidity function (end)
+            (0, functions_1.benchmark)({ name: `getAmountsFromLiquidity`, msg: `getAmountsFromLiquidity`, end: true });
+            return {
+                amount0Min: amountSlippageA.amount,
+                amount1Min: amountSlippageB.amount,
+                amountA,
+                amountB,
+            };
+        });
+    }
+}
+exports.RaydiumSDK = RaydiumSDK;
+/**
+ * Load the Raydium SDK
+ *
+ * @param connection The Solana connection
+ */
+function load(connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield RaydiumSDK.load(connection);
+    });
+}
+/**
+ * Get the Raydium SDK instance
+ *
+ * @returns The Raydium SDK instance
+ */
+function raydium() {
+    return RaydiumSDK.instance().sdk;
+}

package/dist/classes/Search.d.ts

@@ -0,0 +1,100 @@
+import { Token, LoadFromPersistenceFn, StoreToPersistenceFn } from "../types";
+export declare class Search {
+    protected readonly url: string;
+    private tokenIndices?;
+    private tokens?;
+    private _loaded;
+    private _loadedFromPersistence;
+    private previousHash;
+    private latestHash;
+    disableFetch: boolean;
+    private loadFromPersistenceFn?;
+    private storeToPersistenceFn?;
+    /**
+     * Set load persistence callback
+     *
+     * @param loadFromPersistenceFn
+     */
+    setLoadFromPersistenceFn(loadFromPersistenceFn: LoadFromPersistenceFn): void;
+    /**
+     * Set store to persistence callback
+     *
+     * @param storeToPersistenceFn
+     */
+    setStoreToPersistenceFn(storeToPersistenceFn: StoreToPersistenceFn): void;
+    /**
+     * Checks if the token indices and tokens have been loaded.
+     *
+     * @returns {boolean} True if the token indices and tokens have been loaded, false otherwise.
+     */
+    get loaded(): boolean;
+    /**
+     * Constructs a new instance of the Search class.
+     *
+     * @param {string} url - The base URL for the API.
+     */
+    constructor(url: string);
+    /**
+     * Retrieves tokens that match the given keyword.
+     *
+     * This method searches for tokens that match the provided keyword.
+     * If the token indices or tokens are not yet loaded, it logs a warning and returns an empty array.
+     *
+     * @param {string} keyword - The keyword to search for.
+     * @param {number} limit - Number of results to show.
+     * @param {boolean} noLimit - disable limit
+     * @returns {Token[]} An array of tokens that match the given keyword.
+     */
+    token(keyword: string, limit?: number, noLimit?: boolean): Token[];
+    /**
+     * Loads the token indices and tokens.
+     *
+     * This method loads the token indices and tokens if they are not already loaded.
+     * It also sets up a periodic update to refresh the token indices and tokens every minute.
+     *
+     * @returns {Promise<void>} A promise that resolves when the initial load is complete.
+     */
+    load(): Promise<void>;
+    /**
+     * Load tokens and indices from persistence
+     *
+     * @param tokenIndices
+     * @param tokens
+     * @returns
+     */
+    private loadFromPersistence;
+    /**
+     * Retrieves and updates the token indices and tokens if necessary.
+     *
+     * This method checks if the current token indices and tokens are undefined.
+     * If they are, it fetches the token indices and tokens from the API.
+     * It then compares the hash of the current token indices with the hash from the server.
+     * If the hashes do not match, it updates the token indices and tokens.
+     *
+     * @private
+     * @returns {Promise<void>} A promise that resolves when the token indices and tokens are updated.
+     */
+    private getTokenIndices;
+    /**
+     * Retrieves all tokens from the API.
+     *
+     * This method makes a GET request to the API to fetch all tokens.
+     *
+     * @private
+     * @returns {Promise<Token[]>} A promise that resolves to an array of tokens.
+     */
+    private getAllTokens;
+    /**
+     * Retrieves the search indices from the API based on the provided key and optional hash.
+     *
+     * This method makes a GET request to the API to fetch the search indices for the specified key.
+     * If a hash is provided, it includes the hash in the request to check for updated indices.
+     *
+     * @private
+     * @param {string} key - The key to identify the search indices.
+     * @param {string} [hash] - Optional hash to validate against the current hash of the indices.
+     * @returns {Promise<SearchIndices>} A promise that resolves to the search indices for the specified key.
+     */
+    private getSearchIndices;
+}
+//# sourceMappingURL=Search.d.ts.map

package/dist/classes/Search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Search.d.ts","sourceRoot":"","sources":["../../src/classes/Search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAG7F,qBAAa,MAAM;IA4Cf,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM;IA1ChC,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,OAAO,CAAC,MAAM,CAAC,CAAU;IACzB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,sBAAsB,CAAS;IACvC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,UAAU,CAAc;IAChC,YAAY,EAAE,OAAO,CAAS;IAE9B,OAAO,CAAC,qBAAqB,CAAC,CAAwB;IACtD,OAAO,CAAC,oBAAoB,CAAC,CAAuB;IAEpD;;;;OAIG;IACH,wBAAwB,CAAC,qBAAqB,EAAE,qBAAqB;IAIrE;;;;OAIG;IACH,uBAAuB,CAAC,oBAAoB,EAAE,oBAAoB;IAIlE;;;;OAIG;IACH,IAAI,MAAM,IAAI,OAAO,CAAwB;IAE7C;;;;OAIG;gBAEkB,GAAG,EAAE,MAAM;IAGhC;;;;;;;;;;OAUG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAY,EAAE,OAAO,GAAE,OAAe,GAAG,KAAK,EAAE;IAiB9E;;;;;;;OAOG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAsC3B;;;;;;OAMG;YACW,mBAAmB;IAWjC;;;;;;;;;;OAUG;YACW,eAAe;IAmB7B;;;;;;;OAOG;YACW,YAAY;IAI1B;;;;;;;;;;OAUG;YACW,gBAAgB;CAO/B"}