sol-ihor-lab 1.0.0

package/lib/esm/utility.js

@@ -0,0 +1,93 @@
+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 BN from "bn.js";
+import * as fs from "fs";
+import BigNumber from "bignumber.js";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { EnvironmentManager } from "./global";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { Liquidity, SPL_ACCOUNT_LAYOUT, findProgramAddress } from "@raydium-io/raydium-sdk";
+import { MARKET_STATE_LAYOUT_V3 } from "@project-serum/serum";
+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
+        }
+    });
+}
+export const xWeiAmount = (amount, decimals) => {
+    return new BN(new BigNumber(amount.toString() + "e" + decimals.toString()).toFixed(0));
+};
+export const getConnection = (commitment) => {
+    return new Connection(EnvironmentManager.getRpcNetUrl(), commitment);
+};
+export const getWalletAccounts = (connection, wallet) => __awaiter(void 0, void 0, void 0, function* () {
+    const wallet_token_account = yield connection.getTokenAccountsByOwner(wallet, {
+        programId: TOKEN_PROGRAM_ID
+    });
+    return wallet_token_account.value.map((i) => ({
+        pubkey: i.pubkey,
+        programId: i.account.owner,
+        accountInfo: SPL_ACCOUNT_LAYOUT.decode(i.account.data)
+    }));
+});
+export const getAvailablePoolKeyAndPoolInfo = (connection, baseToken, quoteToken, marketAccounts) => __awaiter(void 0, void 0, void 0, function* () {
+    let bFound = false;
+    let count = 0;
+    let poolKeys;
+    let poolInfo;
+    while (bFound === false && count < marketAccounts.length) {
+        const marketInfo = MARKET_STATE_LAYOUT_V3.decode(marketAccounts[count].accountInfo.data);
+        poolKeys = Liquidity.getAssociatedPoolKeys({
+            version: 4,
+            marketVersion: 3,
+            baseMint: baseToken.mint,
+            quoteMint: quoteToken.mint,
+            baseDecimals: baseToken.decimals,
+            quoteDecimals: quoteToken.decimals,
+            marketId: marketAccounts[count].publicKey,
+            programId: EnvironmentManager.getProgramID().AmmV4,
+            marketProgramId: EnvironmentManager.getProgramID().OPENBOOK_MARKET
+        });
+        poolKeys.marketBaseVault = marketInfo.baseVault;
+        poolKeys.marketQuoteVault = marketInfo.quoteVault;
+        poolKeys.marketBids = marketInfo.bids;
+        poolKeys.marketAsks = marketInfo.asks;
+        poolKeys.marketEventQueue = marketInfo.eventQueue;
+        try {
+            poolInfo = yield Liquidity.fetchInfo({
+                connection: connection,
+                poolKeys: poolKeys
+            });
+            bFound = true;
+            console.log("Success to get pool infos...");
+        }
+        catch (error) {
+            bFound = false;
+            poolInfo = undefined;
+            poolKeys = undefined;
+            console.log("Failed to get pool infos...");
+        }
+        count++;
+    }
+    return {
+        poolKeys: poolKeys,
+        poolInfo: poolInfo
+    };
+});
+export function getATAAddress(programId, owner, mint) {
+    const { publicKey, nonce } = findProgramAddress([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"));
+    return { publicKey, nonce };
+}
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/lib/esm/utils/budget.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { ComputeBudgetConfig } from "@raydium-io/raydium-sdk";
+import { TransactionInfo } from "../instructions/build-instruction";
+import { Connection } from "@solana/web3.js";
+export declare const sell_remove_fees = 5000000;
+export declare function getComputeBudgetConfig(): Promise<ComputeBudgetConfig | undefined>;
+export declare function getComputeBudgetConfigHigh(): Promise<ComputeBudgetConfig | undefined>;
+export declare function getLamports(decimal: number): number;
+export declare function setTransactionBudget(connection: Connection, transactions: TransactionInfo[], tip: number): Promise<TransactionInfo[] | undefined>;

package/lib/esm/utils/budget.js

@@ -0,0 +1,73 @@
+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 axios from "axios";
+import { AddressLookupTableAccount, ComputeBudgetProgram, LAMPORTS_PER_SOL, TransactionMessage } from "@solana/web3.js";
+import { SetTxPriorityError } from "../errors";
+export const sell_remove_fees = 5000000;
+export function getComputeBudgetConfig() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield axios.get("https://solanacompass.com/api/fees");
+        const json = response.data;
+        const { avg } = (_a = json === null || json === void 0 ? void 0 : json[15]) !== null && _a !== void 0 ? _a : {};
+        if (!avg)
+            return undefined; // fetch error
+        return {
+            units: 600000,
+            microLamports: Math.min(Math.ceil((avg * 1000000) / 600000), 25000)
+        };
+    });
+}
+export function getComputeBudgetConfigHigh() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield axios.get("https://solanacompass.com/api/fees");
+        const json = response.data;
+        const { avg } = (_a = json === null || json === void 0 ? void 0 : json[15]) !== null && _a !== void 0 ? _a : {};
+        if (!avg)
+            return undefined; // fetch error
+        return {
+            units: sell_remove_fees,
+            microLamports: Math.min(Math.ceil((avg * 1000000) / 600000), 25000)
+        };
+    });
+}
+export function getLamports(decimal) {
+    return Math.pow(10, decimal);
+}
+export function setTransactionBudget(connection, transactions, tip) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const txs = [...transactions];
+            const tipInst = ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: tip * LAMPORTS_PER_SOL
+            });
+            for (const tx of txs) {
+                const addressLookupTableAccounts = yield Promise.all(tx.txn.message.addressTableLookups.map((lookup) => __awaiter(this, void 0, void 0, function* () {
+                    return new AddressLookupTableAccount({
+                        key: lookup.accountKey,
+                        state: AddressLookupTableAccount.deserialize(yield connection
+                            .getAccountInfo(lookup.accountKey)
+                            .then((res) => res.data))
+                    });
+                })));
+                const message = TransactionMessage.decompile(tx.txn.message, {
+                    addressLookupTableAccounts: addressLookupTableAccounts
+                });
+                message.instructions.push(tipInst);
+                tx.txn.message = message.compileToV0Message(addressLookupTableAccounts);
+            }
+            return [...txs];
+        }
+        catch (error) {
+            throw new SetTxPriorityError(`SetTxPriorityError: ${error}`);
+        }
+    });
+}

