@clonegod/ttd-sol-common 1.2.1 → 2.0.1

package/dist/helius_sdk_v1.4.0/RpcClient.js

@@ -1,978 +0,0 @@
-"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.RpcClient = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const bs58_1 = __importDefault(require("bs58"));
-const axios_1 = __importDefault(require("axios"));
-const types_1 = require("./types");
-const get_signature_1 = require("../send_tx/get_signature");
-const dist_1 = require("@clonegod/ttd-core/dist");
-const common_1 = require("../common");
-const jito_1 = require("../jito");
-const jitodontfront_1 = require("../jito/jitodontfront");
-class RpcClient {
-    constructor(connection, id) {
-        this.connection = connection;
-        this.id = id;
-        this.jitoClient = new jito_1.JitoJsonRpcClient('https://mainnet.block-engine.jito.wtf/api/v1', undefined);
-    }
-    airdrop(publicKey, lamports, commitment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const signature = yield this.connection.requestAirdrop(publicKey, lamports);
-            const blockhashWithExpiryBlockHeight = yield this.getLatestBlockhash();
-            const confirmResponse = yield this.connection.confirmTransaction(Object.assign({ signature }, blockhashWithExpiryBlockHeight), commitment);
-            return Object.assign({ signature, confirmResponse }, blockhashWithExpiryBlockHeight);
-        });
-    }
-    getLatestBlockhash() {
-        return __awaiter(this, arguments, void 0, function* (commitmentOrConfig = 'finalized') {
-            return this.connection.getLatestBlockhash(commitmentOrConfig);
-        });
-    }
-    getCurrentTPS() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            try {
-                const samples = yield this.connection.getRecentPerformanceSamples(1);
-                return ((_a = samples[0]) === null || _a === void 0 ? void 0 : _a.numTransactions) / ((_b = samples[0]) === null || _b === void 0 ? void 0 : _b.samplePeriodSecs);
-            }
-            catch (e) {
-                throw new Error(`error calling getCurrentTPS: ${e}`);
-            }
-        });
-    }
-    getStakeAccounts(wallet) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return this.connection.getParsedProgramAccounts(new web3_js_1.PublicKey('Stake11111111111111111111111111111111111111'), {
-                    filters: [
-                        {
-                            dataSize: 200,
-                        },
-                        {
-                            memcmp: {
-                                offset: 44,
-                                bytes: wallet,
-                            },
-                        },
-                    ],
-                });
-            }
-            catch (e) {
-                throw new Error(`error calling getStakeAccounts: ${e}`);
-            }
-        });
-    }
-    getTokenHolders(mintAddress) {
-        try {
-            return this.connection.getParsedProgramAccounts(new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'), {
-                filters: [
-                    {
-                        dataSize: 165,
-                    },
-                    {
-                        memcmp: {
-                            offset: 0,
-                            bytes: mintAddress,
-                        },
-                    },
-                ],
-            });
-        }
-        catch (e) {
-            throw new Error(`error calling getTokenHolders: ${e}`);
-        }
-    }
-    getAsset(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getAsset',
-                    params,
-                }, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                });
-                const { result } = response.data;
-                return result;
-            }
-            catch (error) {
-                throw new Error(`Error in getAsset: ${error}`);
-            }
-        });
-    }
-    getRwaAsset(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getRwaAccountsByMint',
-                    params,
-                }, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                });
-                const { result } = response.data;
-                return result;
-            }
-            catch (error) {
-                throw new Error(`Error in getRwaAsset: ${error}`);
-            }
-        });
-    }
-    getAssetBatch(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getAssetBatch',
-                    params,
-                });
-                return response.data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getAssetBatch: ${error}`);
-            }
-        });
-    }
-    getAssetProof(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getAssetProof',
-                    params,
-                });
-                const { data } = response;
-                return data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getAssetProof: ${error}`);
-            }
-        });
-    }
-    getAssetsByGroup(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getAssetsByGroup',
-                    params,
-                });
-                const { data } = response;
-                return data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getAssetsByGroup: ${error}`);
-            }
-        });
-    }
-    getAssetsByOwner(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getAssetsByOwner',
-                    params,
-                });
-                const { data } = response;
-                return data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getAssetsByOwner: ${error}`);
-            }
-        });
-    }
-    getAssetsByCreator(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getAssetsByCreator',
-                    params,
-                });
-                const { data } = response;
-                return data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getAssetsByCreator: ${error}`);
-            }
-        });
-    }
-    getAssetsByAuthority(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getAssetsByAuthority',
-                    params,
-                });
-                const { data } = response;
-                return data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getAssetsByAuthority: ${error}`);
-            }
-        });
-    }
-    searchAssets(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'searchAssets',
-                    params,
-                });
-                const { data } = response;
-                return data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in searchAssets: ${error}`);
-            }
-        });
-    }
-    getSignaturesForAsset(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getSignaturesForAsset',
-                    params,
-                });
-                const { data } = response;
-                return data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getSignaturesForAsset: ${error}`);
-            }
-        });
-    }
-    getPriorityFeeEstimate(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getPriorityFeeEstimate',
-                    params: [params],
-                }, {
-                    headers: { 'Content-Type': 'application/json' },
-                });
-                if (response.data.error) {
-                    throw new Error(`Error fetching priority fee estimate: ${JSON.stringify(response.data.error, null, 2)}`);
-                }
-                return response.data.result;
-            }
-            catch (error) {
-                if (axios_1.default.isAxiosError(error) && error.response) {
-                    throw new Error(`Error fetching priority fee estimate: ${JSON.stringify(error.response.data, null, 2)}`);
-                }
-                throw new Error(`Error fetching priority fee estimate: ${error}`);
-            }
-        });
-    }
-    getComputeUnits(instructions, payer, lookupTables, signers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const testInstructions = [
-                web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 1400000 }),
-                ...instructions,
-            ];
-            const testTransaction = new web3_js_1.VersionedTransaction(new web3_js_1.TransactionMessage({
-                instructions: testInstructions,
-                payerKey: payer,
-                recentBlockhash: (yield this.connection.getLatestBlockhash()).blockhash,
-            }).compileToV0Message(lookupTables));
-            if (signers) {
-                testTransaction.sign(signers);
-            }
-            const rpcResponse = yield this.connection.simulateTransaction(testTransaction, {
-                sigVerify: !!signers,
-            });
-            if (rpcResponse.value.err) {
-                console.error(`Simulation error: ${JSON.stringify(rpcResponse.value.err, null, 2)}`);
-                return null;
-            }
-            return rpcResponse.value.unitsConsumed || null;
-        });
-    }
-    pollTransactionConfirmation(txtSig_1) {
-        return __awaiter(this, arguments, void 0, function* (txtSig, pollOptions = {
-            confirmationStatuses: ["confirmed", "finalized"],
-            timeout: 15000,
-            interval: 5000
-        }) {
-            let elapsed = 0;
-            return new Promise((resolve, reject) => {
-                const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b, _c;
-                    elapsed += pollOptions.interval;
-                    if (elapsed >= pollOptions.timeout) {
-                        clearInterval(intervalId);
-                        reject(new Error(`Transaction ${txtSig}'s confirmation timed out`));
-                    }
-                    const status = yield this.connection.getSignatureStatus(txtSig);
-                    if (((_a = status === null || status === void 0 ? void 0 : status.value) === null || _a === void 0 ? void 0 : _a.confirmationStatus) && ((_b = pollOptions.confirmationStatuses) === null || _b === void 0 ? void 0 : _b.includes((_c = status === null || status === void 0 ? void 0 : status.value) === null || _c === void 0 ? void 0 : _c.confirmationStatus))) {
-                        clearInterval(intervalId);
-                        resolve(txtSig);
-                    }
-                }), pollOptions.interval);
-            });
-        });
-    }
-    createSmartTransaction(solana_trade_runtime_1, instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], feePayer, serializeOptions = {
-            requireAllSignatures: true,
-            verifySignatures: true,
-        }) {
-            if (!signers.length) {
-                throw new Error('The transaction must have at least one signer');
-            }
-            const existingComputeBudgetInstructions = instructions.filter((instruction) => instruction.programId.equals(web3_js_1.ComputeBudgetProgram.programId));
-            if (existingComputeBudgetInstructions.length > 0) {
-                throw new Error('Cannot provide instructions that set the compute unit price and/or limit');
-            }
-            (0, dist_1.log_info)(`>>> getLatestBlockhashAndContext, start`);
-            const payerKey = feePayer ? feePayer.publicKey : signers[0].publicKey;
-            let { context: { slot: minContextSlot }, value: blockhash, } = yield this.get_last_blockhash_slot([solana_trade_runtime.connection, this.connection]);
-            let block_offset = solana_trade_runtime.settings.strategy.block_offset;
-            if (!isNaN(block_offset) && block_offset > 0) {
-                let blockhash_by_slot_offset = yield this.getBlockhashBySlotOffset(block_offset);
-                (0, dist_1.log_info)(`>>> getBlockhashBySlotOffset`, {
-                    block_offset,
-                    pre: {
-                        minContextSlot,
-                        blockhash,
-                    },
-                    new: {
-                        minContextSlot: blockhash_by_slot_offset.context.slot,
-                        blockhash: blockhash_by_slot_offset.value.blockhash,
-                    }
-                });
-                blockhash = blockhash_by_slot_offset.value;
-                minContextSlot = blockhash_by_slot_offset.context.slot;
-            }
-            (0, dist_1.log_info)(`>>> getLatestBlockhashAndContext, end`);
-            const recentBlockhash = blockhash.blockhash;
-            const isVersioned = lookupTables.length > 0;
-            let legacyTransaction = null;
-            let versionedTransaction = null;
-            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                if (Math.random() > -1)
-                    return;
-                if (isVersioned) {
-                    const v0Message = new web3_js_1.TransactionMessage({
-                        instructions,
-                        payerKey,
-                        recentBlockhash,
-                    }).compileToV0Message(lookupTables);
-                    versionedTransaction = new web3_js_1.VersionedTransaction(v0Message);
-                    const allSigners = feePayer ? [...signers, feePayer] : signers;
-                    versionedTransaction.sign(allSigners);
-                }
-                else {
-                    legacyTransaction = new web3_js_1.Transaction().add(...instructions);
-                    legacyTransaction.recentBlockhash = recentBlockhash;
-                    legacyTransaction.feePayer = payerKey;
-                    for (const signer of signers) {
-                        legacyTransaction.partialSign(signer);
-                    }
-                    if (feePayer) {
-                        legacyTransaction.partialSign(feePayer);
-                    }
-                }
-                const serializedTransaction = bs58_1.default.encode(isVersioned
-                    ? versionedTransaction.serialize()
-                    : legacyTransaction.serialize(serializeOptions));
-                (0, dist_1.log_info)(`>>> getPriorityFeeEstimate, start`);
-                const priorityFeeEstimateResponse = yield this.getPriorityFeeEstimate({
-                    transaction: serializedTransaction,
-                    options: {
-                        recommended: true,
-                    },
-                });
-                const { priorityFeeEstimate } = priorityFeeEstimateResponse;
-                (0, dist_1.log_info)(`>>> getPriorityFeeEstimate, end. priorityFeeEstimate=${priorityFeeEstimate}`);
-                if (!priorityFeeEstimate) {
-                    throw new Error('Priority fee estimate not available');
-                }
-            }), 0);
-            let priorityFeeEstimate = solana_trade_runtime.cu_price;
-            if (solana_trade_runtime.settings.strategy.broadcast_type === 'jito') {
-                priorityFeeEstimate = 1;
-            }
-            const computeBudgetIx = web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-                microLamports: priorityFeeEstimate,
-            });
-            instructions.unshift(computeBudgetIx);
-            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                if (Math.random() > -1)
-                    return;
-                (0, dist_1.log_info)(`>>> getComputeUnits, start`);
-                const units = yield this.getComputeUnits(instructions, payerKey, isVersioned ? lookupTables : [], signers);
-                (0, dist_1.log_info)(`>>> getComputeUnits, end. ComputeUnits=${units}`);
-                if (!units) {
-                    throw new Error(`Error fetching compute units for the instructions provided`);
-                }
-            }), 0);
-            const customersCU = Math.ceil(solana_trade_runtime.cu_limit);
-            const jitodontfrontPubkey = process.env.JITODONTFRONT_PUBKEY || 'jitodontfront111111111111111111111111111111';
-            const computeUnitsIx = (0, jitodontfront_1.createCustomComputeBudgetInstructionWithJitoDontFront)(new web3_js_1.PublicKey(jitodontfrontPubkey), customersCU);
-            instructions.unshift(computeUnitsIx);
-            if (isVersioned) {
-                const v0Message = new web3_js_1.TransactionMessage({
-                    instructions,
-                    payerKey,
-                    recentBlockhash,
-                }).compileToV0Message(lookupTables);
-                versionedTransaction = new web3_js_1.VersionedTransaction(v0Message);
-                const allSigners = feePayer ? [...signers, feePayer] : signers;
-                versionedTransaction.sign(allSigners);
-                return {
-                    transaction: versionedTransaction,
-                    blockhash,
-                    minContextSlot,
-                };
-            }
-            legacyTransaction = new web3_js_1.Transaction().add(...instructions);
-            legacyTransaction.recentBlockhash = recentBlockhash;
-            legacyTransaction.feePayer = payerKey;
-            legacyTransaction.sign(signers[0]);
-            return {
-                transaction: legacyTransaction,
-                blockhash,
-                minContextSlot,
-            };
-        });
-    }
-    sendSmartTransaction(solana_trade_runtime_1, instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], sendOptions = { skipPreflight: false, lastValidBlockHeightOffset: 150 }) {
-            var _a;
-            const lastValidBlockHeightOffset = (_a = sendOptions.lastValidBlockHeightOffset) !== null && _a !== void 0 ? _a : 150;
-            if (lastValidBlockHeightOffset < 0)
-                throw new Error('expiryBlockOffset must be a positive integer');
-            try {
-                const { transaction, blockhash, minContextSlot } = yield this.createSmartTransaction(solana_trade_runtime, instructions, signers, lookupTables, sendOptions.feePayer);
-                (0, dist_1.log_info)(`>>> createSmartTransaction, end`);
-                let txid = (0, get_signature_1.getSignature)(transaction);
-                yield this.connection.sendRawTransaction(transaction.serialize({ verifySignatures: false }), {
-                    maxRetries: 3,
-                    skipPreflight: true
-                });
-                return txid;
-            }
-            catch (error) {
-                throw new Error(`Error sending smart transaction: ${error}`);
-            }
-        });
-    }
-    addTipInstruction(instructions, feePayer, tipAccount, tipAmount) {
-        const tipInstruction = web3_js_1.SystemProgram.transfer({
-            fromPubkey: feePayer,
-            toPubkey: new web3_js_1.PublicKey(tipAccount),
-            lamports: tipAmount,
-        });
-        instructions.push(tipInstruction);
-    }
-    getTipTransaction(singers, tipAccount, tipAmount, blockhash) {
-        const feePayer = singers[0];
-        const tipInstruction = web3_js_1.SystemProgram.transfer({
-            fromPubkey: feePayer.publicKey,
-            toPubkey: new web3_js_1.PublicKey(tipAccount),
-            lamports: tipAmount,
-        });
-        const transaction = new web3_js_1.Transaction().add(tipInstruction);
-        transaction.recentBlockhash = blockhash;
-        transaction.feePayer = feePayer.publicKey;
-        transaction.sign(feePayer);
-        return transaction;
-    }
-    createSmartTransactionWithTip(solana_trade_runtime_1, instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], tipAmount = 1000, feePayer) {
-            if (!signers.length) {
-                throw new Error('The transaction must have at least one signer');
-            }
-            if (!solana_trade_runtime.jito_use_separate_tx) {
-                const randomTipAccount = types_1.JITO_TIP_ACCOUNTS[Math.floor(Math.random() * types_1.JITO_TIP_ACCOUNTS.length)];
-                const payerKey = feePayer ? feePayer.publicKey : signers[0].publicKey;
-                this.addTipInstruction(instructions, payerKey, randomTipAccount, tipAmount);
-            }
-            return this.createSmartTransaction(solana_trade_runtime, instructions, signers, lookupTables, feePayer);
-        });
-    }
-    sendJitoBundle(serializedTransactions, encoding, jitoApiUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.post(jitoApiUrl, {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'sendBundle',
-                params: [
-                    serializedTransactions,
-                    {
-                        "encoding": encoding
-                    }
-                ]
-            }, {
-                headers: { 'Content-Type': 'application/json' },
-            });
-            if (response.data.error) {
-                throw new Error(`Error sending bundles: ${JSON.stringify(response.data.error, null, 2)}`);
-            }
-            return response.data.result;
-        });
-    }
-    getBundleStatuses(bundleIds, jitoApiUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!bundleIds || bundleIds.length == 0 || bundleIds[0] == null) {
-                return;
-            }
-            const response = yield axios_1.default.post(jitoApiUrl, {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'getBundleStatuses',
-                params: [bundleIds],
-            }, {
-                headers: { 'Content-Type': 'application/json' },
-            });
-            if (response.data.error) {
-                (0, dist_1.log_warn)(`getBundleStatuses error!`, {
-                    jitoApiUrl,
-                    bundleIds,
-                });
-                throw new Error(`Error getting bundle statuses: ${JSON.stringify(response.data.error, null, 2)}`);
-            }
-            return response.data.result;
-        });
-    }
-    sendSmartTransactionWithTip(solana_trade_runtime_1, instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], tipAmount = 1000, region = 'Default', feePayer, lastValidBlockHeightOffset = 150) {
-            if (lastValidBlockHeightOffset < 0)
-                throw new Error('lastValidBlockHeightOffset must be a positive integer');
-            if (!signers.length) {
-                throw new Error('The transaction must have at least one signer');
-            }
-            const { transaction, blockhash } = yield this.createSmartTransactionWithTip(solana_trade_runtime, instructions, signers, lookupTables, tipAmount, feePayer);
-            let txid = (0, get_signature_1.getSignature)(transaction);
-            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                const encoding = 'base64';
-                const serializedMainTx = transaction.serialize({ verifySignatures: false }).toString(encoding);
-                let jito_region = process.env.JITO_REGION || region;
-                let jitoApiUrl = `${types_1.JITO_API_URLS[jito_region]}/api/v1/bundles`;
-                const send_tx_jito_url = process.env.SEND_TX_JITO_URL || '';
-                const send_tx_jito_stratgy = process.env.SEND_TX_JITO_STRATEGY || '';
-                if (!(0, dist_1.isEmpty)(send_tx_jito_url) && send_tx_jito_stratgy === 'mul_ips') {
-                    let { jito_use_separate_tx } = solana_trade_runtime;
-                    let group_id = solana_trade_runtime.group.id;
-                    let recent_blockhash = blockhash.blockhash;
-                    let encoded_tx = serializedMainTx;
-                    if (jito_use_separate_tx) {
-                        let serializedTipTx = (yield axios_1.default.get(`${process.env.JITO_CREATE_TIP_TX_URL}?group_id=${group_id}&blockhash=${recent_blockhash}&encoding=${encoding}&tip_amount=${tipAmount}`)).data.data;
-                        encoded_tx = [
-                            serializedMainTx,
-                            serializedTipTx
-                        ].join(',');
-                    }
-                    const max_retry = Number(process.env.JITO_MAX_RETRIES || '10');
-                    this.redirectTransactionToExternalServers(txid, encoded_tx, encoding, group_id, max_retry);
-                    const send_result = yield (0, dist_1.postJSON)(send_tx_jito_url, {
-                        encoding,
-                        encoded_tx,
-                        txid,
-                        trace_id: '',
-                        group_id,
-                        max_retry
-                    });
-                    (0, dist_1.log_info)(`sendJitoBundle (mul_ips)`, {
-                        txid,
-                        jito_use_separate_tx,
-                        max_retry,
-                        send_result
-                    });
-                    return;
-                }
-                let bundleId = yield this.sendJitoBundle([serializedMainTx], encoding, jitoApiUrl);
-                (0, dist_1.log_info)(`sendJitoBundle`, {
-                    txid,
-                    jitoApiUrl,
-                    encoding,
-                    bundleId
-                });
-            }), 0);
-            return txid;
-        });
-    }
-    send_jup_ag_tx_by_jito(solana_trade_runtime_1, transaction_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, transaction, signers, tipAmount = 1000, region = 'Default') {
-            let txid = (0, get_signature_1.getSignature)(transaction);
-            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                let block_offset = solana_trade_runtime.settings.strategy.block_offset;
-                if (isNaN(block_offset) || block_offset < 0) {
-                    throw new Error('block_offset must be a positive integer');
-                }
-                let blockhash_by_slot_offset = yield this.getBlockhashBySlotOffset(block_offset);
-                let blockhash = blockhash_by_slot_offset.value.blockhash;
-                const encoding = 'base64';
-                const serializedMainTx = Buffer.from(transaction.serialize()).toString(encoding);
-                let jito_region = process.env.JITO_REGION || region;
-                let jitoApiUrl = `${types_1.JITO_API_URLS[jito_region]}/api/v1/bundles`;
-                const send_tx_jito_url = process.env.SEND_TX_JITO_URL || '';
-                const send_tx_jito_stratgy = process.env.SEND_TX_JITO_STRATEGY || '';
-                let serializedTipTx = '';
-                if (!(0, dist_1.isEmpty)(send_tx_jito_url) && send_tx_jito_stratgy === 'mul_ips') {
-                    let { jito_use_separate_tx } = solana_trade_runtime;
-                    let group_id = solana_trade_runtime.group.id;
-                    let recent_blockhash = blockhash;
-                    let encoded_tx = serializedMainTx;
-                    if (jito_use_separate_tx) {
-                        serializedTipTx = (yield axios_1.default.get(`${process.env.JITO_CREATE_TIP_TX_URL}?group_id=${group_id}&blockhash=${recent_blockhash}&encoding=${encoding}&tip_amount=${tipAmount}`)).data.data;
-                    }
-                    else {
-                        serializedTipTx = yield this.getSerializedTipTransaction(signers, tipAmount, blockhash, encoding);
-                    }
-                    encoded_tx = [
-                        serializedTipTx,
-                        serializedMainTx
-                    ].join(',');
-                    const max_retry = Number(process.env.JITO_MAX_RETRIES || '2');
-                    this.redirectTransactionToExternalServers(txid, encoded_tx, encoding, group_id, max_retry);
-                    const send_result = yield (0, dist_1.postJSON)(send_tx_jito_url, {
-                        encoding,
-                        encoded_tx,
-                        txid,
-                        trace_id: '',
-                        group_id,
-                        max_retry
-                    });
-                    (0, dist_1.log_info)(`sendJitoBundle (mul_ips)`, {
-                        txid,
-                        jito_use_separate_tx,
-                        max_retry,
-                        send_result
-                    });
-                    return;
-                }
-                serializedTipTx = yield this.getSerializedTipTransaction(signers, tipAmount, blockhash, encoding);
-                let bundleId = yield this.sendJitoBundle([serializedMainTx, serializedTipTx], encoding, jitoApiUrl);
-                (0, dist_1.log_info)(`sendJitoBundle`, {
-                    txid,
-                    jitoApiUrl,
-                    encoding,
-                    bundleId
-                });
-            }), 0);
-            return txid;
-        });
-    }
-    getSerializedTipTransaction(signers_1, tipAmount_1, blockhash_1) {
-        return __awaiter(this, arguments, void 0, function* (signers, tipAmount, blockhash, encoding = 'base64') {
-            const randomTipAccount = types_1.JITO_TIP_ACCOUNTS[Math.floor(Math.random() * types_1.JITO_TIP_ACCOUNTS.length)];
-            let tipTransaction = this.getTipTransaction(signers, randomTipAccount, tipAmount, blockhash);
-            return tipTransaction.serialize({ verifySignatures: false }).toString(encoding);
-        });
-    }
-    redirectTransactionToExternalServers(txid, encoded_tx, encoding, group_id, max_retry) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const jito_send_tx_ext_srv_list = process.env.JITO_SEND_TX_EXT_SRV_LIST || '';
-            if ((0, dist_1.isEmpty)(jito_send_tx_ext_srv_list)) {
-                (0, dist_1.log_info)(`jito_send_tx_ext_srv_list is empty, process.env.JITO_SEND_TX_EXT_SRV_LIST=${jito_send_tx_ext_srv_list}`);
-                return;
-            }
-            const regionGroups = jito_send_tx_ext_srv_list.split(';').filter(Boolean);
-            regionGroups.forEach((region_group) => __awaiter(this, void 0, void 0, function* () {
-                const hosts = region_group.split(',');
-                const host = hosts[(0, dist_1.generateRandomNumber)(0, hosts.length - 1)];
-                const url = `http://${host}/solana/send_tx`;
-                (0, dist_1.postJSON)(url, {
-                    encoding,
-                    encoded_tx,
-                    txid,
-                    trace_id: '',
-                    group_id,
-                    max_retry
-                }).then(res => {
-                    (0, dist_1.log_info)(`redirect tx ${txid} to ${url} success`, res);
-                }).catch(err => {
-                    (0, dist_1.log_warn)(`redirect tx ${txid} to ${url} failed`, err.message);
-                });
-            }));
-        });
-    }
-    getNftEditions(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getNftEditions',
-                    params,
-                }, {
-                    headers: { 'Content-Type': 'application/json' },
-                });
-                return response.data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getNftEditions: ${error}`);
-            }
-        });
-    }
-    getTokenAccounts(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'getTokenAccounts',
-                    params,
-                }, {
-                    headers: { 'Content-Type': 'application/json' },
-                });
-                return response.data.result;
-            }
-            catch (error) {
-                throw new Error(`Error in getTokenAccounts: ${error}`);
-            }
-        });
-    }
-    sendTransaction(transaction_1) {
-        return __awaiter(this, arguments, void 0, function* (transaction, options = {
-            skipPreflight: true,
-        }) {
-            let rawTransaction;
-            if (transaction instanceof web3_js_1.VersionedTransaction) {
-                rawTransaction = Buffer.from(transaction.serialize()).toString('base64');
-            }
-            else {
-                rawTransaction = transaction.serialize({ verifySignatures: false }).toString('base64');
-            }
-            try {
-                const url = `${this.connection.rpcEndpoint}`;
-                const response = yield axios_1.default.post(url, {
-                    jsonrpc: '2.0',
-                    id: this.id,
-                    method: 'sendTransaction',
-                    params: [rawTransaction, Object.assign({ encoding: 'base64' }, options)],
-                }, {
-                    headers: { 'Content-Type': 'application/json' },
-                });
-                if (response.data.error) {
-                    throw new Error(`RPC error: ${JSON.stringify(response.data.error)}`);
-                }
-                let txid = response.data.result;
-                (0, dist_1.log_info)(`sendTransaction`, {
-                    url,
-                    txid
-                });
-                return txid;
-            }
-            catch (error) {
-                throw new Error(`Error sending transaction: ${error}`);
-            }
-        });
-    }
-    sendSmartTransactionWithTipMixed(solana_trade_runtime_1, instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], tipAmount = 1000, region = 'Default', feePayer, lastValidBlockHeightOffset = 150) {
-            if (lastValidBlockHeightOffset < 0)
-                throw new Error('lastValidBlockHeightOffset must be a positive integer');
-            if (!signers.length) {
-                throw new Error('The transaction must have at least one signer');
-            }
-            const { transaction, blockhash } = yield this.createSmartTransactionWithTip(solana_trade_runtime, instructions, signers, lookupTables, tipAmount, feePayer);
-            let txid = (0, get_signature_1.getSignature)(transaction);
-            setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                const serializedTransaction = bs58_1.default.encode(transaction.serialize({ verifySignatures: false }));
-                let jitoApiUrl = `${types_1.JITO_API_URLS[region]}/api/v1/bundles`;
-                (0, dist_1.log_info)('sendSmartTransactionWithTipMixed, start');
-                this.sendTransaction(transaction);
-                this.sendJitoTransaction(serializedTransaction, `${types_1.JITO_API_URLS['Default']}/api/v1/transactions?bundleOnly=true`);
-                const bundleId = yield this.sendJitoTransaction(serializedTransaction, `${types_1.JITO_API_URLS['Default']}/api/v1/transactions?bundleOnly=true`);
-                (0, dist_1.log_info)(`sendJitoTransaction`, {
-                    txid,
-                    bundleId
-                });
-            }), 0);
-            return txid;
-        });
-    }
-    sendJitoTransaction(serializedTransaction_1, jitoApiUrl_1) {
-        return __awaiter(this, arguments, void 0, function* (serializedTransaction, jitoApiUrl, encoding = 'base58') {
-            let start = Date.now();
-            let params;
-            if (encoding === 'base58') {
-                params = [serializedTransaction];
-            }
-            else if (encoding === 'base64') {
-                params = [serializedTransaction, { encoding }];
-            }
-            else {
-                throw new Error('Invalid encoding type:' + encoding);
-            }
-            const response = yield axios_1.default.post(jitoApiUrl, {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'sendTransaction',
-                params,
-            }, {
-                headers: { 'Content-Type': 'application/json' },
-            });
-            if (response.data.error) {
-                throw new Error(`Error sending bundles: ${JSON.stringify(response.data.error, null, 2)}`);
-            }
-            let bundleId = response.headers['x-bundle-id'];
-            (0, dist_1.log_info)('sendJitoTransaction finish', {
-                jitoApiUrl,
-                encoding,
-                bundleId,
-                take: (Date.now() - start) + 'ms'
-            });
-            return bundleId;
-        });
-    }
-    get_last_blockhash_slot(connections) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let last_blockhash_slot;
-            try {
-                let appConfig = global.appConfig;
-                let { key, value } = yield appConfig.arb_cache.loading_cache.get(dist_1.CHAIN_ID.SOLANA, 'b', 'slot', true);
-                let { context_slot, blockhash, blockHeight } = JSON.parse(value);
-                last_blockhash_slot = {
-                    context: {
-                        slot: context_slot
-                    },
-                    value: {
-                        blockhash,
-                        lastValidBlockHeight: blockHeight
-                    }
-                };
-            }
-            catch (err) {
-                (0, dist_1.log_error)('get_last_blockhash_slot, from redis', err);
-            }
-            if (!last_blockhash_slot) {
-                for (let c of connections) {
-                    try {
-                        (0, dist_1.log_info)(`get_last_blockhash_slot, rpc_endpoint=${c.rpcEndpoint}`);
-                        last_blockhash_slot = yield c.getLatestBlockhashAndContext();
-                        break;
-                    }
-                    catch (err) {
-                        (0, dist_1.log_error)('get_last_blockhash_slot, fetch by connection', err);
-                    }
-                }
-            }
-            return last_blockhash_slot;
-        });
-    }
-    getBlockhashBySlotOffset() {
-        return __awaiter(this, arguments, void 0, function* (targetSlotOffset = 145, limit = 1) {
-            let appConfig = global.appConfig;
-            let { key, blocks } = yield appConfig.arb_cache.loading_cache.get_block_info(dist_1.CHAIN_ID.SOLANA, targetSlotOffset, limit);
-            let { slot, blockhash, blockHeight } = JSON.parse(blocks[0]);
-            return {
-                key,
-                context: { slot },
-                value: {
-                    blockhash,
-                    lastValidBlockHeight: blockHeight
-                }
-            };
-        });
-    }
-    try_get_bundle_failed_result(txid_1, bundle_id_1) {
-        return __awaiter(this, arguments, void 0, function* (txid, bundle_id, timeoutMs = 90000) {
-            let url = `https://bundles.jito.wtf/api/v1/bundles/get_bundle_error/${bundle_id}`;
-            let check_interval = parseInt(process.env.CHECK_BUNDLE_ERROR_INTERVAL_MILLS || '7000');
-            let start = Date.now();
-            while (Date.now() - start < timeoutMs) {
-                try {
-                    let err_result = yield (yield fetch(url)).json();
-                    if (err_result && err_result.length > 0) {
-                        (0, dist_1.log_warn)('get_bundle_error, res=', { url, txid, check_interval, timeoutMs, err_result });
-                        let appConfig = global.appConfig;
-                        let mock_failed_tx = {
-                            params: {
-                                result: {
-                                    signature: txid,
-                                    slot: 0,
-                                    transaction: {
-                                        transaction: {
-                                            signatures: [txid]
-                                        },
-                                        version: 0,
-                                        meta: {
-                                            err: JSON.stringify(err_result),
-                                            logMessages: [],
-                                            preBalances: [0],
-                                            postBalances: [0]
-                                        }
-                                    }
-                                }
-                            }
-                        };
-                        appConfig.emit(common_1.LOCAL_EVENT_NAME.EVENT_WALLET_TRANSACTION + '#' + txid, JSON.stringify(mock_failed_tx));
-                        break;
-                    }
-                    else {
-                        (0, dist_1.log_debug)('get_bundle_error, res=', { url, check_interval, rs: err_result });
-                    }
-                }
-                catch (err) {
-                    console.error('get_bundle_error, error!', err);
-                    break;
-                }
-                yield new Promise(resolve => setTimeout(resolve, check_interval));
-            }
-        });
-    }
-    send_tx_to_all_jito_region(serializedTransaction, encoding) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let jito_block_engine_urls = [
-                `${types_1.JITO_API_URLS['Default']}/api/v1/transactions?bundleOnly=true`,
-                `${types_1.JITO_API_URLS['NY']}/api/v1/transactions?bundleOnly=true`,
-                `${types_1.JITO_API_URLS['Amsterdam']}/api/v1/transactions?bundleOnly=true`,
-                `${types_1.JITO_API_URLS['Frankfurt']}/api/v1/transactions?bundleOnly=true`,
-                `${types_1.JITO_API_URLS['Tokyo']}/api/v1/transactions?bundleOnly=true`,
-                `${types_1.JITO_API_URLS['Slc']}/api/v1/transactions?bundleOnly=true`,
-            ];
-            let bundle_id = yield Promise.race(jito_block_engine_urls.map(address => this.sendJitoTransaction(serializedTransaction, address, encoding)));
-            return bundle_id;
-        });
-    }
-}
-exports.RpcClient = RpcClient;