@clonegod/ttd-sol-common 1.0.32 → 1.0.34

package/dist/common/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const MAX_GAS_FEE: number;
+export declare const ONE_MILLION = 1000000;
+export declare enum COMMITMENT_LEVEL {
+    PROCESSED = "processed",
+    CONFIRMED = "confirmed",
+    _FINALIZED = "finalized"
+}
+export declare enum LOCAL_EVENT_NAME {
+    EVENT_POOL_ACCOUNT_CHANGE = "EVENT_POOL_ACCOUNT_CHANGE"
+}

package/dist/common/constants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_EVENT_NAME = exports.COMMITMENT_LEVEL = exports.ONE_MILLION = exports.MAX_GAS_FEE = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.MAX_GAS_FEE = web3_js_1.LAMPORTS_PER_SOL / 1000;
+exports.ONE_MILLION = 1000000;
+var COMMITMENT_LEVEL;
+(function (COMMITMENT_LEVEL) {
+    COMMITMENT_LEVEL["PROCESSED"] = "processed";
+    COMMITMENT_LEVEL["CONFIRMED"] = "confirmed";
+    COMMITMENT_LEVEL["_FINALIZED"] = "finalized";
+})(COMMITMENT_LEVEL || (exports.COMMITMENT_LEVEL = COMMITMENT_LEVEL = {}));
+var LOCAL_EVENT_NAME;
+(function (LOCAL_EVENT_NAME) {
+    LOCAL_EVENT_NAME["EVENT_POOL_ACCOUNT_CHANGE"] = "EVENT_POOL_ACCOUNT_CHANGE";
+})(LOCAL_EVENT_NAME || (exports.LOCAL_EVENT_NAME = LOCAL_EVENT_NAME = {}));

package/dist/common/context.d.ts

@@ -0,0 +1,22 @@
+import { OrderMessageType, PriceMessageType, StandardPoolInfoType, TradeRuntimeType } from "@clonegod/ttd-common";
+import { CHAIN_ID, DEX_ID } from "@clonegod/ttd-common/dist";
+import { Connection } from "@solana/web3.js";
+import { SolanaTradeRuntimeType } from "./types";
+export declare class TradeContext {
+    connection: Connection;
+    trade_runtime: TradeRuntimeType;
+    solana_trade_runtime: SolanaTradeRuntimeType;
+    price_msg: PriceMessageType;
+    order_msg: OrderMessageType;
+    order_trace_id: string;
+    group_id: string;
+    chain_id: CHAIN_ID;
+    dex_id: DEX_ID;
+    pool_id: string;
+    fee_rate: string;
+    pool_info: StandardPoolInfoType;
+    aToB: boolean;
+    slippage_bps: number;
+    constructor(price_msg: PriceMessageType, order_msg: OrderMessageType);
+    init(trade_runtime: TradeRuntimeType): Promise<void>;
+}

package/dist/common/context.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.TradeContext = void 0;
+const dist_1 = require("@clonegod/ttd-common/dist");
+const send_tx_1 = require("../send_tx");
+class TradeContext {
+    constructor(price_msg, order_msg) {
+        this.price_msg = price_msg;
+        this.order_msg = order_msg;
+        this.order_trace_id = order_msg.order_trace_id;
+    }
+    init(trade_runtime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.trade_runtime = trade_runtime;
+            let { group_id, unique_orderbook_id } = this.order_msg;
+            this.group_id = group_id;
+            let unique_orderbook_id_obj = (0, dist_1.parse_unique_orderbook_id)(unique_orderbook_id);
+            this.chain_id = dist_1.CHAIN_ID[unique_orderbook_id_obj.chain_id];
+            this.dex_id = dist_1.DEX_ID[unique_orderbook_id_obj.dex_id];
+            this.pool_id = unique_orderbook_id_obj.pool_id;
+            this.fee_rate = unique_orderbook_id_obj.fee_rate;
+            this.pool_info = this.trade_runtime.pair_dex.pool_info_list.find(e => e.pool_address === this.pool_id);
+            if (!this.pool_info) {
+                throw new Error(`Not found pool_info! pool_id=${this.pool_id}, pool_info_list=${JSON.stringify(this.trade_runtime.pair_dex.pool_info_list)}`);
+            }
+            this.slippage_bps = Math.min(100, Math.max(30, this.trade_runtime.settings.slippage_bps));
+            this.aToB = this.pool_info.is_reverse_token ? !this.order_msg.aToB : this.order_msg.aToB;
+            this.solana_trade_runtime = (0, send_tx_1.create_solana_trade_runtime)(this.connection, this.trade_runtime, this.pool_info);
+        });
+    }
+}
+exports.TradeContext = TradeContext;

package/dist/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants';
+export * from './context';
+export * from './types';