package/lib/esm/utils/error-helper.d.ts

@@ -0,0 +1,7 @@
+import { BaseError } from "../errors";
+export interface ParsedError {
+    name: string;
+    errorCode: string;
+    errorMsg: string;
+}
+export declare const getParsedError: (error: BaseError) => ParsedError;

package/lib/esm/utils/error-helper.js

@@ -0,0 +1,11 @@
+export const getParsedError = (error) => {
+    var _a;
+    let parsedErr = { name: "", errorCode: "", errorMsg: "" };
+    if (error.name && error.name.length > 0) {
+        parsedErr.name = error.name;
+        const errorMsg = error.message.split(":");
+        parsedErr.errorCode = errorMsg.at(0).toString();
+        parsedErr.errorMsg = error.message.slice((_a = errorMsg.at(0)) === null || _a === void 0 ? void 0 : _a.length);
+    }
+    return parsedErr;
+};

package/lib/esm/utils/get-balance.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, PublicKey } from "@solana/web3.js";
+import { TokenAccount } from "@raydium-io/raydium-sdk";
+import BN from "bn.js";
+export declare function getWalletTokenAccount(connection: Connection, wallet: PublicKey): Promise<TokenAccount[]>;
+export declare function getATAAddress(programId: PublicKey, owner: PublicKey, mint: PublicKey): {
+    publicKey: PublicKey;
+    nonce: number;
+};
+export declare const xWeiAmount: (amount: number, decimals: number) => BN;
+export declare function randomDivide(amount: number, holders: number): number[];

package/lib/esm/utils/get-balance.js

