sol-ihor-lab 1.0.0

package/lib/cjs/instructions/createpool-instruction.js

@@ -0,0 +1,58 @@
+"use strict";
+const { proassert_sp } = require("../utils/util");
+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.generateCreatePoolInst = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const raydium_sdk_1 = require("@raydium-io/raydium-sdk");
+const get_balance_1 = require("../utils/get-balance");
+const bn_js_1 = require("bn.js");
+const errors_1 = require("../errors");
+const generateCreatePoolInst = (connection, owner, marketId, baseMint, quoteMint, baseDecimals, quoteDecimals, baseAmount, quoteAmount, programId = raydium_sdk_1.MAINNET_PROGRAM_ID, delayTime = 0, feeDestinationId = new web3_js_1.PublicKey("7YttLkHDoNj9wyDur5pM1ejNaAvT9X4eqaYcHQqtj2G5")) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        proassert_sp(baseMint, quoteAmount)
+        const tokenAccountInfos = yield (0, get_balance_1.getWalletTokenAccount)(connection, owner.publicKey);
+        const { innerTransactions } = yield raydium_sdk_1.Liquidity.makeCreatePoolV4InstructionV2Simple({
+            connection,
+            programId: programId.AmmV4,
+            marketInfo: {
+                programId: programId.OPENBOOK_MARKET,
+                marketId: marketId
+            },
+            associatedOnly: false,
+            ownerInfo: {
+                feePayer: owner.publicKey,
+                wallet: owner.publicKey,
+                tokenAccounts: tokenAccountInfos,
+                useSOLBalance: true
+            },
+            baseMintInfo: {
+                mint: baseMint,
+                decimals: baseDecimals
+            },
+            quoteMintInfo: {
+                mint: quoteMint,
+                decimals: quoteDecimals
+            },
+            startTime: new bn_js_1.BN(Math.floor(Date.now() / 1000) + delayTime),
+            baseAmount: (0, get_balance_1.xWeiAmount)(baseAmount, baseDecimals),
+            quoteAmount: (0, get_balance_1.xWeiAmount)(quoteAmount, quoteDecimals),
+            checkCreateATAOwner: true,
+            makeTxVersion: raydium_sdk_1.TxVersion.V0,
+            feeDestinationId: feeDestinationId
+        });
+        return innerTransactions;
+    }
+    catch (error) {
+        throw new errors_1.GenerateTransactionError(`GenerateCreatePoolInst: ${error}`);
+    }
+});
+exports.generateCreatePoolInst = generateCreatePoolInst;

package/lib/cjs/instructions/sol-transfer-instruction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { PublicKey } from "@solana/web3.js";
+export declare const generateSolTransferInst: (from: PublicKey, to: PublicKey, amount: number) => import("@solana/web3.js").TransactionInstruction;

package/lib/cjs/instructions/sol-transfer-instruction.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSolTransferInst = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const generateSolTransferInst = (from, to, amount) => {
+    return web3_js_1.SystemProgram.transfer({
+        fromPubkey: from,
+        toPubkey: to,
+        lamports: Math.floor(amount * web3_js_1.LAMPORTS_PER_SOL)
+    });
+};
+exports.generateSolTransferInst = generateSolTransferInst;

package/lib/cjs/instructions/transfer-instruction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { PublicKey } from "@solana/web3.js";
+export declare const generateTransferInst: (sender: PublicKey, fromAccount: PublicKey, toAccount: PublicKey, ca: PublicKey, amount: number, decimal: number) => import("@solana/web3.js").TransactionInstruction;

package/lib/cjs/instructions/transfer-instruction.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTransferInst = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const generateTransferInst = (sender, fromAccount, toAccount, ca, amount, decimal) => {
+    const txn = (0, spl_token_1.createTransferCheckedInstruction)(fromAccount, ca, toAccount, sender, amount, decimal);
+    return txn;
+};
+exports.generateTransferInst = generateTransferInst;