package/dist/common/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./types"), exports);

package/dist/common/types.d.ts

@@ -0,0 +1,31 @@
+import { StandardTokenInfoType, TradeRuntimeType } from "@clonegod/ttd-common";
+import { Connection } from "@solana/web3.js";
+export interface StandardSwapDetailType {
+    success: boolean;
+    error_code: string;
+    wallet: string;
+    txid: string;
+    block_time: number;
+    block_number: number;
+    pool_address: string;
+    tokenA: TokenBalChangeType;
+    tokenB: TokenBalChangeType;
+    tx_price: string;
+    gas_fee: GasFeeType;
+}
+export interface TokenBalChangeType extends StandardTokenInfoType {
+    pre_bal: number;
+    post_bal: number;
+    change: string;
+}
+export interface GasFeeType {
+    base_fee: number;
+    priority_fee: number;
+    total_fee: number;
+}
+export interface SolanaTradeRuntimeType extends TradeRuntimeType {
+    connection: Connection;
+    priority_fee: number;
+    cu_price: number;
+    cu_limit: number;
+}

package/dist/common/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/helius_geyser_ws/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { StandardPoolInfoType } from "@clonegod/ttd-common";
+import EventEmitter from "events";
+export declare const subscribe_pool_change_by_geyser: (geyser_ws_url: string, pool_list: StandardPoolInfoType[], eventEmitter: EventEmitter) => Promise<void>;

package/dist/helius_geyser_ws/index.js

@@ -0,0 +1,93 @@
+"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.subscribe_pool_change_by_geyser = void 0;
+const dist_1 = require("@clonegod/ttd-common/dist");
+const ws_1 = __importDefault(require("ws"));
+const constants_1 = require("../common/constants");
+const subscribe_pool_change_by_geyser = (geyser_ws_url, pool_list, eventEmitter) => __awaiter(void 0, void 0, void 0, function* () {
+    if ((0, dist_1.isEmpty)(geyser_ws_url)) {
+        (0, dist_1.log_warn)(`geyser_ws_url is empty, cann't subscribe`);
+        return;
+    }
+    if ((0, dist_1.isEmpty)(pool_list)) {
+        (0, dist_1.log_warn)(`pool_list is empty, nothing to subscribe`);
+        return;
+    }
+    yield (0, dist_1.sleep)(1000);
+    var ws_client = new ws_1.default(geyser_ws_url);
+    function subscribe_account_change(ws_client, pool) {
+        (0, dist_1.log_info)(`subscribe: ${pool.pool_name} -> ${pool.pool_address}`);
+        const request = {
+            jsonrpc: '2.0',
+            id: 420,
+            method: 'accountSubscribe',
+            params: [
+                pool.pool_address,
+                {
+                    encoding: 'jsonParsed',
+                    commitment: constants_1.COMMITMENT_LEVEL.PROCESSED,
+                },
+            ],
+        };
+        ws_client.send(JSON.stringify(request));
+    }
+    ws_client.on('open', function open() {
+        (0, dist_1.log_info)(`WebSocket is open`);
+        pool_list.forEach((pool) => {
+            subscribe_account_change(ws_client, pool);
+        });
+    });
+    ws_client.on('message', function incoming(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_info)(`Received Geyser Message`);
+            let messageStr = '';
+            try {
+                messageStr = data.toString('utf8');
+                if (dist_1.LOG.trace) {
+                    (0, dist_1.log_trace)(`Received msg:`, messageStr);
+                }
+                if (messageStr == '{}') {
+                    (0, dist_1.log_info)(`receive empty message, something wrong! exit ...`);
+                    ws_client.close();
+                }
+                const messageObj = JSON.parse(messageStr);
+                if (messageObj['id']) {
+                    (0, dist_1.log_info)(`accountSubscribe success!`, messageStr);
+                    return;
+                }
+                else {
+                    const res_data = messageObj['params']['result']['value']['data'];
+                    let data_buff = Buffer.from(res_data[0], res_data[1]);
+                    eventEmitter.emit(constants_1.LOCAL_EVENT_NAME.EVENT_POOL_ACCOUNT_CHANGE, data_buff);
+                }
+            }
+            catch (err) {
+                (0, dist_1.log_error)(`Failed to parse JSON: ${messageStr}`, err);
+                ws_client.close();
+            }
+        });
+    });
+    ws_client.on('error', function error(err) {
+        (0, dist_1.log_error)(`WebSocket error:`, err);
+        ws_client.close();
+    });
+    ws_client.on('close', function close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_warn)(`Socket is closed. Reconnect will be attempted in few seconds`);
+            (0, exports.subscribe_pool_change_by_geyser)(geyser_ws_url, pool_list, eventEmitter);
+        });
+    });
+});
+exports.subscribe_pool_change_by_geyser = subscribe_pool_change_by_geyser;

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