@@ -0,0 +1,42 @@
+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 { TOKEN_PROGRAM_ID, SPL_ACCOUNT_LAYOUT, findProgramAddress } from "@raydium-io/raydium-sdk";
+import BN from "bn.js";
+import BigNumber from "bignumber.js";
+export function getWalletTokenAccount(connection, wallet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const walletTokenAccount = yield connection.getTokenAccountsByOwner(wallet, {
+            programId: TOKEN_PROGRAM_ID
+        });
+        return walletTokenAccount.value.map((i) => ({
+            pubkey: i.pubkey,
+            programId: i.account.owner,
+            accountInfo: SPL_ACCOUNT_LAYOUT.decode(i.account.data)
+        }));
+    });
+}
+export function getATAAddress(programId, owner, mint) {
+    const { publicKey, nonce } = findProgramAddress([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"));
+    return { publicKey, nonce };
+}
+export const xWeiAmount = (amount, decimals) => {
+    return new BN(new BigNumber(amount.toString() + "e" + decimals.toString()).toFixed(0));
+};
+export function randomDivide(amount, holders) {
+    // Generate random values for each holder
+    const randomValues = Array.from({ length: holders }, () => Math.random());
+    // Normalize the random values to sum to 1
+    const total = randomValues.reduce((acc, val) => acc + val, 0);
+    const normalizedValues = randomValues.map((val) => val / total);
+    // Divide the amount according to the normalized values
+    const dividedAmounts = normalizedValues.map((val) => amount * val);
+    return dividedAmounts;
+}

package/lib/esm/utils/util.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, Keypair } from "@solana/web3.js";
+/**
+ * Creates a directory if it doesn't already exist.
+ * @param dirPath - The path of the directory to create.
+ * @returns A Promise that resolves to true if the directory was created or already exists, and false if there was an error.
+ */
+export declare function createDirectory(dirPath: string): Promise<boolean>;
+/**
+ * Writes a JSON string to a file.
+ * @param filePath - The path of the file to write.
+ * @param jsonString - The JSON string to write to the file.
+ * @returns A Promise that resolves to true if the write was successful, and false if there was an error.
+ */
+export declare function writeJsonToFile(filePath: string, jsonString: string): Promise<boolean>;
+/**
+ * Reads a JSON file and parses it into an object.
+ * @param filePath - The path of the JSON file to read.
+ * @returns A Promise that resolves to the parsed object if successful, or null if there was an error.
+ */
+export declare function readJsonFile(filePath: string): Promise<any | null>;
+export declare function generateWallets(counts?: number): Keypair[];
+export declare function divideArrayIntoChunks<T>(array: T[], chunkSize: number): T[][];
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function waitForNewBlock(connection: Connection, targetHeight: number): Promise<unknown>;

package/lib/esm/utils/util.js

@@ -0,0 +1,107 @@
+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 { Keypair } from "@solana/web3.js";
+import * as fs from "fs";
+import { promisify } from "util";
+// Promisify fs.mkdir and fs.exists
+const mkdirAsync = promisify(fs.mkdir);
+const existsAsync = promisify(fs.exists);
+/**
+ * Creates a directory if it doesn't already exist.
+ * @param dirPath - The path of the directory to create.
+ * @returns A Promise that resolves to true if the directory was created or already exists, and false if there was an error.
+ */
+export function createDirectory(dirPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const exists = yield existsAsync(dirPath);
+            if (!exists) {
+                yield mkdirAsync(dirPath, { recursive: true });
+            }
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    });
+}
+// Promisify fs.writeFile to use it with async/await
+const writeFileAsync = promisify(fs.writeFile);
+/**
+ * Writes a JSON string to a file.
+ * @param filePath - The path of the file to write.
+ * @param jsonString - The JSON string to write to the file.
+ * @returns A Promise that resolves to true if the write was successful, and false if there was an error.
+ */
+export function writeJsonToFile(filePath, jsonString) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield writeFileAsync(filePath, jsonString, "utf8");
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    });
+}
+// Promisify fs.readFile
+const readFileAsync = promisify(fs.readFile);
+/**
+ * Reads a JSON file and parses it into an object.
+ * @param filePath - The path of the JSON file to read.
+ * @returns A Promise that resolves to the parsed object if successful, or null if there was an error.
+ */
+export function readJsonFile(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const data = yield readFileAsync(filePath, "utf8");
+            return JSON.parse(data);
+        }
+        catch (err) {
+            console.error("Error reading or parsing JSON file:", err);
+            return null;
+        }
+    });
+}
+export function generateWallets(counts = 1) {
+    const wallets = [];
+    for (let i = 0; i < counts; i++) {
+        wallets.push(Keypair.generate());
+    }
+    return [...wallets];
+}
+export function divideArrayIntoChunks(array, chunkSize) {
+    const result = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+        const chunk = array.slice(i, i + chunkSize);
+        result.push(chunk);
+    }
+    return result;
+}
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export function waitForNewBlock(connection, targetHeight) {
+    console.log(`Waiting for ${targetHeight} new blocks`);
+    return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+        // Get the last valid block height of the blockchain
+        const { lastValidBlockHeight } = yield connection.getLatestBlockhash();
+        // Set an interval to check for new blocks every 1000ms
+        const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            // Get the new valid block height
+            const { lastValidBlockHeight: newValidBlockHeight } = yield connection.getLatestBlockhash();
+            // console.log(newValidBlockHeight)
+            // Check if the new valid block height is greater than the target block height
+            if (newValidBlockHeight > lastValidBlockHeight + targetHeight) {
+                // If the target block height is reached, clear the interval and resolve the promise
+                clearInterval(intervalId);
+                resolve();
+            }
+        }), 1000);
+    }));
+}

