@clonegod/ttd-sol-common 1.0.117 → 1.0.119

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

@@ -49,7 +49,8 @@ export declare class RpcClient {
     getTokenAccounts(params: DAS.GetTokenAccountsRequest): Promise<DAS.GetTokenAccountsResponse>;
     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>;
+    sendJitoTransaction(serializedTransaction: string, jitoApiUrl: string, encoding?: string): Promise<string>;
     get_last_blockhash_slot(connections: Connection[]): Promise<RpcResponseAndContext<BlockhashWithExpiryBlockHeight>>;
     try_get_bundle_failed_result(txid: string, bundle_id: string, timeoutMs?: number): Promise<void>;
+    send_tx_to_all_jito_region(serializedTransaction: string, encoding: string): Promise<string>;
 }

package/dist/helius_sdk_v1.4.0/RpcClient.js

@@ -485,7 +485,7 @@ class RpcClient {
                     let error;
                     do {
                         try {
-                            const signature = yield this.connection.sendRawTransaction(transaction.serialize(), Object.assign({ maxRetries: 3, preflightCommitment: 'confirmed', skipPreflight: sendOptions.skipPreflight, minContextSlot }, sendOptions));
+                            const signature = yield this.connection.sendRawTransaction(transaction.serialize({ verifySignatures: false }), Object.assign({ maxRetries: 3, preflightCommitment: 'confirmed', skipPreflight: sendOptions.skipPreflight, minContextSlot }, sendOptions));
                             const abortSignal = AbortSignal.timeout(15000);
                             yield this.connection.confirmTransaction({
                                 abortSignal,
@@ -576,10 +576,10 @@ class RpcClient {
             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());
+                const encoding = 'base64';
+                const serializedTransaction = transaction.serialize({ verifySignatures: false }).toString(encoding);
                 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);
+                const bundleId = yield this.send_tx_to_all_jito_region(serializedTransaction, encoding);
                 this.try_get_bundle_failed_result(txid, bundleId);
                 (0, dist_1.log_info)(`sendJitoBundle finish`, {
                     jitoApiUrl,
@@ -593,7 +593,7 @@ class RpcClient {
                 const startTime = Date.now();
                 while (Date.now() - startTime < timeout) {
                     const bundleStatuses = yield this.getBundleStatuses([bundleId], jitoApiUrl);
-                    (0, dist_1.log_info)(`getBundleStatuses`, {
+                    (0, dist_1.log_debug)(`getBundleStatuses success`, {
                         txid,
                         bundleId,
                         jitoApiUrl,
@@ -610,7 +610,7 @@ class RpcClient {
                     }
                     yield new Promise((resolve) => setTimeout(resolve, interval));
                 }
-                let err = new Error('Bundle failed to confirm within the timeout period');
+                let err = new Error('Bundle failed to confirm within the timeout period:' + timeout + 'ms');
                 (0, dist_1.log_error)(`Bundle failed to confirm, txid=${txid}`, err);
                 throw err;
             }), 0);
@@ -664,7 +664,7 @@ class RpcClient {
                 rawTransaction = Buffer.from(transaction.serialize()).toString('base64');
             }
             else {
-                rawTransaction = transaction.serialize().toString('base64');
+                rawTransaction = transaction.serialize({ verifySignatures: false }).toString('base64');
             }
             try {
                 const url = `${this.connection.rpcEndpoint}`;
@@ -701,7 +701,7 @@ class RpcClient {
             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());
+                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);
@@ -713,7 +713,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 ||
@@ -736,23 +736,31 @@ class RpcClient {
                     }
                     yield new Promise((resolve) => setTimeout(resolve, interval));
                 }
-                let err = new Error('Bundle failed to confirm within the timeout period');
+                let err = new Error('Bundle failed to confirm within the timeout period:' + timeout + 'ms');
                 (0, dist_1.log_error)(`Bundle failed to confirm, txid=${txid}`, err);
                 throw err;
             }), 0);
             return txid;
         });
     }
-    sendJitoTransaction(serializedTransaction, jitoApiUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            (0, dist_1.log_info)('sendJitoTransaction start', {
-                jitoApiUrl
-            });
+    sendJitoTransaction(serializedTransaction_1, jitoApiUrl_1) {
+        return __awaiter(this, arguments, void 0, function* (serializedTransaction, jitoApiUrl, encoding = 'base64') {
+            let start = Date.now();
+            let params;
+            if (encoding === 'base64') {
+                params = [serializedTransaction, { encoding }];
+            }
+            else if (encoding === 'bs58') {
+                params = [serializedTransaction];
+            }
+            else {
+                throw new Error('Invalid type of encoding:' + encoding);
+            }
             const response = yield axios_1.default.post(jitoApiUrl, {
                 jsonrpc: '2.0',
                 id: 1,
                 method: 'sendTransaction',
-                params: [serializedTransaction],
+                params,
             }, {
                 headers: { 'Content-Type': 'application/json' },
             });
@@ -762,7 +770,9 @@ class RpcClient {
             let bundleId = response.headers['x-bundle-id'];
             (0, dist_1.log_info)('sendJitoTransaction finish', {
                 jitoApiUrl,
-                bundleId
+                encoding,
+                bundleId,
+                take: (Date.now() - start) + 'ms'
             });
             return bundleId;
         });
@@ -805,11 +815,11 @@ class RpcClient {
             let start = Date.now();
             while (Date.now() - start < timeoutMs) {
                 try {
-                    let rs = yield (yield fetch(url)).json();
-                    if (rs && rs.length > 0) {
-                        (0, dist_1.log_warn)('get_bundle_error, res=', { url, txid, check_interval, timeoutMs, rs });
+                    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_tx_obj = {
+                        let mock_failed_tx = {
                             params: {
                                 result: {
                                     signature: txid,
@@ -820,18 +830,20 @@ class RpcClient {
                                         },
                                         version: 0,
                                         meta: {
-                                            err: JSON.stringify(rs),
-                                            logMessages: []
+                                            err: JSON.stringify(err_result),
+                                            logMessages: [],
+                                            preBalances: [0],
+                                            postBalances: [0]
                                         }
                                     }
                                 }
                             }
                         };
-                        appConfig.emit(common_1.LOCAL_EVENT_NAME.EVENT_WALLET_TRANSACTION + '#' + txid, JSON.stringify(mock_tx_obj));
+                        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 });
+                        (0, dist_1.log_debug)('get_bundle_error, res=', { url, check_interval, rs: err_result });
                     }
                 }
                 catch (err) {
@@ -842,5 +854,19 @@ class RpcClient {
             }
         });
     }
+    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;

package/dist/helius_sdk_v1.4.0/types/enums.js

@@ -602,4 +602,5 @@ exports.JITO_API_URLS = {
     Amsterdam: 'https://amsterdam.mainnet.block-engine.jito.wtf',
     Frankfurt: 'https://frankfurt.mainnet.block-engine.jito.wtf',
     Tokyo: 'https://tokyo.mainnet.block-engine.jito.wtf',
+    Slc: 'https://slc.mainnet.block-engine.jito.wtf'
 };

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

@@ -293,7 +293,7 @@ export interface GetPriorityFeeEstimateResponse {
     priorityFeeEstimate?: number;
     priorityFeeLevels?: MicroLamportPriorityFeeLevels;
 }
-export type JitoRegion = 'Default' | 'NY' | 'Amsterdam' | 'Frankfurt' | 'Tokyo';
+export type JitoRegion = 'Default' | 'NY' | 'Amsterdam' | 'Frankfurt' | 'Tokyo' | 'Slc';
 export type PollTransactionOptions = {
     confirmationStatuses?: TransactionConfirmationStatus[];
     timeout?: number;

package/dist/trade/tx_result_check.js

@@ -71,11 +71,9 @@ class TransactionResultChecker {
                 else {
                     this.event_emitter.emit(dist_1.TRANSACTION_STATE_FAILED, trade_result);
                 }
-                setTimeout(() => {
-                    console.log('<----------------------------------------------------');
-                    console.dir(trade_result, { depth: 8 });
-                    console.log('---------------------------------------------------->');
-                }, 0);
+                console.log('<----------------------------------------------------');
+                console.dir(trade_result, { depth: 8 });
+                console.log('---------------------------------------------------->');
             }
             catch (err) {
                 (0, dist_1.log_error)('parse geyser stream message error!', err);
@@ -114,11 +112,11 @@ class TransactionResultChecker {
                                 this.event_emitter.emit(dist_1.TRANSACTION_STATE_FAILED, trade_result);
                             }
                         }
-                        setTimeout(() => {
+                        if (dist_1.LOG.debug) {
                             console.log('<====================================================');
                             console.dir(trade_result, { depth: 8 });
                             console.log('====================================================>');
-                        }, 0);
+                        }
                     }
                     else {
                         clearInterval(intervalId);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-sol-common",
-    "version": "1.0.117",
+    "version": "1.0.119",
     "description": "",
     "main": "dist/index.js",
     "types": "types/index.d.ts",