sol-ihor-lab 1.0.0

package/lib/esm/create_open_market.js

@@ -0,0 +1,310 @@
+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, SYSVAR_RENT_PUBKEY, SystemProgram, TransactionInstruction } from "@solana/web3.js";
+import { EnvironmentManager, SPL_ERROR } from "./global";
+import { InstructionType, MARKET_STATE_LAYOUT_V2, Token, TxVersion, buildSimpleTransaction, generatePubKey, splitTxAndSigners, struct, u16, u32, u64, u8 } from "@raydium-io/raydium-sdk";
+import { TOKEN_PROGRAM_ID, createInitializeAccountInstruction, getMint } from "@solana/spl-token";
+import BN from "bn.js";
+import * as transactions from "./transaction-helper/transaction";
+function makeCreateMarketInstruction(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ connection, wallet, baseInfo, quoteInfo, lotSize, // 1
+    tickSize, // 0.01
+    dexProgramId, makeTxVersion, lookupTableCache }) {
+        const market = generatePubKey({
+            fromPublicKey: wallet,
+            programId: dexProgramId
+        });
+        const requestQueue = generatePubKey({
+            fromPublicKey: wallet,
+            programId: dexProgramId
+        });
+        const eventQueue = generatePubKey({
+            fromPublicKey: wallet,
+            programId: dexProgramId
+        });
+        const bids = generatePubKey({
+            fromPublicKey: wallet,
+            programId: dexProgramId
+        });
+        const asks = generatePubKey({
+            fromPublicKey: wallet,
+            programId: dexProgramId
+        });
+        const baseVault = generatePubKey({
+            fromPublicKey: wallet,
+            programId: TOKEN_PROGRAM_ID
+        });
+        const quoteVault = generatePubKey({
+            fromPublicKey: wallet,
+            programId: TOKEN_PROGRAM_ID
+        });
+        const feeRateBps = 0;
+        const quoteDustThreshold = new BN(100);
+        function getVaultOwnerAndNonce() {
+            const vaultSignerNonce = new BN(0);
+            while (true) {
+                try {
+                    const vaultOwner = PublicKey.createProgramAddressSync([
+                        market.publicKey.toBuffer(),
+                        vaultSignerNonce.toArrayLike(Buffer, "le", 8)
+                    ], dexProgramId);
+                    return { vaultOwner, vaultSignerNonce };
+                }
+                catch (e) {
+                    vaultSignerNonce.iaddn(1);
+                    if (vaultSignerNonce.gt(new BN(25555)))
+                        throw Error("find vault owner error");
+                }
+            }
+        }
+        function initializeMarketInstruction({ programId, marketInfo }) {
+            const dataLayout = struct([
+                u8("version"),
+                u32("instruction"),
+                u64("baseLotSize"),
+                u64("quoteLotSize"),
+                u16("feeRateBps"),
+                u64("vaultSignerNonce"),
+                u64("quoteDustThreshold")
+            ]);
+            const keys = [
+                { pubkey: marketInfo.id, isSigner: false, isWritable: true },
+                { pubkey: marketInfo.requestQueue, isSigner: false, isWritable: true },
+                { pubkey: marketInfo.eventQueue, isSigner: false, isWritable: true },
+                { pubkey: marketInfo.bids, isSigner: false, isWritable: true },
+                { pubkey: marketInfo.asks, isSigner: false, isWritable: true },
+                { pubkey: marketInfo.baseVault, isSigner: false, isWritable: true },
+                { pubkey: marketInfo.quoteVault, isSigner: false, isWritable: true },
+                { pubkey: marketInfo.baseMint, isSigner: false, isWritable: false },
+                { pubkey: marketInfo.quoteMint, isSigner: false, isWritable: false },
+                // Use a dummy address if using the new dex upgrade to save tx space.
+                {
+                    pubkey: marketInfo.authority
+                        ? marketInfo.quoteMint
+                        : SYSVAR_RENT_PUBKEY,
+                    isSigner: false,
+                    isWritable: false
+                }
+            ]
+                .concat(marketInfo.authority
+                ? { pubkey: marketInfo.authority, isSigner: false, isWritable: false }
+                : [])
+                .concat(marketInfo.authority && marketInfo.pruneAuthority
+                ? {
+                    pubkey: marketInfo.pruneAuthority,
+                    isSigner: false,
+                    isWritable: false
+                }
+                : []);
+            const data = Buffer.alloc(dataLayout.span);
+            dataLayout.encode({
+                version: 0,
+                instruction: 0,
+                baseLotSize: marketInfo.baseLotSize,
+                quoteLotSize: marketInfo.quoteLotSize,
+                feeRateBps: marketInfo.feeRateBps,
+                vaultSignerNonce: marketInfo.vaultSignerNonce,
+                quoteDustThreshold: marketInfo.quoteDustThreshold
+            }, data);
+            return new TransactionInstruction({
+                keys,
+                programId,
+                data
+            });
+        }
+        const { vaultOwner, vaultSignerNonce } = getVaultOwnerAndNonce();
+        const ZERO = new BN(0);
+        const baseLotSize = new BN(Math.round(Math.pow(10, baseInfo.decimals) * lotSize));
+        const quoteLotSize = new BN(Math.round(lotSize * Math.pow(10, quoteInfo.decimals) * tickSize));
+        if (baseLotSize.eq(ZERO))
+            throw Error("lot size is too small");
+        if (quoteLotSize.eq(ZERO))
+            throw Error("tick size or lot size is too small");
+        const ins1 = [];
+        const accountLamports = yield connection.getMinimumBalanceForRentExemption(165);
+        ins1.push(SystemProgram.createAccountWithSeed({
+            fromPubkey: wallet,
+            basePubkey: wallet,
+            seed: baseVault.seed,
+            newAccountPubkey: baseVault.publicKey,
+            lamports: accountLamports,
+            space: 165,
+            programId: TOKEN_PROGRAM_ID
+        }), SystemProgram.createAccountWithSeed({
+            fromPubkey: wallet,
+            basePubkey: wallet,
+            seed: quoteVault.seed,
+            newAccountPubkey: quoteVault.publicKey,
+            lamports: accountLamports,
+            space: 165,
+            programId: TOKEN_PROGRAM_ID
+        }), createInitializeAccountInstruction(baseVault.publicKey, baseInfo.mint, vaultOwner), createInitializeAccountInstruction(quoteVault.publicKey, quoteInfo.mint, vaultOwner));
+        const EVENT_QUEUE_ITEMS = 128; // Default: 2978
+        const REQUEST_QUEUE_ITEMS = 63; // Default: 63
+        const ORDERBOOK_ITEMS = 201; // Default: 909
+        const eventQueueSpace = EVENT_QUEUE_ITEMS * 88 + 44 + 48;
+        const requestQueueSpace = REQUEST_QUEUE_ITEMS * 80 + 44 + 48;
+        const orderBookSpace = ORDERBOOK_ITEMS * 80 + 44 + 48;
+        const ins2 = [];
+        ins2.push(SystemProgram.createAccountWithSeed({
+            fromPubkey: wallet,
+            basePubkey: wallet,
+            seed: market.seed,
+            newAccountPubkey: market.publicKey,
+            lamports: yield connection.getMinimumBalanceForRentExemption(MARKET_STATE_LAYOUT_V2.span),
+            space: MARKET_STATE_LAYOUT_V2.span,
+            programId: dexProgramId
+        }), SystemProgram.createAccountWithSeed({
+            fromPubkey: wallet,
+            basePubkey: wallet,
+            seed: requestQueue.seed,
+            newAccountPubkey: requestQueue.publicKey,
+            lamports: yield connection.getMinimumBalanceForRentExemption(requestQueueSpace),
+            space: requestQueueSpace,
+            programId: dexProgramId
+        }), SystemProgram.createAccountWithSeed({
+            fromPubkey: wallet,
+            basePubkey: wallet,
+            seed: eventQueue.seed,
+            newAccountPubkey: eventQueue.publicKey,
+            lamports: yield connection.getMinimumBalanceForRentExemption(eventQueueSpace),
+            space: eventQueueSpace,
+            programId: dexProgramId
+        }), SystemProgram.createAccountWithSeed({
+            fromPubkey: wallet,
+            basePubkey: wallet,
+            seed: bids.seed,
+            newAccountPubkey: bids.publicKey,
+            lamports: yield connection.getMinimumBalanceForRentExemption(orderBookSpace),
+            space: orderBookSpace,
+            programId: dexProgramId
+        }), SystemProgram.createAccountWithSeed({
+            fromPubkey: wallet,
+            basePubkey: wallet,
+            seed: asks.seed,
+            newAccountPubkey: asks.publicKey,
+            lamports: yield connection.getMinimumBalanceForRentExemption(orderBookSpace),
+            space: orderBookSpace,
+            programId: dexProgramId
+        }), initializeMarketInstruction({
+            programId: dexProgramId,
+            marketInfo: {
+                id: market.publicKey,
+                requestQueue: requestQueue.publicKey,
+                eventQueue: eventQueue.publicKey,
+                bids: bids.publicKey,
+                asks: asks.publicKey,
+                baseVault: baseVault.publicKey,
+                quoteVault: quoteVault.publicKey,
+                baseMint: baseInfo.mint,
+                quoteMint: quoteInfo.mint,
+                baseLotSize: baseLotSize,
+                quoteLotSize: quoteLotSize,
+                feeRateBps: feeRateBps,
+                vaultSignerNonce: vaultSignerNonce,
+                quoteDustThreshold: quoteDustThreshold
+            }
+        }));
+        const ins = {
+            address: {
+                marketId: market.publicKey,
+                requestQueue: requestQueue.publicKey,
+                eventQueue: eventQueue.publicKey,
+                bids: bids.publicKey,
+                asks: asks.publicKey,
+                baseVault: baseVault.publicKey,
+                quoteVault: quoteVault.publicKey,
+                baseMint: baseInfo.mint,
+                quoteMint: quoteInfo.mint
+            },
+            innerTransactions: [
+                {
+                    instructions: ins1,
+                    signers: [],
+                    instructionTypes: [
+                        InstructionType.createAccount,
+                        InstructionType.createAccount,
+                        InstructionType.initAccount,
+                        InstructionType.initAccount
+                    ]
+                },
+                {
+                    instructions: ins2,
+                    signers: [],
+                    instructionTypes: [
+                        InstructionType.createAccount,
+                        InstructionType.createAccount,
+                        InstructionType.createAccount,
+                        InstructionType.createAccount,
+                        InstructionType.createAccount,
+                        InstructionType.initMarket
+                    ]
+                }
+            ]
+        };
+        return {
+            address: ins.address,
+            innerTransactions: yield splitTxAndSigners({
+                connection,
+                makeTxVersion,
+                computeBudgetConfig: undefined,
+                payer: wallet,
+                innerTransaction: ins.innerTransactions,
+                lookupTableCache
+            })
+        };
+    });
+}
+export const createOpenBookMarket = (connection_1, token_owner_1, token_address_1, ...args_1) => __awaiter(void 0, [connection_1, token_owner_1, token_address_1, ...args_1], void 0, function* (connection, token_owner, token_address, min_order_size = 1, tick_size = 0.01) {
+    if (token_owner.publicKey.toBase58().length <= 0 ||
+        token_address.length <= 0) {
+        console.log("Error: [Create Open Book Market] invalid argument for create open book market");
+        return SPL_ERROR.E_INVALID_ARGUE;
+    }
+    try {
+        const token_mint = new PublicKey(token_address);
+        const mint_info = yield getMint(connection, token_mint);
+        const base_token = new Token(TOKEN_PROGRAM_ID, token_address, mint_info.decimals);
+        const quote_token_info = EnvironmentManager.getQuoteTokenInfo();
+        const quote_token = new Token(TOKEN_PROGRAM_ID, quote_token_info.address, quote_token_info.decimal, quote_token_info.symbol, quote_token_info.name);
+        console.log("[Create Open Book Market]<--------------------make marekt instruction");
+        const { innerTransactions, address } = yield makeCreateMarketInstruction({
+            connection: connection,
+            wallet: token_owner.publicKey,
+            baseInfo: base_token,
+            quoteInfo: quote_token,
+            lotSize: min_order_size,
+            tickSize: tick_size,
+            dexProgramId: EnvironmentManager.getProgramID().OPENBOOK_MARKET,
+            makeTxVersion: TxVersion.V0,
+            lookupTableCache: EnvironmentManager.getCacheLTA()
+        });
+        console.log("[Create Open Book Market]<--------------------create simple transaction");
+        const txns = yield buildSimpleTransaction({
+            connection: connection,
+            makeTxVersion: TxVersion.V0,
+            payer: token_owner.publicKey,
+            innerTransactions: innerTransactions,
+            addLookupTableInfo: EnvironmentManager.getCacheLTA()
+        });
+        console.log("[Create Open Book Market]<--------------------send and confirm transaction");
+        const txn_result = yield transactions.sendAndConfirmTransactionsWithCheck(connection, token_owner, txns);
+        if (txn_result !== SPL_ERROR.E_OK) {
+            console.error("Error: [Create Open Book Market] failed to send and confirm transaction");
+            return SPL_ERROR.E_FAIL;
+        }
+    }
+    catch (error) {
+        console.error("Error: [Create Open Book Market] error occured: ", error);
+        return SPL_ERROR.E_FAIL;
+    }
+    console.log("Success: [Create Open Book Market] Success to create open book market id");
+    return SPL_ERROR.E_OK;
+});