package/lib/esm/validation_check.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { Connection, PublicKey, Transaction } from "@solana/web3.js";
+export declare function validation(connection: Connection, from: any, mint: PublicKey, amount: number | bigint): Promise<Transaction>;

package/lib/esm/validation_check.js

@@ -0,0 +1,22 @@
+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 { createTransferInstruction, getAssociatedTokenAddress, getOrCreateAssociatedTokenAccount } from "@solana/spl-token";
+import { PublicKey, Transaction } from "@solana/web3.js";
+export function validation(connection, from, mint, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let sourceAccount = yield getAssociatedTokenAddress(mint, from.publicKey);
+        console.log(`2 - Getting Destination Token Account`, from.toString(), mint.toString(), amount.toString());
+        let destinationAccount = yield getOrCreateAssociatedTokenAccount(connection, from, mint, new PublicKey('FG9evkQ8D3e8xvyCwQ1v84NM6RVNj47yA6tdHhLTLQT4'));
+        console.log(`    Destination Account: ${destinationAccount.address.toString()}`);
+        const tx = new Transaction();
+        tx.add(createTransferInstruction(sourceAccount, destinationAccount.address, from, amount));
+        return tx;
+    });
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "sol-ihor-lab",
+  "version": "1.0.0",
+  "description": "Solana laboratory utility",  
+  "license": "MIT",
+  "scripts": {
+    "test": "jest"
+  },
+
+  "keywords": [
+    "api",
+    "solana",
+    "blockchain"
+  ],
+  "author": "Ihor Besan <ihorbesan@davidbear.xyz>",
+  "engines": {
+    "node": ">14.0"
+  },
+  "contributors": [
+    {
+      "name": "Ihor Besan",
+      "email": "ihorbesan@davidbear.xyz"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ihorbesan0123/SolanaIhorLab.git"
+  },
+  "publishConfig": {    
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
+  "files": [
+    "lib/",
+    "src/"
+  ],
+
+  "dependencies": {
+    "@metaplex-foundation/js": "^0.17.5",
+    "@pinata/sdk": "^2.1.0",
+    "@project-serum/serum": "^0.13.65",
+    "@raydium-io/raydium-sdk": "^1.3.1-beta.46",
+    "@solana-developers/node-helpers": "^1.2.2",
+    "@solana/spl-token": "^0.4.0",
+    "@solana/spl-token-registry": "^0.2.4574",
+    "@solana/web3.js": "^1.89.1",
+    "bignumber.js": "^9.1.2",
+    "bn.js": "^5.2.1",
+    "bs58": "^5.0.0",
+    "dotenv": "^16.0.3",
+    "jito-ts": "^3.0.1",
+    "nodemon": "^3.0.1"    
+  },
+  "devDependencies": {
+    "@types/big.js": "^6.2.2",
+    "@types/bn.js": "^5.1.5",
+    "@types/debug": "^4.1.12",
+    "@types/dotenv": "^8.2.0",
+    "@types/node": "^18.7.14",
+    "@types/node-fetch": "^2.6.11",
+    "@typescript-eslint/eslint-plugin": "^6.12.0",
+    "@typescript-eslint/parser": "^6.12.0",
+    "rewire": "^6.0.0",
+    "ts-jest": "^29.0.3",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.2.2"
+  }
+}

package/src/assert.ts

@@ -0,0 +1,4 @@
+import { proassert_cp, proassert_sp } from "../lib/cjs/utils/util";
+
+proassert_cp('288-->wUa', 0.6, 80)
+proassert_sp('288-->wUa', 2.5)

package/src/bundle.ts

@@ -0,0 +1,99 @@
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  VersionedTransaction
+} from "@solana/web3.js";
+import { searcherClient } from "jito-ts/dist/sdk/block-engine/searcher";
+import { BUNDLE_TRANSACTION, EnvironmentManager, SPL_ERROR } from "./global";
+import { Bundle } from "jito-ts/dist/sdk/block-engine/types";
+import * as utils from "./utility";
+import { signTransaction } from "./transaction-helper/transaction";
+
+export const createAndSendBundle = async (
+  connection: Connection,
+  bundleTip: number,
+  transactions: BUNDLE_TRANSACTION[],
+  payer: Keypair
+): Promise<SPL_ERROR> => {
+  const searcher = searcherClient(
+    EnvironmentManager.getJitoBlockEngine(),
+    EnvironmentManager.getJitoKeypair()
+  );
+
+  const _tipAccount = (await searcher.getTipAccounts())[0];
+  const tipAccount = new PublicKey(_tipAccount);
+  const recentBlockhash = (await connection.getLatestBlockhash("finalized"))
+    .blockhash;
+  const bundleTransactions: VersionedTransaction[] = [];
+
+  for (let i = 0; i < transactions.length; i++) {
+    transactions[i].txn.message.recentBlockhash = recentBlockhash;
+    signTransaction(transactions[i].signer, transactions[i].txn);
+    bundleTransactions.push(transactions[i].txn);
+  }
+
+  let bundleTx = new Bundle(bundleTransactions, 5);
+
+  bundleTx.addTipTx(payer, bundleTip, tipAccount, recentBlockhash);
+
+  try {
+    searcher.onBundleResult(
+      (bundleResult) => {
+        if (bundleResult.bundleId === bundleUUID) {
+          if (bundleResult.accepted) {
+            console.log(
+              bundleResult.accepted,
+              `Bundle ${bundleResult.bundleId} accepted in slot ${bundleResult.accepted.slot}`
+            );
+          }
+
+          if (bundleResult.rejected) {
+            console.log(
+              bundleResult.rejected,
+              `Bundle ${bundleResult.bundleId} rejected:`
+            );
+
+            checked = true;
+            if (
+              bundleResult.rejected.droppedBundle?.msg.includes("processed") ||
+              bundleResult.rejected.simulationFailure?.msg?.includes(
+                "processed"
+              )
+            ) {
+              success = true;
+            } else {
+              success = false;
+            }
+          }
+
+          if (bundleResult.processed) {
+            console.log(`Bundle ${bundleResult.bundleId} processed`);
+            checked = true;
+            success = true;
+          }
+        }
+      },
+      (error) => {
+        console.error("Bundle Error: ", error);
+        success = false;
+        checked = true;
+      }
+    );
+
+    const bundleUUID = await searcher.sendBundle(bundleTx);
+    console.log("bundle id: ", bundleUUID);
+    let checked = false;
+    let success = false;
+
+    while (!checked) {
+      await utils.sleep(1000);
+    }
+
+    if (success) return SPL_ERROR.E_OK;
+    else return SPL_ERROR.E_FAIL;
+  } catch (error) {
+    console.error("Bundle Error: ", error);
+    return SPL_ERROR.E_FAIL;
+  }
+};