@@ -3,7 +3,7 @@
 import { BlockhashWithExpiryBlockHeight, VersionedTransaction, AddressLookupTableAccount, Transaction, TransactionInstruction, TransactionSignature, Commitment, PublicKey, AccountInfo, GetLatestBlockhashConfig, RpcResponseAndContext, SignatureResult, Blockhash, Connection, ParsedAccountData, SendOptions, Signer, SerializeConfig } from '@solana/web3.js';
 import { DAS } from './types/das-types';
 import { GetPriorityFeeEstimateRequest, GetPriorityFeeEstimateResponse, JitoRegion, PollTransactionOptions, SmartTransactionContext, HeliusSendOptions } from './types';
-import { SolanaTradeRuntimeType } from '../context';
+import { SolanaTradeRuntimeType } from '../common';
 export type SendAndConfirmTransactionResponse = {
     signature: TransactionSignature;
     confirmResponse: RpcResponseAndContext<SignatureResult>;

package/dist/helius_sdk_v1.4.0/RpcClient.js

@@ -17,7 +17,7 @@ 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("../get_signature");
+const get_signature_1 = require("../send_tx/get_signature");
 const dist_1 = require("@clonegod/ttd-common/dist");
 class RpcClient {
     constructor(connection, id) {
@@ -363,14 +363,14 @@ class RpcClient {
             if (existingComputeBudgetInstructions.length > 0) {
                 throw new Error('Cannot provide instructions that set the compute unit price and/or limit');
             }
-            (0, dist_1.log_debug)(`>>> getLatestBlockhashAndContext, start`);
+            (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()
             ]);
+            (0, dist_1.log_info)(`>>> getLatestBlockhashAndContext, end`);
             const recentBlockhash = blockhash.blockhash;
-            (0, dist_1.log_debug)(`>>> getLatestBlockhashAndContext, end`);
             const isVersioned = lookupTables.length > 0;
             let legacyTransaction = null;
             let versionedTransaction = null;
@@ -401,7 +401,7 @@ class RpcClient {
                 const serializedTransaction = bs58_1.default.encode(isVersioned
                     ? versionedTransaction.serialize()
                     : legacyTransaction.serialize(serializeOptions));
-                (0, dist_1.log_debug)(`>>> getPriorityFeeEstimate, start`);
+                (0, dist_1.log_info)(`>>> getPriorityFeeEstimate, start`);
                 const priorityFeeEstimateResponse = yield this.getPriorityFeeEstimate({
                     transaction: serializedTransaction,
                     options: {
@@ -409,7 +409,7 @@ class RpcClient {
                     },
                 });
                 const { priorityFeeEstimate } = priorityFeeEstimateResponse;
-                (0, dist_1.log_debug)(`>>> getPriorityFeeEstimate, end. priorityFeeEstimate=${priorityFeeEstimate}`);
+                (0, dist_1.log_info)(`>>> getPriorityFeeEstimate, end. priorityFeeEstimate=${priorityFeeEstimate}`);
                 if (!priorityFeeEstimate) {
                     throw new Error('Priority fee estimate not available');
                 }
@@ -425,9 +425,9 @@ class RpcClient {
             setTimeout(() => __awaiter(this, void 0, void 0, function* () {
                 if (Math.random() > 0.15)
                     return;
-                (0, dist_1.log_debug)(`>>> getComputeUnits, start`);
+                (0, dist_1.log_info)(`>>> getComputeUnits, start`);
                 const units = yield this.getComputeUnits(instructions, payerKey, isVersioned ? lookupTables : [], signers);
-                (0, dist_1.log_debug)(`>>> getComputeUnits, end. ComputeUnits=${units}`);
+                (0, dist_1.log_info)(`>>> getComputeUnits, end. ComputeUnits=${units}`);
                 if (!units) {
                     throw new Error(`Error fetching compute units for the instructions provided`);
                 }
@@ -476,7 +476,7 @@ class RpcClient {
                 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_debug)(`>>> createSmartTransaction, end`);
+                (0, dist_1.log_info)(`>>> createSmartTransaction, end`);
                 let txid = (0, get_signature_1.getSignature)(transaction);
                 setTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     const commitment = (sendOptions === null || sendOptions === void 0 ? void 0 : sendOptions.preflightCommitment) || 'confirmed';

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export * from './constants';
-export * from './context';
-export * from './strategy_util';
+export * from './common';
 export * from './helius_geyser_ws';
-export * from './send_transaction';
+export * from './send_tx';
+export * from './trade';

package/dist/index.js

@@ -14,8 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./constants"), exports);
-__exportStar(require("./context"), exports);
-__exportStar(require("./strategy_util"), exports);
+__exportStar(require("./common"), exports);
 __exportStar(require("./helius_geyser_ws"), exports);
-__exportStar(require("./send_transaction"), exports);
+__exportStar(require("./send_tx"), exports);
+__exportStar(require("./trade"), exports);

package/dist/send_tx/get_signature.d.ts

@@ -0,0 +1,2 @@
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+export declare function getSignature(transaction: Transaction | VersionedTransaction): string;

package/dist/send_tx/get_signature.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSignature = void 0;
+const bs58_1 = __importDefault(require("bs58"));
+function getSignature(transaction) {
+    const signature = 'signature' in transaction ? transaction.signature : transaction.signatures[0];
+    if (!signature) {
+        throw new Error('Missing transaction signature, the transaction was not signed by the fee payer');
+    }
+    return bs58_1.default.encode(signature);
+}
+exports.getSignature = getSignature;

package/dist/send_tx/index.d.ts

@@ -0,0 +1,3 @@
+export * from './get_signature';
+export * from './send_transaction';
+export * from './strategy_util';

package/dist/send_tx/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get_signature"), exports);
+__exportStar(require("./send_transaction"), exports);
+__exportStar(require("./strategy_util"), exports);

package/dist/send_tx/send_transaction.d.ts

@@ -0,0 +1,14 @@
+import { SendOptions, Signer, TransactionInstruction } from "@solana/web3.js";
+import { Helius } from "../helius_sdk_v1.4.0";
+import { SolanaTradeRuntimeType } from '../common/types';
+export declare class HeliusClient {
+    signers: Signer[];
+    sendOptions: SendOptions;
+    cluster: string;
+    helius_mainnet: Helius;
+    helius_staked: Helius;
+    constructor(signers: Signer[]);
+    send_transaction(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[]): Promise<string>;
+    private send_smart_transaction;
+    private send_transaction_by_jito;
+}

package/dist/send_tx/send_transaction.js

@@ -0,0 +1,79 @@
+"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.HeliusClient = void 0;
+const dist_1 = require("@clonegod/ttd-common/dist");
+const helius_sdk_v1_4_0_1 = require("../helius_sdk_v1.4.0");
+const strategy_util_1 = require("./strategy_util");
+class HeliusClient {
+    constructor(signers) {
+        this.cluster = 'mainnet-beta';
+        this.signers = signers;
+        this.sendOptions = {
+            skipPreflight: true,
+            maxRetries: 0
+        };
+        let helius_api_key = process.env.HELIUS_API_KEY;
+        let helius_mainnet_endpoint = `https://mainnet.helius-rpc.com/?api-key=${helius_api_key}`;
+        let helius_staked_endpoint = `https://staked.helius-rpc.com?api-key=${helius_api_key}`;
+        this.helius_mainnet = new helius_sdk_v1_4_0_1.Helius('', this.cluster, 'helius-sdk', helius_mainnet_endpoint);
+        this.helius_staked = new helius_sdk_v1_4_0_1.Helius('', this.cluster, 'helius-sdk', helius_staked_endpoint);
+    }
+    send_transaction(solana_trade_runtime, instructions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let txid = '';
+            let { broadcast_type, speed } = solana_trade_runtime.settings.strategy;
+            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 {
+                throw new Error(`Not support broadcast_type: ${broadcast_type}`);
+            }
+            return txid;
+        });
+    }
+    send_smart_transaction(solana_trade_runtime, instructions, use_staked_endpint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_info)(`send_smart_transaction, start`);
+            let start_time = Date.now();
+            let rpc = use_staked_endpint ? this.helius_staked.rpc : this.helius_mainnet.rpc;
+            let txid = yield rpc.sendSmartTransaction(solana_trade_runtime, instructions, this.signers, [], this.sendOptions);
+            (0, dist_1.log_info)(`send_smart_transaction, end`, {
+                txid,
+                use_staked_endpint,
+                take_time: Date.now() - start_time
+            });
+            return txid;
+        });
+    }
+    send_transaction_by_jito(solana_trade_runtime, instructions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_info)(`send_transaction_by_jito, start`);
+            let start_time = Date.now();
+            let tipAmount = solana_trade_runtime.priority_fee;
+            let jito_region = (0, strategy_util_1.get_jito_region)();
+            let 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_by_jito, end`, {
+                tipAmount,
+                jito_region,
+                txid,
+                take_time: Date.now() - start_time
+            });
+            return txid;
+        });
+    }
+}
+exports.HeliusClient = HeliusClient;

package/dist/send_tx/strategy_util.d.ts

@@ -0,0 +1,7 @@
+import { StandardPoolInfoType, TradeRuntimeType, TradeStrategyType } from "@clonegod/ttd-common";
+import { JitoRegion } from "../helius_sdk_v1.4.0";
+import { Connection } from "@solana/web3.js";
+import { SolanaTradeRuntimeType } from "../common/types";
+export declare function create_solana_trade_runtime(connection: Connection, trade_runtime: TradeRuntimeType, pool_info: StandardPoolInfoType): SolanaTradeRuntimeType;
+export declare function calculate_gas_fee(trade_strategy: TradeStrategyType): number;
+export declare function get_jito_region(): JitoRegion;

package/dist/send_tx/strategy_util.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_jito_region = exports.calculate_gas_fee = exports.create_solana_trade_runtime = void 0;
+const dist_1 = require("@clonegod/ttd-common/dist");
+const constants_1 = require("../common/constants");
+function create_solana_trade_runtime(connection, trade_runtime, pool_info) {
+    let trade_strategy = trade_runtime.settings.strategy;
+    let { cu_limit } = pool_info;
+    if (isNaN(cu_limit) || cu_limit < 50000) {
+        cu_limit = 50000;
+    }
+    let priority_fee = calculate_gas_fee(trade_strategy);
+    let cu_price = Math.ceil(priority_fee * constants_1.ONE_MILLION / cu_limit);
+    (0, dist_1.log_info)(`trade_strategy & gas`, {
+        trade_strategy,
+        priority_fee,
+        cu_limit,
+        cu_price
+    });
+    let solana_trade_runtime = Object.assign(Object.assign({}, trade_runtime), { connection,
+        priority_fee,
+        cu_limit,
+        cu_price });
+    return solana_trade_runtime;
+}
+exports.create_solana_trade_runtime = create_solana_trade_runtime;
+function calculate_gas_fee(trade_strategy) {
+    let { speed, fee_mode, fee_exact, fee_max_cap, } = trade_strategy;
+    let gas_fee = 1000;
+    switch (fee_mode) {
+        case "exact":
+            gas_fee = get_excat_fee_by_speed(speed, fee_exact);
+            break;
+        case "max_cap":
+            gas_fee = get_dynamic_fee_by_speed(speed, 50000, fee_max_cap);
+            break;
+        default:
+            throw new Error(`Not support fee_mode: ${fee_mode}`);
+    }
+    return gas_fee;
+}
+exports.calculate_gas_fee = calculate_gas_fee;
+function get_excat_fee_by_speed(speed, fee_exact) {
+    let factor = 1;
+    if (speed === 'fast') {
+        factor = 1;
+    }
+    if (speed === 'turbo') {
+        factor = 2;
+    }
+    if (speed === 'ultra') {
+        factor = 5;
+    }
+    return fee_exact * factor;
+}
+function get_dynamic_fee_by_speed(speed, estimate_priority_fee, fee_max_cap) {
+    let factor = 1;
+    if (speed === 'fast') {
+        factor = 1;
+    }
+    if (speed === 'turbo') {
+        factor = 2;
+    }
+    if (speed === 'ultra') {
+        factor = 5;
+    }
+    return Math.min(estimate_priority_fee * factor, fee_max_cap);
+}
+function get_jito_region() {
+    let jito_region;
+    let server_info = (0, dist_1.getServerInfo)();
+    switch (server_info.region) {
+        case 'fra':
+            jito_region = 'Frankfurt';
+            break;
+        case 'virginia':
+            jito_region = 'NY';
+            break;
+        case 'jp':
+            jito_region = 'Tokyo';
+            break;
+        default:
+            jito_region = 'Default';
+    }
+    (0, dist_1.log_debug)(`get_jito_region`, {
+        server_info,
+        jito_region
+    });
+    return jito_region;
+}
+exports.get_jito_region = get_jito_region;

package/dist/trade/abstract_trade.d.ts

@@ -0,0 +1,4 @@
+import { TradeContext } from "../common/context";
+export declare abstract class AbastrcatTrade {
+    abstract execute(context: TradeContext): Promise<string>;
+}

package/dist/trade/abstract_trade.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbastrcatTrade = void 0;
+class AbastrcatTrade {
+}
+exports.AbastrcatTrade = AbastrcatTrade;

package/dist/trade/index.d.ts

@@ -0,0 +1,3 @@
+export * from './abstract_trade';
+export * from './tx_result_check';
+export * from './tx_result_parse';

package/dist/trade/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract_trade"), exports);
+__exportStar(require("./tx_result_check"), exports);
+__exportStar(require("./tx_result_parse"), exports);

package/dist/trade/tx_result_check.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { OrderMessageType, PriceMessageType, StandardPoolInfoType, TradeResultType } from "@clonegod/ttd-common";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { EventEmitter } from 'events';
+import { TradeContext } from "../common/context";
+import { StandardSwapDetailType } from "../common/types";
+import { TransactionResultParser } from "./tx_result_parse";
+export declare class TransactionResultChecker {
+    env_args: any;
+    event_emitter: EventEmitter;
+    connection: Connection;
+    wallet: PublicKey;
+    context: TradeContext;
+    group_id: string;
+    txid: string;
+    trace_id: string;
+    price_msg: PriceMessageType;
+    order_msg: OrderMessageType;
+    pool_info: StandardPoolInfoType;
+    check_count: number;
+    transactionParser: TransactionResultParser;
+    constructor(env_args: any, event_emitter: EventEmitter, context: TradeContext, txid: string);
+    init_tx_status(): this;
+    check(): Promise<void>;
+    check_tx_result_interval(): Promise<void>;
+    map_swap_result_to_tx_result(swap_result: StandardSwapDetailType): TradeResultType;
+}

package/dist/trade/tx_result_check.js

@@ -0,0 +1,179 @@
+"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.TransactionResultChecker = void 0;
+const dist_1 = require("@clonegod/ttd-common/dist");
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../common/constants");
+const tx_result_parse_1 = require("./tx_result_parse");
+class TransactionResultChecker {
+    constructor(env_args, event_emitter, context, txid) {
+        this.env_args = env_args;
+        this.event_emitter = event_emitter;
+        this.context = context;
+        this.group_id = context.group_id;
+        this.connection = context.solana_trade_runtime.connection;
+        this.wallet = new web3_js_1.PublicKey(context.trade_runtime.wallet.public_key);
+        this.txid = txid;
+        this.price_msg = context.price_msg;
+        this.order_msg = context.order_msg;
+        this.pool_info = context.pool_info;
+        this.trace_id = context.order_msg.order_trace_id;
+        this.check_count = 0;
+        this.transactionParser = new tx_result_parse_1.TransactionResultParser(this.env_args, this.wallet, this.event_emitter);
+    }
+    init_tx_status() {
+        let empty_trade_result = JSON.parse(JSON.stringify({
+            group_id: this.context.group_id,
+            txid: this.txid
+        }));
+        this.event_emitter.emit(dist_1.TRANSACTION_STATE_PROCESSING, empty_trade_result);
+        return this;
+    }
+    check() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.check_tx_result_interval();
+        });
+    }
+    check_tx_result_interval() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const check_start_time = Date.now();
+            const check_interval = 1000;
+            const check_timeout = 30 * 1000;
+            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                this.check_count += 1;
+                (0, dist_1.log_info)(`check transaction start: seq=[${this.check_count}], txhash= ${this.txid}, trace_id=${this.trace_id}`);
+                try {
+                    if (Date.now() - check_start_time < check_timeout) {
+                        let tx_info = yield this.connection.getParsedTransaction(this.txid, {
+                            commitment: constants_1.COMMITMENT_LEVEL.CONFIRMED,
+                            maxSupportedTransactionVersion: 0,
+                        });
+                        if ((0, dist_1.isEmpty)(tx_info)) {
+                            return;
+                        }
+                        clearInterval(intervalId);
+                        let swap_result = this.transactionParser.parse_transaction_data(tx_info, this.pool_info);
+                        let trade_result = this.map_swap_result_to_tx_result(swap_result);
+                        if (trade_result.success) {
+                            this.event_emitter.emit(dist_1.TRANSACTION_STATE_SUCCESS, trade_result);
+                        }
+                        else {
+                            this.event_emitter.emit(dist_1.TRANSACTION_STATE_FAILED, trade_result);
+                        }
+                        setTimeout(() => {
+                            console.log('<====================================================');
+                            console.dir(trade_result, { depth: 8 });
+                            console.log('====================================================>');
+                        }, 0);
+                    }
+                    else {
+                        clearInterval(intervalId);
+                    }
+                }
+                catch (err) {
+                    (0, dist_1.log_error)('parse transaction error!', err);
+                }
+            }), check_interval);
+        });
+    }
+    map_swap_result_to_tx_result(swap_result) {
+        let { success, error_code, wallet, block_number, block_time: order_block_time, txid, tx_price, tokenA, tokenB, gas_fee } = swap_result;
+        let { pool_name, is_reverse_token } = this.pool_info;
+        let { chain_id, dex_id, unique_orderbook_id, pair, price_id, time: quote_time, ask, bid } = this.price_msg;
+        let { group_id, unique_order_msg_id, order_send_time, order_recv_time, order_submit_time, aToB } = this.order_msg;
+        let order_price = aToB ? bid.price : ask.price;
+        let server_info = (0, dist_1.getServerInfo)();
+        let total_order_time = (order_block_time + 500) - order_recv_time;
+        let order_end_time = Date.now();
+        let start_time = order_recv_time;
+        let end_time = order_end_time;
+        let total_time = total_order_time;
+        let time = {
+            block_time: quote_time.block_time,
+            stream_time: quote_time.stream_time,
+            quote_start_time: quote_time.quote_start_time,
+            quote_end_time: quote_time.quote_end_time,
+            price_time: quote_time.price_time,
+            total_quote_time: quote_time.total_quote_time,
+            order_send_time,
+            order_recv_time,
+            order_submit_time,
+            order_block_time,
+            total_order_time,
+            order_end_time,
+        };
+        let broadcast = [];
+        let trade_strategy = this.context.solana_trade_runtime.settings.strategy;
+        let send_type = trade_strategy.broadcast_type;
+        if (send_type === 'rpc') {
+            send_type = trade_strategy.speed === 'fast' ? 'mainnet' : 'mainnet-premium';
+        }
+        broadcast.push({
+            rpc: {
+                read: 'qn',
+                write: 'qn'
+            },
+            type: send_type,
+            fee: gas_fee
+        });
+        let trade_balance_change = {
+            tokenA: {
+                symbol: tokenA.symbol,
+                address: tokenA.address,
+                pre_bal: tokenA.pre_bal,
+                post_bal: tokenA.post_bal,
+                change: Number(tokenA.change),
+                decimals: tokenA.decimals,
+            },
+            tokenB: {
+                symbol: tokenB.symbol,
+                address: tokenB.address,
+                pre_bal: tokenB.pre_bal,
+                post_bal: tokenB.post_bal,
+                change: Number(tokenB.change),
+                decimals: tokenB.decimals,
+            },
+        };
+        if (is_reverse_token) {
+            let { tokenA, tokenB } = trade_balance_change;
+            trade_balance_change.tokenA = tokenB;
+            trade_balance_change.tokenB = tokenA;
+        }
+        let trade_extra_info = {
+            time,
+            broadcast,
+            server_info,
+        };
+        const trade_result = {
+            success,
+            error_code,
+            start_time,
+            end_time,
+            total_time,
+            group_id,
+            wallet,
+            chain_id,
+            pair,
+            dex_id,
+            txid,
+            unique_orderbook_id,
+            unique_order_msg_id,
+            order_price,
+            aToB,
+            tx_price,
+            balance: trade_balance_change,
+            execution: trade_extra_info,
+        };
+        return trade_result;
+    }
+}
+exports.TransactionResultChecker = TransactionResultChecker;

package/dist/trade/tx_result_parse.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { StandardPoolInfoType } from '@clonegod/ttd-common';
+import { ParsedTransactionWithMeta, PublicKey, TokenBalance } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import { StandardSwapDetailType } from '../common/types';
+export declare class TransactionResultParser {
+    env_args: any;
+    event_emitter: EventEmitter;
+    wallet_pubkey: PublicKey;
+    constructor(env_args: any, wallet_pubkey: PublicKey, event_emitter: EventEmitter);
+    parse_transaction_data(txData: ParsedTransactionWithMeta, pool_info: StandardPoolInfoType): StandardSwapDetailType;
+    getTokenBalance(owner: string, mint: string, tokenBalances: TokenBalance[]): number;
+}
+export declare const parse_tx_failed_error_code: (dex_id_list: string[], tx_failed_error_msg: string) => string;

package/dist/trade/tx_result_parse.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse_tx_failed_error_code = exports.TransactionResultParser = void 0;
+const dist_1 = require("@clonegod/ttd-common/dist");
+class TransactionResultParser {
+    constructor(env_args, wallet_pubkey, event_emitter) {
+        this.env_args = env_args;
+        this.wallet_pubkey = wallet_pubkey;
+        this.event_emitter = event_emitter;
+    }
+    parse_transaction_data(txData, pool_info) {
+        let success = true;
+        let error_code = '';
+        let { blockTime, meta, transaction, slot } = txData;
+        if (meta.err) {
+            success = false;
+            error_code = (0, exports.parse_tx_failed_error_code)(this.env_args.dex_id_list, JSON.stringify({
+                txid: transaction.signatures,
+                err: meta.err,
+                logMessages: meta.logMessages
+            }));
+        }
+        const { pool_address, tokenA, tokenB, is_reverse_token } = pool_info;
+        let txid = transaction.signatures[0];
+        const owner = this.wallet_pubkey.toBase58();
+        const { preTokenBalances, postTokenBalances, preBalances, postBalances } = meta;
+        const tokenA_PreBalance = this.getTokenBalance(owner, tokenA.address, preTokenBalances);
+        const tokenA_PostBalance = this.getTokenBalance(owner, tokenA.address, postTokenBalances);
+        const tokenB_PreBalance = this.getTokenBalance(owner, tokenB.address, preTokenBalances);
+        const tokenB_PostBalance = this.getTokenBalance(owner, tokenB.address, postTokenBalances);
+        blockTime = blockTime * 1000 || 0;
+        const tokenAChange = Number((tokenA_PostBalance - tokenA_PreBalance).toFixed(tokenA.decimals));
+        const tokenBChange = Number((tokenB_PostBalance - tokenB_PreBalance).toFixed(tokenB.decimals));
+        let price = "";
+        if (success) {
+            if (is_reverse_token) {
+                price = Math.abs(tokenAChange / tokenBChange).toFixed(tokenA.decimals);
+            }
+            else {
+                price = Math.abs(tokenBChange / tokenAChange).toFixed(tokenB.decimals);
+            }
+        }
+        const base_fee = 5000;
+        const total_fee = preBalances[0] - postBalances[0];
+        const priority_fee = total_fee - base_fee;
+        let gas_fee = {
+            base_fee,
+            priority_fee,
+            total_fee
+        };
+        const tradeResult = {
+            success,
+            error_code,
+            wallet: owner,
+            block_time: blockTime,
+            block_number: slot,
+            txid,
+            pool_address,
+            tokenA: Object.assign(Object.assign({}, tokenA), { pre_bal: tokenA_PreBalance, post_bal: tokenA_PostBalance, change: tokenAChange.toString() }),
+            tokenB: Object.assign(Object.assign({}, tokenB), { pre_bal: tokenB_PreBalance, post_bal: tokenB_PostBalance, change: tokenBChange.toString() }),
+            tx_price: price,
+            gas_fee
+        };
+        return tradeResult;
+    }
+    getTokenBalance(owner, mint, tokenBalances) {
+        var _a, _b;
+        const balance = (_b = (_a = tokenBalances === null || tokenBalances === void 0 ? void 0 : tokenBalances.find((e) => e.owner === owner && e.mint == mint)) === null || _a === void 0 ? void 0 : _a.uiTokenAmount) === null || _b === void 0 ? void 0 : _b.uiAmount;
+        if (typeof balance !== 'undefined' && balance !== null) {
+            return balance;
+        }
+        return 0;
+    }
+}
+exports.TransactionResultParser = TransactionResultParser;
+const parse_tx_failed_error_code = (dex_id_list, tx_failed_error_msg) => {
+    (0, dist_1.log_info)(`parse_tx_failed_error_code`, {
+        dex_id_list,
+        tx_failed_error_msg
+    });
+    let err_code = "";
+    if (dex_id_list.includes(dist_1.DEX_ID.RAYDIUM_AMM)) {
+        err_code = parse_raydium_failure(tx_failed_error_msg);
+    }
+    else if (dex_id_list.includes(dist_1.DEX_ID.ORCA_CLMM)) {
+        err_code = parse_orca_failure(tx_failed_error_msg);
+    }
+    if (!err_code) {
+        err_code = dist_1.TradeErrorCodeType.UNKOWN;
+    }
+    return err_code;
+};
+exports.parse_tx_failed_error_code = parse_tx_failed_error_code;
+function parse_raydium_failure(error_msg) {
+    if (error_msg.includes('0x28')) {
+        return dist_1.TradeErrorCodeType.InsufficientFunds;
+    }
+    if (error_msg.includes('0x1e') || error_msg.includes('exceeds desired slippage limit')) {
+        return dist_1.TradeErrorCodeType.AmountOutBelowMinimum;
+    }
+    return null;
+}
+function parse_orca_failure(error_msg) {
+    if (error_msg.includes('0x1]') || error_msg.includes('insufficient funds')) {
+        return dist_1.TradeErrorCodeType.InsufficientFunds;
+    }
+    if (error_msg.includes('0x1794') || error_msg.includes('below minimum threshold')) {
+        return dist_1.TradeErrorCodeType.AmountOutBelowMinimum;
+    }
+    if (error_msg.includes('0xbc4') || error_msg.includes('expected this account to be already initialized')) {
+        return dist_1.TradeErrorCodeType.AccountNotInitialized;
+    }
+    if (error_msg.includes('0x1787') || error_msg.includes('Invalid tick array sequence')) {
+        return dist_1.TradeErrorCodeType.InvalidTickArraySequence;
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-sol-common",
-    "version": "1.0.32",
+    "version": "1.0.34",
     "description": "",
     "main": "dist/index.js",
     "types": "types/index.d.ts",
@@ -13,7 +13,8 @@
         "push": "npm run build && npm publish"
     },
     "dependencies": {
-        "@clonegod/ttd-common": "1.0.135",
+        "@clonegod/ttd-common": "1.0.145",
+        "@solana/web3.js": "1.91.6",
         "@irys/sdk": "^0.2.10",
         "@metaplex-foundation/mpl-token-metadata": "^2.5.2",
         "axios": "^1.2.3",