package/lib/esm/create_pool.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair } from "@solana/web3.js";
+import { TX_RET } from "./global";
+export declare const createPool: (connection: Connection, token_owner: Keypair, token_address: string, input_token_amount: number, input_quote_amount: number) => Promise<TX_RET>;

package/lib/esm/create_pool.js

@@ -0,0 +1,80 @@
+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, TxVersion, buildSimpleTransaction } from "@raydium-io/raydium-sdk";
+import { Market } from "@project-serum/serum";
+import * as utiles from "./utility";
+import { BN } from "bn.js";
+export const createPool = (connection, token_owner, token_address, input_token_amount, input_quote_amount) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (token_address.length <= 0) {
+            console.log("Error: [Create Pool] invalid argument for create pool");
+            return { result: SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+        }
+        console.log("<---------------------[Create Pool]-----------------------");
+        const token_mint = new PublicKey(token_address);
+        const mint_info = yield getMint(connection, token_mint);
+        const base_token = new Token(TOKEN_PROGRAM_ID, token_address, mint_info.decimals);
+        const quote_token_info = EnvironmentManager.getQuoteTokenInfo();
+        const quote_token = new Token(TOKEN_PROGRAM_ID, quote_token_info.address, quote_token_info.decimal, quote_token_info.symbol, quote_token_info.name);
+        const accounts = yield Market.findAccountsByMints(connection, base_token.mint, quote_token.mint, EnvironmentManager.getProgramID().OPENBOOK_MARKET);
+        if (accounts.length === 0) {
+            throw "Get market account failed";
+        }
+        console.log("Market Found");
+        const market_id = accounts[0].publicKey;
+        const start_time = Math.floor(Date.now() / 1000);
+        const base_amount = utiles.xWeiAmount(input_token_amount, base_token.decimals);
+        const quote_amount = utiles.xWeiAmount(input_quote_amount, quote_token.decimals);
+        const wallet_token_accounts = yield utiles.getWalletAccounts(connection, token_owner.publicKey);
+        if (!wallet_token_accounts || wallet_token_accounts.length <= 0) {
+            throw "Get wallet account failed";
+        }
+        const { innerTransactions, address } = yield Liquidity.makeCreatePoolV4InstructionV2Simple({
+            connection: connection,
+            programId: EnvironmentManager.getProgramID().AmmV4,
+            marketInfo: {
+                marketId: market_id,
+                programId: EnvironmentManager.getProgramID().OPENBOOK_MARKET
+            },
+            baseMintInfo: base_token,
+            quoteMintInfo: quote_token,
+            baseAmount: base_amount,
+            quoteAmount: quote_amount,
+            startTime: new BN(start_time),
+            ownerInfo: {
+                feePayer: token_owner.publicKey,
+                wallet: token_owner.publicKey,
+                tokenAccounts: wallet_token_accounts,
+                useSOLBalance: true
+            },
+            makeTxVersion: TxVersion.V0,
+            associatedOnly: false,
+            checkCreateATAOwner: true,
+            feeDestinationId: EnvironmentManager.getFeeDestinationId()
+        });
+        const txns = yield buildSimpleTransaction({
+            connection: connection,
+            makeTxVersion: TxVersion.V0,
+            payer: token_owner.publicKey,
+            innerTransactions: innerTransactions,
+            addLookupTableInfo: EnvironmentManager.getCacheLTA(),
+            recentBlockhash: (yield connection.getLatestBlockhash()).blockhash
+        });
+        console.log("Success: [Create Pool] made transaction successfully");
+        return { result: SPL_ERROR.E_OK, value: txns };
+    }
+    catch (error) {
+        console.error("Error: [Create Pool] err: ", error);
+        return { result: SPL_ERROR.E_FAIL, value: undefined };
+    }
+});