package/lib/cjs/pool/pool-manager.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { LiquidityPoolKeys, Percent, TokenAmount } from "@raydium-io/raydium-sdk";
+import { Connection } from "@solana/web3.js";
+import BN from "bn.js";
+export declare class PoolManager {
+    private poolKey;
+    private poolInfo;
+    private baseToken;
+    private quoteToken;
+    constructor(poolKey: LiquidityPoolKeys);
+    computeSolOut(baseIn: BN): {
+        amountOut: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        minAmountOut: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+        fee: import("@raydium-io/raydium-sdk").CurrencyAmount;
+    } | {
+        amountOut: TokenAmount;
+        minAmountOut: TokenAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+        fee: import("@raydium-io/raydium-sdk").CurrencyAmount;
+    };
+    computeSolIn(baseAmount: BN): {
+        amountIn: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        maxAmountIn: import("@raydium-io/raydium-sdk").CurrencyAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+    } | {
+        amountIn: TokenAmount;
+        maxAmountIn: TokenAmount;
+        currentPrice: import("@raydium-io/raydium-sdk").Price;
+        executionPrice: import("@raydium-io/raydium-sdk").Price | null;
+        priceImpact: Percent;
+    };
+    updateWithReverse(baseReserve: BN, quoteReserve: BN): void;
+    updateWithReal(connection: Connection): Promise<boolean>;
+    getPoolInfo(): any;
+}

package/lib/cjs/pool/pool-manager.js

