@clonegod/ttd-sol-common 1.0.114 → 1.0.115

package/dist/helius_sdk_v1.4.0/RpcClient.d.ts

@@ -2,6 +2,7 @@ import { BlockhashWithExpiryBlockHeight, VersionedTransaction, AddressLookupTabl
 import { DAS } from './types/das-types';
 import { GetPriorityFeeEstimateRequest, GetPriorityFeeEstimateResponse, JitoRegion, PollTransactionOptions, SmartTransactionContext, HeliusSendOptions } from './types';
 import { SolanaTradeRuntimeType } from '../../types';
+import { JitoJsonRpcClient } from '../jito';
 export type SendAndConfirmTransactionResponse = {
     signature: TransactionSignature;
     confirmResponse: RpcResponseAndContext<SignatureResult>;
@@ -11,6 +12,7 @@ export type SendAndConfirmTransactionResponse = {
 export declare class RpcClient {
     protected readonly connection: Connection;
     protected readonly id?: string;
+    jitoClient: JitoJsonRpcClient;
     constructor(connection: Connection, id?: string);
     airdrop(publicKey: PublicKey, lamports: number, commitment?: Commitment): Promise<SendAndConfirmTransactionResponse>;
     getLatestBlockhash(commitmentOrConfig?: Commitment | GetLatestBlockhashConfig): Promise<BlockhashWithExpiryBlockHeight>;
@@ -48,4 +50,6 @@ export declare class RpcClient {
     sendTransaction(transaction: Transaction | VersionedTransaction, options?: HeliusSendOptions): Promise<TransactionSignature>;
     sendSmartTransactionWithTipMixed(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], tipAmount?: number, region?: JitoRegion, feePayer?: Signer, lastValidBlockHeightOffset?: number): Promise<string>;
     sendJitoTransaction(serializedTransaction: string, jitoApiUrl: string): Promise<string>;
+    get_last_blockhash_slot(connections: Connection[]): Promise<RpcResponseAndContext<BlockhashWithExpiryBlockHeight>>;
+    check_bundle_result(bundle_id: string, timeoutMs?: number): Promise<void>;
 }

package/dist/helius_sdk_v1.4.0/RpcClient.js

@@ -19,10 +19,12 @@ 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-common/dist");
+const jito_1 = require("../jito");
 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* () {
@@ -365,10 +367,7 @@ class RpcClient {
             }
             (0, dist_1.log_info)(`>>> getLatestBlockhashAndContext, start`);
             const payerKey = feePayer ? feePayer.publicKey : signers[0].publicKey;
-            const { context: { slot: minContextSlot }, value: blockhash, } = yield Promise.race([
-                this.connection.getLatestBlockhashAndContext(),
-                solana_trade_runtime.connection.getLatestBlockhashAndContext()
-            ]);
+            let { context: { slot: minContextSlot }, value: blockhash, } = yield this.get_last_blockhash_slot([this.connection, solana_trade_runtime.connection]);
             (0, dist_1.log_info)(`>>> getLatestBlockhashAndContext, end`);
             const recentBlockhash = blockhash.blockhash;
             const isVersioned = lookupTables.length > 0;
@@ -396,7 +395,7 @@ class RpcClient {
                 }
             }
             setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                if (Math.random() > 0.15)
+                if (Math.random() > -1)
                     return;
                 const serializedTransaction = bs58_1.default.encode(isVersioned
                     ? versionedTransaction.serialize()
@@ -423,7 +422,7 @@ class RpcClient {
             });
             instructions.unshift(computeBudgetIx);
             setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                if (Math.random() > 0)
+                if (Math.random() > -1)
                     return;
                 (0, dist_1.log_info)(`>>> getComputeUnits, start`);
                 const units = yield this.getComputeUnits(instructions, payerKey, isVersioned ? lookupTables : [], signers);
@@ -580,6 +579,7 @@ class RpcClient {
                 let jitoApiUrl = `${types_1.JITO_API_URLS[region]}/api/v1/bundles`;
                 this.sendJitoTransaction(serializedTransaction, `${types_1.JITO_API_URLS['Default']}/api/v1/transactions?bundleOnly=true`);
                 const bundleId = yield this.sendJitoBundle([serializedTransaction], jitoApiUrl);
+                this.check_bundle_result(bundleId);
                 (0, dist_1.log_info)(`sendJitoBundle finish`, {
                     jitoApiUrl,
                     txid,
@@ -587,7 +587,7 @@ class RpcClient {
                 });
                 const currentBlockHeight = yield solana_trade_runtime.connection.getBlockHeight();
                 const lastValidBlockHeight = Math.min(blockhash.lastValidBlockHeight, currentBlockHeight + lastValidBlockHeightOffset);
-                const timeout = 60000;
+                const timeout = 10000;
                 const interval = 5000;
                 const startTime = Date.now();
                 while (Date.now() - startTime < timeout ||
@@ -767,5 +767,53 @@ class RpcClient {
             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) {
+                try {
+                    last_blockhash_slot = yield Promise.race(connections.map(c => c.getLatestBlockhashAndContext()));
+                }
+                catch (err) {
+                    (0, dist_1.log_error)('get_last_blockhash_slot, fetch by connection', err);
+                }
+            }
+            return last_blockhash_slot;
+        });
+    }
+    check_bundle_result(bundle_id_1) {
+        return __awaiter(this, arguments, void 0, function* (bundle_id, timeoutMs = 3000) {
+            this.jitoClient.confirmInflightBundle(bundle_id, timeoutMs);
+            let start = Date.now();
+            while (Date.now() - start < timeoutMs) {
+                try {
+                    let rs = yield fetch(`https://bundles.jito.wtf/api/v1/bundles/get_bundle_error/${bundle_id}`);
+                    let jsonObj = yield rs.json();
+                    console.log('get_bundle_error, res=', jsonObj);
+                }
+                catch (err) {
+                    console.error('get_bundle_error, error!', err);
+                }
+                yield new Promise(resolve => setTimeout(resolve, 500));
+            }
+        });
+    }
 }
 exports.RpcClient = RpcClient;

package/dist/jito/index.d.ts

@@ -0,0 +1,14 @@
+export declare class JitoJsonRpcClient {
+    baseUrl: string;
+    uuid: string;
+    client: any;
+    constructor(baseUrl: string, uuid: string);
+    sendRequest(endpoint: any, method: any, params: any): Promise<any>;
+    getTipAccounts(): Promise<any>;
+    getRandomTipAccount(): Promise<any>;
+    sendBundle(params: any): Promise<any>;
+    sendTxn(params: any, bundleOnly?: boolean): Promise<any>;
+    getInFlightBundleStatuses(params: any): Promise<any>;
+    getBundleStatuses(params: any): Promise<any>;
+    confirmInflightBundle(bundleId: any, timeoutMs?: number): Promise<any>;
+}

package/dist/jito/index.js

@@ -0,0 +1,142 @@
+"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.JitoJsonRpcClient = void 0;
+const axios = require('axios');
+class JitoJsonRpcClient {
+    constructor(baseUrl, uuid) {
+        this.baseUrl = baseUrl;
+        this.uuid = uuid;
+        this.client = axios.create({
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    sendRequest(endpoint, method, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.baseUrl}${endpoint}`;
+            const data = {
+                jsonrpc: '2.0',
+                id: 1,
+                method,
+                params: params || [],
+            };
+            console.log(`Sending request to: ${url}`);
+            console.log(`Request body: ${JSON.stringify(data, null, 2)}`);
+            try {
+                const response = yield this.client.post(url, data);
+                console.log(`Response status: ${response.status}`);
+                console.log(`Response body: ${JSON.stringify(response.data, null, 2)}`);
+                return response.data;
+            }
+            catch (error) {
+                if (axios.isAxiosError(error)) {
+                    console.error(`HTTP error: ${error.message}`);
+                    throw error;
+                }
+                else {
+                    console.error(`Unexpected error: ${error}`);
+                    throw new Error('An unexpected error occurred');
+                }
+            }
+        });
+    }
+    getTipAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = this.uuid ? `/bundles?uuid=${this.uuid}` : '/bundles';
+            return this.sendRequest(endpoint, 'getTipAccounts', null);
+        });
+    }
+    getRandomTipAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tipAccountsResponse = yield this.getTipAccounts();
+            if (tipAccountsResponse.result && Array.isArray(tipAccountsResponse.result) && tipAccountsResponse.result.length > 0) {
+                const randomIndex = Math.floor(Math.random() * tipAccountsResponse.result.length);
+                return tipAccountsResponse.result[randomIndex];
+            }
+            else {
+                throw new Error('No tip accounts available');
+            }
+        });
+    }
+    sendBundle(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = this.uuid ? `/bundles?uuid=${this.uuid}` : '/bundles';
+            return this.sendRequest(endpoint, 'sendBundle', params);
+        });
+    }
+    sendTxn(params_1) {
+        return __awaiter(this, arguments, void 0, function* (params, bundleOnly = false) {
+            let endpoint = '/transactions';
+            const queryParams = [];
+            if (bundleOnly) {
+                queryParams.push('bundleOnly=true');
+            }
+            if (this.uuid) {
+                queryParams.push(`uuid=${this.uuid}`);
+            }
+            if (queryParams.length > 0) {
+                endpoint += `?${queryParams.join('&')}`;
+            }
+            return this.sendRequest(endpoint, 'sendTransaction', params);
+        });
+    }
+    getInFlightBundleStatuses(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = this.uuid ? `/bundles?uuid=${this.uuid}` : '/bundles';
+            return this.sendRequest(endpoint, 'getInflightBundleStatuses', params);
+        });
+    }
+    getBundleStatuses(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const endpoint = this.uuid ? `/bundles?uuid=${this.uuid}` : '/bundles';
+            return this.sendRequest(endpoint, 'getBundleStatuses', params);
+        });
+    }
+    confirmInflightBundle(bundleId_1) {
+        return __awaiter(this, arguments, void 0, function* (bundleId, timeoutMs = 60000) {
+            const start = Date.now();
+            while (Date.now() - start < timeoutMs) {
+                try {
+                    const response = yield this.getInFlightBundleStatuses([[bundleId]]);
+                    if (response.result && response.result.value && response.result.value.length > 0) {
+                        const bundleStatus = response.result.value[0];
+                        console.log(`Bundle status: ${bundleStatus.status}, Landed slot: ${bundleStatus.landed_slot}`);
+                        if (bundleStatus.status === "Failed") {
+                            return bundleStatus;
+                        }
+                        else if (bundleStatus.status === "Landed") {
+                            const detailedStatus = yield this.getBundleStatuses([[bundleId]]);
+                            if (detailedStatus.result && detailedStatus.result.value && detailedStatus.result.value.length > 0) {
+                                return detailedStatus.result.value[0];
+                            }
+                            else {
+                                console.log('No detailed status returned for landed bundle.');
+                                return bundleStatus;
+                            }
+                        }
+                    }
+                    else {
+                        console.log('No status returned for the bundle. It may be invalid or very old.');
+                    }
+                }
+                catch (error) {
+                    console.error('Error checking bundle status:', error);
+                }
+                yield new Promise(resolve => setTimeout(resolve, 2000));
+            }
+            console.log(`Bundle ${bundleId} has not reached a final state within ${timeoutMs}ms`);
+            return { status: 'Timeout' };
+        });
+    }
+}
+exports.JitoJsonRpcClient = JitoJsonRpcClient;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-sol-common",
-    "version": "1.0.114",
+    "version": "1.0.115",
     "description": "",
     "main": "dist/index.js",
     "types": "types/index.d.ts",
@@ -30,4 +30,4 @@
     "publishConfig": {
         "access": "public"
     }
-}
+}

package/types/index.d.ts

@@ -56,3 +56,11 @@ export interface SolanaTradeRuntimeType extends TradeRuntimeType {
 }
 
 
+export interface SolLastBlockAndSlot {
+    context_slot: number
+    slot: number
+    blockhash: string
+    blockHeight: number
+    blockTime: number
+}
+