package/lib/esm/create_token.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair } from "@solana/web3.js";
+import { TX_RET } from "./global";
+export declare const createToken: (connection: Connection, token_owner: Keypair, name: string, symbol: string, decimal: number, total_supply: number, token_logo: string, description?: string) => Promise<TX_RET>;

package/lib/esm/create_token.js

@@ -0,0 +1,137 @@
+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, Transaction } from "@solana/web3.js";
+import { EnvironmentManager, SPL_ERROR } from "./global";
+import { createMint, getMint, getOrCreateAssociatedTokenAccount, mintTo } from "@solana/spl-token";
+import { Metaplex, bundlrStorage, keypairIdentity, toMetaplexFile } from "@metaplex-foundation/js";
+import { readFileSync } from "fs";
+import { checkFileExists, xWeiAmount } from "./utility";
+import { PROGRAM_ID, createCreateMetadataAccountV3Instruction } from "@metaplex-foundation/mpl-token-metadata";
+import * as transaction from "./transaction-helper/transaction";
+const totalSupplyMint = (connection, token_owner, token_addr, total_supply) => __awaiter(void 0, void 0, void 0, function* () {
+    const token_mint = new PublicKey(token_addr);
+    const mint_info = yield getMint(connection, token_mint);
+    try {
+        const owner_token_account = yield getOrCreateAssociatedTokenAccount(connection, token_owner, token_mint, token_owner.publicKey);
+        if (owner_token_account.address.toBase58().length <= 0) {
+            console.log("Error: [Total Supply Mint] failed to create associated token account");
+            return SPL_ERROR.E_TOTAL_MINT_FAIL;
+        }
+        const token_amount = xWeiAmount(total_supply, mint_info.decimals);
+        const mint_result = yield mintTo(connection, token_owner, token_mint, owner_token_account.address, token_owner, BigInt(token_amount.toString()));
+        if (mint_result.length <= 0) {
+            console.log("Error: [Total Supply Mint] failed to mint to owner wallet");
+            return SPL_ERROR.E_TOTAL_MINT_FAIL;
+        }
+    }
+    catch (error) {
+        console.log("Error: [Total Supply Mint] failed to mint to owner wallet");
+        return SPL_ERROR.E_TOTAL_MINT_FAIL;
+    }
+    return SPL_ERROR.E_OK;
+});
+const createTokenMetaData = (connection, token_owner, token_addr, name, symbol, token_logo, rpc_url, description) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const metaplex = Metaplex.make(connection)
+            .use(keypairIdentity(token_owner))
+            .use(bundlrStorage({
+            address: EnvironmentManager.getBundlrUrl(),
+            providerUrl: rpc_url,
+            timeout: 60000
+        }));
+        const buffer = readFileSync(token_logo);
+        const file = toMetaplexFile(buffer, "token-logo.png");
+        const logo_url = yield metaplex.storage().upload(file);
+        if (logo_url.length <= 0) {
+            console.log("Error: [Create Token Meta Data] failed to load metapelx data!!!");
+            return SPL_ERROR.E_FAIL;
+        }
+        const metaplex_data = {
+            name: name,
+            symbol: symbol,
+            image: logo_url,
+            description
+        };
+        const { uri } = yield metaplex.nfts().uploadMetadata(metaplex_data);
+        if (uri.length <= 0) {
+            console.log("Error: [Create Token Meta Data] failed to upload metaplex data!!!");
+            return SPL_ERROR.E_FAIL;
+        }
+        const token_mint = new PublicKey(token_addr);
+        const [metadata_PDA] = PublicKey.findProgramAddressSync([Buffer.from("metadata"), PROGRAM_ID.toBuffer(), token_mint.toBuffer()], PROGRAM_ID);
+        const token_meta_data = {
+            name: name,
+            symbol: symbol,
+            uri: uri,
+            sellerFeeBasisPoints: 0,
+            creators: null,
+            collection: null,
+            uses: null
+        };
+        const txn = new Transaction().add(createCreateMetadataAccountV3Instruction({
+            metadata: metadata_PDA,
+            mint: token_mint,
+            mintAuthority: token_owner.publicKey,
+            payer: token_owner.publicKey,
+            updateAuthority: token_owner.publicKey
+        }, {
+            createMetadataAccountArgsV3: {
+                data: token_meta_data,
+                isMutable: true,
+                collectionDetails: null
+            }
+        }));
+        if ((yield transaction.sendAndConfirmTransactionWithCheck(connection, token_owner, txn)) !== SPL_ERROR.E_OK) {
+            return SPL_ERROR.E_FAIL;
+        }
+    }
+    catch (error) {
+        console.log("Error: [Create Token Meta Data] failed to create meta data -", error);
+        return SPL_ERROR.E_FAIL;
+    }
+    return SPL_ERROR.E_OK;
+});
+export const createToken = (connection, token_owner, name, symbol, decimal, total_supply, token_logo, description) => __awaiter(void 0, void 0, void 0, function* () {
+    if (name.length <= 0 ||
+        symbol.length <= 0 ||
+        token_logo.length <= 0 ||
+        token_owner.publicKey.toBase58().length <= 0 ||
+        EnvironmentManager.getRpcNetUrl().length <= 0 ||
+        decimal <= 0 ||
+        total_supply <= 0) {
+        console.log("Error: [Create Token] invalid argument to create token!!!");
+        return { result: SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+    }
+    if ((yield checkFileExists(token_logo)) === false) {
+        console.log("Error: [Create Token] invalid argument to create token - token logo path invalid!!!");
+        return { result: SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+    }
+    console.log("<-----------------[Create Token]---------------------");
+    console.log("Name: ", name, "Symbol: ", symbol, "Decimal: ", decimal, "Total Supply: ", total_supply, "Token Logo: ", token_logo, "Token Description: ", description);
+    console.log("<-----------------[Create Token]---------------------");
+    const token_mint = yield createMint(connection, token_owner, token_owner.publicKey, token_owner.publicKey, decimal);
+    if (token_mint.toBase58().length <= 0) {
+        console.log("Error: [Create Token] failed to create mint!!!");
+        return { result: SPL_ERROR.E_FAIL, value: undefined };
+    }
+    console.log("<-----------------[Create Token Meta Data]---------------------");
+    const meta_result = yield createTokenMetaData(connection, token_owner, token_mint.toBase58(), name, symbol, token_logo, EnvironmentManager.getRpcNetUrl(), description);
+    if (meta_result !== SPL_ERROR.E_OK) {
+        console.log("Error: [Create Token] failed to create meta data!!!");
+        return { result: SPL_ERROR.E_CREATE_META_FAILED, value: undefined };
+    }
+    console.log("<-----------------[Token mint]---------------------");
+    if ((yield totalSupplyMint(connection, token_owner, token_mint.toBase58(), total_supply)) !== SPL_ERROR.E_OK) {
+        console.log("Error: [Create Token] failed to mint total supply!!!");
+        return { result: SPL_ERROR.E_TOTAL_MINT_FAIL, value: undefined };
+    }
+    console.log("Success: [Create Token] Mint Address: ", token_mint.toBase58());
+    return { result: SPL_ERROR.E_OK, value: token_mint.toBase58() };
+});

package/lib/esm/errors.d.ts

@@ -0,0 +1,18 @@
+export declare abstract class BaseError extends Error {
+    constructor(message?: string);
+}
+export declare class UploadMetadataError extends BaseError {
+    name: string;
+}
+export declare class GenerateTransactionError extends BaseError {
+    name: string;
+}
+export declare class BuildInstructionError extends BaseError {
+    name: string;
+}
+export declare class SetTxPriorityError extends BaseError {
+    name: string;
+}
+export declare class TransactionExecuteError extends BaseError {
+    name: string;
+}

package/lib/esm/errors.js

@@ -0,0 +1,35 @@
+export class BaseError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+export class UploadMetadataError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = "UploadMetadataError";
+    }
+}
+export class GenerateTransactionError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = "GenerateTransactionError";
+    }
+}
+export class BuildInstructionError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = "BuildInstructionError";
+    }
+}
+export class SetTxPriorityError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = "SetTxPriorityError";
+    }
+}
+export class TransactionExecuteError extends BaseError {
+    constructor() {
+        super(...arguments);
+        this.name = "TransactionExecuteError";
+    }
+}