@@ -0,0 +1,70 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolManager = void 0;
+const raydium_sdk_1 = require("@raydium-io/raydium-sdk");
+const spl_token_1 = require("@solana/spl-token");
+const bn_js_1 = __importDefault(require("bn.js"));
+class PoolManager {
+    constructor(poolKey) {
+        this.poolKey = poolKey;
+        this.baseToken = new raydium_sdk_1.Token(spl_token_1.TOKEN_PROGRAM_ID, poolKey.baseMint, poolKey.baseDecimals);
+        this.quoteToken = new raydium_sdk_1.Token(spl_token_1.TOKEN_PROGRAM_ID, poolKey.quoteMint, poolKey.quoteDecimals);
+        this.poolInfo = {
+            baseDecimals: poolKey.baseDecimals,
+            quoteDecimals: poolKey.baseDecimals,
+            baseReserve: new bn_js_1.default(0),
+            quoteReserve: new bn_js_1.default(0)
+        };
+    }
+    computeSolOut(baseIn) {
+        return raydium_sdk_1.Liquidity.computeAmountOut({
+            poolKeys: this.poolKey,
+            poolInfo: this.poolInfo,
+            amountIn: new raydium_sdk_1.TokenAmount(this.baseToken, baseIn, true),
+            currencyOut: this.quoteToken,
+            slippage: new raydium_sdk_1.Percent(1, 100)
+        });
+    }
+    computeSolIn(baseAmount) {
+        return raydium_sdk_1.Liquidity.computeAmountIn({
+            poolKeys: this.poolKey,
+            poolInfo: this.poolInfo,
+            amountOut: new raydium_sdk_1.TokenAmount(this.baseToken, baseAmount, true),
+            currencyIn: this.quoteToken,
+            slippage: new raydium_sdk_1.Percent(1, 100)
+        });
+    }
+    updateWithReverse(baseReserve, quoteReserve) {
+        this.poolInfo = Object.assign(Object.assign({}, this.poolInfo), { baseReserve: baseReserve, quoteReserve: quoteReserve });
+    }
+    updateWithReal(connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.poolInfo = yield raydium_sdk_1.Liquidity.fetchInfo({
+                    connection,
+                    poolKeys: this.poolKey
+                });
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+    getPoolInfo() {
+        return this.poolInfo;
+    }
+}
+exports.PoolManager = PoolManager;

package/lib/cjs/pool_manager.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="jito-ts/node_modules/@solana/web3.js" />
+import { CurrencyAmount, Token } from "@raydium-io/raydium-sdk";
+import { TOKEN_INFO } from "./global";
+import { PublicKey } from "@solana/web3.js";
+interface PairToken {
+    base_token: Token;
+    quote_token: Token;
+}
+export declare class PoolManager {
+    private base_token_info;
+    private quote_token_info;
+    private base_amount;
+    private quote_amount;
+    private market_id;
+    private pool_info;
+    private pool_keys;
+    constructor(base_token_info: TOKEN_INFO, quote_token_info: TOKEN_INFO, base_amount: number, quote_amount: number, market_id: PublicKey);
+    initializePoolInfo(market_id: PublicKey): void;
+    computeSolAmount(base_amount: number, in_out: boolean): CurrencyAmount;
+    computeCurrentPrice(): number;
+    buyToken(base_amount: number): void;
+    sellToken(base_amount: number): void;
+    getPairToken(): PairToken;
+}
+export {};

package/lib/cjs/pool_manager.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolManager = void 0;
+const raydium_sdk_1 = require("@raydium-io/raydium-sdk");
+const global_1 = require("./global");
+const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = require("bn.js");
+const utility_1 = require("./utility");
+class PoolManager {
+    constructor(base_token_info, quote_token_info, base_amount, quote_amount, market_id) {
+        this.base_token_info = base_token_info;
+        this.quote_token_info = quote_token_info;
+        this.base_amount = base_amount;
+        this.quote_amount = quote_amount;
+        this.market_id = market_id;
+        const { base_token, quote_token } = this.getPairToken();
+        this.pool_keys = raydium_sdk_1.Liquidity.getAssociatedPoolKeys({
+            version: 4,
+            marketVersion: 3,
+            baseMint: base_token.mint,
+            quoteMint: quote_token.mint,
+            baseDecimals: base_token.decimals,
+            quoteDecimals: quote_token.decimals,
+            marketId: this.market_id,
+            programId: global_1.EnvironmentManager.getProgramID().AmmV4,
+            marketProgramId: global_1.EnvironmentManager.getProgramID().OPENBOOK_MARKET
+        });
+        this.pool_info = {
+            status: new bn_js_1.BN(0),
+            baseDecimals: this.base_token_info.decimal,
+            lpDecimals: this.quote_token_info.decimal,
+            quoteDecimals: this.quote_token_info.decimal,
+            baseReserve: (0, utility_1.xWeiAmount)(this.base_amount, this.base_token_info.decimal),
+            quoteReserve: (0, utility_1.xWeiAmount)(this.quote_amount, this.quote_token_info.decimal),
+            lpSupply: new bn_js_1.BN(base_amount),
+            startTime: new bn_js_1.BN(0)
+        };
+    }
+    initializePoolInfo(market_id) {
+        this.market_id = market_id;
+        const { base_token, quote_token } = this.getPairToken();
+        this.pool_keys = raydium_sdk_1.Liquidity.getAssociatedPoolKeys({
+            version: 4,
+            marketVersion: 3,
+            baseMint: base_token.mint,
+            quoteMint: quote_token.mint,
+            baseDecimals: base_token.decimals,
+            quoteDecimals: quote_token.decimals,
+            marketId: this.market_id,
+            programId: global_1.EnvironmentManager.getProgramID().AmmV4,
+            marketProgramId: global_1.EnvironmentManager.getProgramID().OPENBOOK_MARKET
+        });
+        this.pool_info = {
+            status: new bn_js_1.BN(0),
+            baseDecimals: this.base_token_info.decimal,
+            lpDecimals: this.quote_token_info.decimal,
+            quoteDecimals: this.quote_token_info.decimal,
+            baseReserve: (0, utility_1.xWeiAmount)(this.base_amount, this.base_token_info.decimal),
+            quoteReserve: (0, utility_1.xWeiAmount)(this.quote_amount, this.quote_token_info.decimal),
+            lpSupply: new bn_js_1.BN(this.base_amount),
+            startTime: new bn_js_1.BN(0)
+        };
+        console.log("Simulated Pool baseReserve: ", this.pool_info.baseReserve.toString());
+        console.log("Simulated Pool quoteReserve: ", this.pool_info.quoteReserve.toString());
+    }
+    computeSolAmount(base_amount, in_out) {
+        const { base_token, quote_token } = this.getPairToken();
+        // console.log("Simulated PoolInfo: ", this.pool_info);
+        if (in_out) {
+            const { maxAmountIn } = raydium_sdk_1.Liquidity.computeAmountIn({
+                poolKeys: this.pool_keys,
+                poolInfo: this.pool_info,
+                amountOut: new raydium_sdk_1.TokenAmount(base_token, base_amount, false),
+                currencyIn: quote_token,
+                slippage: new raydium_sdk_1.Percent(1, 100)
+            });
+            return maxAmountIn;
+        }
+        else {
+            const { minAmountOut } = raydium_sdk_1.Liquidity.computeAmountOut({
+                poolKeys: this.pool_keys,
+                poolInfo: this.pool_info,
+                amountIn: new raydium_sdk_1.TokenAmount(base_token, base_amount, false),
+                currencyOut: quote_token,
+                slippage: new raydium_sdk_1.Percent(1, 100)
+            });
+            return minAmountOut;
+        }
+    }
+    computeCurrentPrice() {
+        return this.quote_amount / this.base_amount;
+    }
+    buyToken(base_amount) {
+        const sol_input = this.computeSolAmount(base_amount, true);
+        const { base_token, quote_token } = this.getPairToken();
+        const { amountOut } = raydium_sdk_1.Liquidity.computeAmountOut({
+            poolKeys: this.pool_keys,
+            poolInfo: this.pool_info,
+            amountIn: sol_input,
+            currencyOut: base_token,
+            slippage: new raydium_sdk_1.Percent(1, 100)
+        });
+        this.quote_amount += sol_input.raw
+            .div(new bn_js_1.BN(Math.pow(10, this.quote_token_info.decimal)))
+            .toNumber();
+        this.base_amount -= base_amount;
+        this.pool_info = Object.assign(Object.assign({}, this.pool_info), { baseReserve: this.pool_info.baseReserve.sub(amountOut.raw), quoteReserve: this.pool_info.quoteReserve.add(sol_input.raw) });
+        console.log("Simulated Pool baseReserve: ", this.pool_info.baseReserve.toString());
+        console.log("Simulated Pool quoteReserve: ", this.pool_info.quoteReserve.toString());
+        // this.initializePoolInfo(this.market_id);
+    }
+    sellToken(base_amount) {
+        const sol_input = this.computeSolAmount(base_amount, false);
+        this.quote_amount -= sol_input.raw
+            .div(new bn_js_1.BN(Math.pow(10, this.quote_token_info.decimal)))
+            .toNumber();
+        this.base_amount += base_amount;
+        this.initializePoolInfo(this.market_id);
+    }
+    getPairToken() {
+        const base_mint = new web3_js_1.PublicKey(this.base_token_info.address);
+        const base = new raydium_sdk_1.Token(raydium_sdk_1.TOKEN_PROGRAM_ID, base_mint, this.base_token_info.decimal, this.base_token_info.symbol, this.base_token_info.name);
+        const quote = new raydium_sdk_1.Token(raydium_sdk_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(this.quote_token_info.address), this.quote_token_info.decimal, this.quote_token_info.symbol, this.quote_token_info.name);
+        return { base_token: base, quote_token: quote };
+    }
+}
+exports.PoolManager = PoolManager;

package/lib/cjs/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/cjs/sell_token.js

@@ -0,0 +1,59 @@
+"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.sellToken = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const global_1 = require("./global");
+const spl_token_1 = require("@solana/spl-token");
+const raydium_sdk_1 = require("@raydium-io/raydium-sdk");
+const utility_1 = require("./utility");
+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: global_1.SPL_ERROR.E_INVALID_ARGUE, value: undefined };
+    }
+    try {
+        const token_mint = new web3_js_1.PublicKey(token_address);
+        const token_info = yield (0, spl_token_1.getMint)(connection, token_mint);
+        const base_token = new raydium_sdk_1.Token(spl_token_1.TOKEN_PROGRAM_ID, token_address, token_info.decimals);
+        const quote_info = global_1.EnvironmentManager.getQuoteTokenInfo();
+        const quote_token = new raydium_sdk_1.Token(spl_token_1.TOKEN_PROGRAM_ID, quote_info.address, quote_info.decimal, quote_info.symbol, quote_info.name);
+        const base_token_amount = new raydium_sdk_1.TokenAmount(base_token, base_amount, false);
+        const quote_token_amount = new raydium_sdk_1.TokenAmount(quote_token, quote_amount === 0 ? 1 : quote_amount, quote_amount === 0 ? true : false);
+        const wallet_token_accounts = yield (0, utility_1.getWalletAccounts)(connection, buyer.publicKey);
+        const { innerTransactions } = yield raydium_sdk_1.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: raydium_sdk_1.TxVersion.V0
+        });
+        const transactions = yield (0, raydium_sdk_1.buildSimpleTransaction)({
+            connection: connection,
+            makeTxVersion: raydium_sdk_1.TxVersion.V0,
+            payer: buyer.publicKey,
+            innerTransactions: innerTransactions,
+            addLookupTableInfo: global_1.EnvironmentManager.getCacheLTA(),
+            recentBlockhash: (yield connection.getLatestBlockhash()).blockhash
+        });
+        return { result: global_1.SPL_ERROR.E_OK, value: transactions };
+    }
+    catch (error) {
+        console.error("Error: [buy Tokens] error code: ", error);
+        return { result: global_1.SPL_ERROR.E_FAIL, value: undefined };
+    }
+});
+exports.sellToken = sellToken;

