@clonegod/ttd-sol-common 1.0.76 → 1.0.77

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

@@ -46,4 +46,6 @@ export declare class RpcClient {
     getNftEditions(params: DAS.GetNftEditionsRequest): Promise<DAS.GetNftEditionsResponse>;
     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>;
 }

package/dist/helius_sdk_v1.4.0/RpcClient.js

@@ -418,6 +418,9 @@ class RpcClient {
             if (solana_trade_runtime.settings.strategy.broadcast_type === 'jito') {
                 priorityFeeEstimate = 1;
             }
+            if (solana_trade_runtime.settings.strategy.broadcast_type === 'mixed') {
+                priorityFeeEstimate = Math.ceil(priorityFeeEstimate * 0.7);
+            }
             const computeBudgetIx = web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
                 microLamports: priorityFeeEstimate,
             });
@@ -676,12 +679,88 @@ class RpcClient {
                 if (response.data.error) {
                     throw new Error(`RPC error: ${JSON.stringify(response.data.error)}`);
                 }
-                return response.data.result;
+                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());
+                let jitoApiUrl = `${types_1.JITO_API_URLS[region]}/api/v1/transactions`;
+                if (solana_trade_runtime.jito_plugin_url) {
+                    jitoApiUrl = solana_trade_runtime.jito_plugin_url;
+                }
+                (0, dist_1.log_info)('sendSmartTransactionWithTipMixed, start');
+                this.sendTransaction(transaction);
+                const bundleId = yield this.sendJitoTransaction(serializedTransaction, jitoApiUrl);
+                (0, dist_1.log_info)(`sendJitoTransaction`, {
+                    txid,
+                    bundleId
+                });
+                const currentBlockHeight = yield solana_trade_runtime.connection.getBlockHeight();
+                const lastValidBlockHeight = Math.min(blockhash.lastValidBlockHeight, currentBlockHeight + lastValidBlockHeightOffset);
+                const timeout = 60000;
+                const interval = 5000;
+                const startTime = Date.now();
+                while (Date.now() - startTime < timeout ||
+                    (yield this.connection.getBlockHeight()) <= lastValidBlockHeight) {
+                    const bundleStatuses = yield this.getBundleStatuses([bundleId], jitoApiUrl);
+                    (0, dist_1.log_info)(`getBundleStatuses`, {
+                        txid,
+                        bundleId,
+                        jitoApiUrl,
+                        bundleStatuses
+                    });
+                    if (bundleStatuses &&
+                        bundleStatuses.value &&
+                        bundleStatuses.value.length > 0 &&
+                        bundleStatuses.value[0]) {
+                        const status = bundleStatuses.value[0].confirmation_status;
+                        if (status === 'confirmed') {
+                            return bundleStatuses.value[0].transactions[0];
+                        }
+                    }
+                    yield new Promise((resolve) => setTimeout(resolve, interval));
+                }
+                let err = new Error('Bundle failed to confirm within the timeout period');
+                (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* () {
+            const response = yield axios_1.default.post(jitoApiUrl, {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'sendTransaction',
+                params: [serializedTransaction],
+            }, {
+                headers: { 'Content-Type': 'application/json' },
+            });
+            if (response.data.error) {
+                throw new Error(`Error sending bundles: ${JSON.stringify(response.data.error, null, 2)}`);
+            }
+            console.log(response.headers);
+            return response.headers['x-bundle-id'];
+        });
+    }
 }
 exports.RpcClient = RpcClient;

package/dist/send_tx/helius_client.d.ts

@@ -1,6 +1,6 @@
 import { SendOptions, Signer, TransactionInstruction } from "@solana/web3.js";
-import { Helius } from "../helius_sdk_v1.4.0";
 import { SolanaTradeRuntimeType } from '../../types';
+import { Helius } from "../helius_sdk_v1.4.0";
 export declare class HeliusClient {
     signers: Signer[];
     sendOptions: SendOptions;
@@ -11,4 +11,5 @@ export declare class HeliusClient {
     send_transaction(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[]): Promise<string>;
     private send_smart_transaction;
     private send_transaction_by_jito;
+    private send_transaction_mixed;
 }

package/dist/send_tx/helius_client.js

@@ -31,13 +31,16 @@ class HeliusClient {
         return __awaiter(this, void 0, void 0, function* () {
             let txid = '';
             let { broadcast_type, speed } = solana_trade_runtime.settings.strategy;
+            let use_staked_endpint = speed === 'turbo' || speed === 'ultra';
             if (broadcast_type === 'rpc') {
-                let use_staked_endpint = speed === 'turbo' || speed === 'ultra';
                 txid = yield this.send_smart_transaction(solana_trade_runtime, instructions, use_staked_endpint);
             }
             else if (broadcast_type === 'jito') {
                 txid = yield this.send_transaction_by_jito(solana_trade_runtime, instructions);
             }
+            else if (broadcast_type === 'mixed') {
+                txid = yield this.send_transaction_mixed(solana_trade_runtime, instructions, use_staked_endpint);
+            }
             else {
                 throw new Error(`Not support broadcast_type: ${broadcast_type}`);
             }
@@ -75,5 +78,22 @@ class HeliusClient {
             return txid;
         });
     }
+    send_transaction_mixed(solana_trade_runtime, instructions, use_staked_endpint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_info)(`send_transaction_mixed, start`);
+            let start_time = Date.now();
+            let tipAmount = Math.ceil(solana_trade_runtime.priority_fee * 0.3);
+            let jito_region = (0, strategy_util_1.get_jito_region)();
+            let rpc = use_staked_endpint ? this.helius_staked.rpc : this.helius_mainnet.rpc;
+            let txid = yield rpc.sendSmartTransactionWithTip(solana_trade_runtime, instructions, this.signers, [], tipAmount, jito_region);
+            (0, dist_1.log_info)(`send_transaction_mixed, end`, {
+                tipAmount,
+                jito_region,
+                txid,
+                take_time: Date.now() - start_time
+            });
+            return txid;
+        });
+    }
 }
 exports.HeliusClient = HeliusClient;

package/package.json

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