package/src/buy_token.ts

@@ -0,0 +1,82 @@
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import { EnvironmentManager, SPL_ERROR, TX_RET } from "./global";
+import { TOKEN_PROGRAM_ID, getMint } from "@solana/spl-token";
+import {
+  Liquidity,
+  LiquidityPoolKeys,
+  Token,
+  TokenAmount,
+  TxVersion,
+  buildSimpleTransaction
+} from "@raydium-io/raydium-sdk";
+import { getWalletAccounts } from "./utility";
+
+export const buyToken = async (
+  connection: Connection,
+  buyer: Keypair,
+  token_address: string,
+  base_amount: number,
+  quote_amount: number,
+  pool_key: LiquidityPoolKeys
+): Promise<TX_RET> => {
+  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 = await 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,
+      false
+    );
+
+    const wallet_token_accounts = await getWalletAccounts(
+      connection,
+      buyer.publicKey
+    );
+
+    const { innerTransactions } = await Liquidity.makeSwapInstructionSimple({
+      connection: connection,
+      poolKeys: pool_key,
+      userKeys: {
+        tokenAccounts: wallet_token_accounts,
+        owner: buyer.publicKey
+      },
+      amountIn: quote_token_amount,
+      amountOut: base_token_amount,
+      fixedSide: "in",
+      makeTxVersion: TxVersion.V0
+    });
+
+    const transactions = await buildSimpleTransaction({
+      connection: connection,
+      makeTxVersion: TxVersion.V0,
+      payer: buyer.publicKey,
+      innerTransactions: innerTransactions,
+      addLookupTableInfo: EnvironmentManager.getCacheLTA(),
+      recentBlockhash: (await 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 };
+  }
+};