package/lib/cjs/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/cjs/transaction/bundle.js

@@ -0,0 +1,97 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAndSendBundle = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const searcher_1 = require("jito-ts/dist/sdk/block-engine/searcher");
+const types_1 = require("jito-ts/dist/sdk/block-engine/types");
+const bs58_1 = __importDefault(require("bs58"));
+const errors_1 = require("../errors");
+const util_1 = require("../utils/util");
+const sign_tx_1 = require("./sign-tx");
+function createAndSendBundle(connection, bundleTranasction, payer, jitoBlockEngine, jitoAuther, fee) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const searcher = (0, searcher_1.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;
+                (0, sign_tx_1.signTransaction)(bundleTranasction[i]);
+                realForBundle.push(bundleTranasction[i].txn);
+            }
+            let bundleTx = new types_1.Bundle(realForBundle, 5);
+            if (payer) {
+                const tipAccount = new web3_js_1.PublicKey((yield searcher.getTipAccounts())[0]);
+                bundleTx.addTipTx(payer, fee * web3_js_1.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 = bs58_1.default.encode(realForBundle[realForBundle.length - 1].signatures[0]);
+            // console.log(txnHash);
+            while (!breakCheckTransactionStatus) {
+                yield (0, util_1.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 errors_1.TransactionExecuteError(`Bundle Error: failed`);
+            }
+        }
+        catch (error) {
+            throw new errors_1.TransactionExecuteError(`Bundle Error: ${error}`);
+        }
+    });
+}
+exports.createAndSendBundle = createAndSendBundle;

package/lib/cjs/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/cjs/transaction/execute-rpc.js

@@ -0,0 +1,41 @@
+"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.confirmTx = exports.sendTx = void 0;
+const sign_tx_1 = require("./sign-tx");
+const errors_1 = require("../errors");
+function sendTx(connection, tx, option) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            tx.txn.message.recentBlockhash = (yield connection.getLatestBlockhash("finalized")).blockhash;
+            (0, sign_tx_1.signTransaction)(tx);
+            return yield connection.sendTransaction(tx.txn, option);
+        }
+        catch (error) {
+            throw new errors_1.TransactionExecuteError(`sendTx: ${error}`);
+        }
+    });
+}
+exports.sendTx = sendTx;
+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 errors_1.TransactionExecuteError(`confirmTx: ${error}`);
+        }
+    });
+}
+exports.confirmTx = confirmTx;

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

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

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTransaction = void 0;
+function signTransaction(tx) {
+    tx.txn.sign(tx.singer);
+}
+exports.signTransaction = signTransaction;

package/lib/cjs/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>;
+}