package/lib/esm/global.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { CacheLTA, ProgramId } from "@raydium-io/raydium-sdk";
+import { Keypair, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+export declare enum SPL_ERROR {
+    E_INVALID_ARGUE = -1,
+    E_OK = 0,
+    E_FAIL = 1,
+    E_CHECK_FAIL = 2,
+    E_SEND_TX_FAIL = 3,
+    E_CONFIRM_TX_FAIL = 4,
+    E_CREATE_META_FAILED = 5,
+    E_TOTAL_MINT_FAIL = 6
+}
+export declare enum NETWORK_MODE {
+    NETWORK_MAIN = 0,
+    NETWORK_DEV = 1,
+    NETWORK_TEST = 2
+}
+export interface TX_RET {
+    result: SPL_ERROR;
+    value: string | (VersionedTransaction | Transaction)[] | undefined;
+}
+export interface TOKEN_INFO {
+    address: string;
+    name: string;
+    symbol: string;
+    decimal: number;
+}
+export interface BUNDLE_TRANSACTION {
+    txn: VersionedTransaction;
+    signer: Keypair;
+}
+export declare class EnvironmentManager {
+    private static NET_MODE;
+    private static JITO_BLOCKENGINE_URL;
+    private static RPC_CHECK_URL;
+    private static RPC_MAIN_URL;
+    private static RPC_DEVNET_URL;
+    private static RPC_TESTNET_URL;
+    private static JITO_KEYPAIR;
+    private static QUOTE_TOKEN_INFO;
+    static setNetworkMode(mode: NETWORK_MODE): void;
+    static setMainNetURL(url: string): void;
+    static setDevNetURL(url: string): void;
+    static setTestNettURL(url: string): void;
+    static getMainNetURL(): string;
+    static getDevNetURL(): string;
+    static getTestNetURL(): string;
+    static getNetworkMode(): NETWORK_MODE;
+    static getRpcNetUrl(): string;
+    static setNetUrls(main_url: string, dev_url: string, test_url?: string): void;
+    static getBundlrUrl(): string;
+    static getCheckUrl(): string;
+    static getProgramID(): ProgramId;
+    static setQuoteTokenInfo(token_info: TOKEN_INFO): void;
+    static getQuoteTokenInfo(): TOKEN_INFO;
+    static getCacheLTA(): CacheLTA | undefined;
+    static getFeeDestinationId(): PublicKey;
+    static getJitoBlockEngine(): string;
+    static setJitoKeypair(auth_key: Keypair): void;
+    static getJitoKeypair(): Keypair;
+}