@clonegod/ttd-sol-common 2.0.7 → 2.0.9

package/dist/common/constants.d.ts

@@ -0,0 +1,5 @@
+export declare enum COMMITMENT_LEVEL {
+    PROCESSED = "processed",
+    CONFIRMED = "confirmed",
+    _FINALIZED = "finalized"
+}

package/dist/common/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMITMENT_LEVEL = void 0;
+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 = {}));

package/dist/common/index.d.ts

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

package/dist/common/index.js

@@ -0,0 +1,17 @@
+"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);

package/dist/index.d.ts

@@ -1,2 +1,4 @@
-export * from './quote';
 export * from './types';
+export * from './common';
+export * from './quote';
+export * from './trade';

package/dist/index.js

@@ -14,5 +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("./quote"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./quote"), exports);
+__exportStar(require("./trade"), exports);

package/dist/trade/index.d.ts

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

package/dist/trade/index.js

@@ -0,0 +1,18 @@
+"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("./tx_result_check"), exports);
+__exportStar(require("./tx_result_parse"), exports);

package/dist/trade/tx_result_check.d.ts

@@ -0,0 +1,28 @@
+import { OrderMessageType, PriceMessageType, StandardPoolInfoType, StandardSwapDetailType, TradeResultType } from "@clonegod/ttd-core";
+import { AbstractTransactionResultCheck, TradeContext } from "@clonegod/ttd-core/dist";
+import { Connection } from "@solana/web3.js";
+import { EventEmitter } from 'events';
+import { TransactionResultParser } from "./tx_result_parse";
+export declare class TransactionResultChecker extends AbstractTransactionResultCheck {
+    env_args: any;
+    event_emitter: EventEmitter;
+    wallet: string;
+    context: TradeContext;
+    group_id: string;
+    txid: string;
+    trace_id: string;
+    price_msg: PriceMessageType;
+    order_msg: OrderMessageType;
+    pool_info: StandardPoolInfoType;
+    intervalId: any;
+    check_count: number;
+    transactionParser: TransactionResultParser;
+    trade_result_already_processed: boolean;
+    connection: Connection;
+    constructor(env_args: any, event_emitter: EventEmitter);
+    init_tx_status(): this;
+    check(): Promise<void>;
+    on_subscibe_transaction(): 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,227 @@
+"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-core/dist");
+const web3_js_1 = require("@solana/web3.js");
+const tx_result_parse_1 = require("./tx_result_parse");
+const common_1 = require("../common");
+class TransactionResultChecker extends dist_1.AbstractTransactionResultCheck {
+    constructor(env_args, event_emitter) {
+        super(env_args, event_emitter);
+        this.env_args = env_args;
+        this.event_emitter = event_emitter;
+        this.connection = new web3_js_1.Connection(env_args.rpc_endpoint, {
+            commitment: common_1.COMMITMENT_LEVEL.CONFIRMED,
+        });
+        this.check_count = 0;
+        this.transactionParser = new tx_result_parse_1.TransactionResultParser(this.env_args, new web3_js_1.PublicKey(this.wallet), this.event_emitter);
+        this.trade_result_already_processed = false;
+    }
+    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();
+            this.on_subscibe_transaction();
+        });
+    }
+    on_subscibe_transaction() {
+        this.event_emitter.once(dist_1.LOCAL_EVENT_NAME.EVENT_WALLET_TRANSACTION + '#' + this.txid, (messageStr) => {
+            try {
+                this.trade_result_already_processed = true;
+                (0, dist_1.log_debug)('on events: EVENT_WALLET_TRANSACTION', messageStr);
+                let messageObj = messageStr;
+                if (typeof messageStr === 'string') {
+                    messageObj = JSON.parse(messageStr);
+                }
+                const result = messageObj.params.result;
+                const _txid = result.signature;
+                const slot = result.slot;
+                (0, dist_1.log_info)('check txid:', { _txid, txid: this.txid, slot });
+                result.transaction.transaction.signatures = [_txid];
+                let tx_result = {
+                    slot,
+                    transaction: result.transaction.transaction,
+                    meta: result.transaction.meta,
+                    blockTime: Date.now() / 1000,
+                    version: result.transaction.version
+                };
+                let swap_result = this.transactionParser.parse_transaction_data(tx_result, 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);
+                }
+                console.log('<----------------------------------------------------');
+                console.dir(trade_result, { depth: 8 });
+                console.log('---------------------------------------------------->');
+            }
+            catch (err) {
+                (0, dist_1.log_error)('parse geyser stream message error!', err);
+                return;
+            }
+        });
+    }
+    check_tx_result_interval() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const check_start_time = Date.now();
+            const check_interval = parseInt(process.env.CHECK_TX_RESULT_INTERVAL_MILLS || '3000');
+            const check_timeout = parseInt(process.env.CHECK_TX_RESULT_TIMEOUT_MILLS || '10000');
+            (0, dist_1.log_info)(`check transaction start: check_interval=${check_interval}, check_timeout=${check_timeout}`);
+            if (check_interval >= check_timeout) {
+                (0, dist_1.log_warn)(`check_interval=${check_interval} >= check_timeout=${check_timeout}, check_tx_result_interval failed!`);
+                return;
+            }
+            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                this.check_count += 1;
+                (0, dist_1.log_info)(`check transaction: seq=[${this.check_count}], txhash= ${this.txid}, trace_id=${this.trace_id}`);
+                try {
+                    if (Date.now() - check_start_time < check_timeout) {
+                        let tx_result = yield this.connection.getParsedTransaction(this.txid, {
+                            commitment: common_1.COMMITMENT_LEVEL.CONFIRMED,
+                            maxSupportedTransactionVersion: 0,
+                        });
+                        if ((0, dist_1.isEmpty)(tx_result)) {
+                            return;
+                        }
+                        clearInterval(intervalId);
+                        let swap_result = this.transactionParser.parse_transaction_data(tx_result, this.pool_info);
+                        let trade_result = this.map_swap_result_to_tx_result(swap_result);
+                        if (this.trade_result_already_processed) {
+                            (0, dist_1.log_warn)(`trade_result_already_processed=${this.trade_result_already_processed}, ignore trade result fetch by interval check!`);
+                        }
+                        else {
+                            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);
+                            }
+                            console.log('<====================================================');
+                            console.dir(trade_result, { depth: 8 });
+                            console.log('====================================================>');
+                        }
+                    }
+                    else {
+                        clearInterval(intervalId);
+                    }
+                }
+                catch (err) {
+                    clearInterval(intervalId);
+                    (0, dist_1.log_error)('parse transaction error!', err);
+                }
+            }), check_interval);
+            this.intervalId = intervalId;
+        });
+    }
+    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 order_end_time = Date.now();
+        let start_time = order_recv_time;
+        let end_time = order_end_time;
+        let total_time = end_time - start_time;
+        let total_order_time = total_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,
+            order_end_time,
+            total_order_time,
+        };
+        let broadcast = [];
+        let trade_strategy = this.context.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 c_id = this.order_msg.c_id || '';
+        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,
+            c_id
+        };
+        return trade_result;
+    }
+}
+exports.TransactionResultChecker = TransactionResultChecker;

package/dist/trade/tx_result_parse.d.ts

@@ -0,0 +1,12 @@
+import { StandardPoolInfoType, StandardSwapDetailType } from '@clonegod/ttd-core';
+import { ParsedTransactionWithMeta, PublicKey, TokenBalance } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+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,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse_tx_failed_error_code = exports.TransactionResultParser = void 0;
+const dist_1 = require("@clonegod/ttd-core/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 = undefined;
+        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;
+        let priority_fee = 0;
+        let total_fee = 0;
+        total_fee = preBalances[0] - postBalances[0];
+        priority_fee = Math.abs(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 }),
+            tokenB: Object.assign(Object.assign({}, tokenB), { pre_bal: tokenB_PreBalance, post_bal: tokenB_PostBalance, change: tokenBChange }),
+            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_amm_failure(tx_failed_error_msg);
+    }
+    else if (dex_id_list.includes(dist_1.DEX_ID.RAYDIUM_CLMM)) {
+        err_code = parse_raydium_clmm_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) {
+        if (tx_failed_error_msg.includes('exceeded CUs meter at BPF instruction')) {
+            err_code = dist_1.TradeErrorCodeType.ExceededCUsLimit;
+        }
+        if (tx_failed_error_msg.includes('insufficient funds')) {
+            return dist_1.TradeErrorCodeType.InsufficientFunds;
+        }
+    }
+    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_amm_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_raydium_clmm_failure(error_msg) {
+    if (error_msg.includes('Computational budget exceeded')) {
+        return dist_1.TradeErrorCodeType.ExceededCUsLimit;
+    }
+    if (error_msg.includes('0x1786') || error_msg.includes('Too little output received')) {
+        return dist_1.TradeErrorCodeType.AmountOutBelowMinimum;
+    }
+    if (error_msg.includes('0x178c') || error_msg.includes('Invaild first tick array account')) {
+        return dist_1.TradeErrorCodeType.InvalidTickArraySequence;
+    }
+    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": "2.0.7",
+  "version": "2.0.9",
   "description": "",
   "main": "dist/index.js",
   "types": "types/index.d.ts",

package/src/common/constants.ts

@@ -0,0 +1,14 @@
+/**
+ * Solana 常量定义
+ * 这些常量后续会移到 ttd-sol-common 包中
+ */
+
+/**
+ * Solana 连接确认级别
+ */
+export enum COMMITMENT_LEVEL {
+    PROCESSED = "processed",
+    CONFIRMED = "confirmed",
+    _FINALIZED = "finalized"
+}
+

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export * from './constants'
+

package/src/index.ts

@@ -1,3 +1,5 @@
-export * from './quote'
 export * from './types'
+export * from './common'
+export * from './quote'
+export * from './trade'
 

package/src/trade/index.ts

@@ -0,0 +1,2 @@
+export * from './tx_result_check'
+export * from './tx_result_parse'

package/src/trade/tx_result_check.ts

@@ -0,0 +1,298 @@
+import { OrderMessageType, PriceMessageType, StandardPoolInfoType, StandardSwapDetailType, TradeBroadcastType, TradeResultBalanceChangeType, TradeResultType, TradeTimeFlowType } from "@clonegod/ttd-core"
+import { AbstractTransactionResultCheck, getServerInfo, isEmpty, LOCAL_EVENT_NAME, LOG, log_debug, log_error, log_info, log_warn, TradeContext, TRANSACTION_STATE_FAILED, TRANSACTION_STATE_PROCESSING, TRANSACTION_STATE_SUCCESS } from "@clonegod/ttd-core/dist"
+import { Connection, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js"
+import { EventEmitter } from 'events'
+import { TransactionResultParser } from "./tx_result_parse"
+import { COMMITMENT_LEVEL } from "../common"
+
+
+
+/**
+ * 获取Transaction的交易结果
+ */
+export class TransactionResultChecker extends AbstractTransactionResultCheck {
+    env_args: any
+    event_emitter: EventEmitter
+    wallet: string
+    
+    context: TradeContext
+    group_id: string
+    txid: string
+    
+    trace_id: string
+    price_msg: PriceMessageType
+    order_msg: OrderMessageType
+    pool_info: StandardPoolInfoType
+    
+    intervalId: any
+    check_count: number
+    transactionParser: TransactionResultParser
+    
+    trade_result_already_processed: boolean
+    
+    connection: Connection
+    
+    constructor(env_args: any, event_emitter: EventEmitter) {
+        super(env_args, event_emitter)
+        this.env_args = env_args
+        this.event_emitter = event_emitter
+
+        
+        this.connection = new Connection(env_args.rpc_endpoint, {
+            commitment: COMMITMENT_LEVEL.CONFIRMED,
+        })
+
+        this.check_count = 0
+        this.transactionParser = new TransactionResultParser(this.env_args, new PublicKey(this.wallet), this.event_emitter)
+        this.trade_result_already_processed = false
+    }
+
+    /**
+     * set trade initial status: PROCESSING
+     */
+    init_tx_status() {
+        let empty_trade_result = JSON.parse(JSON.stringify({
+            group_id: this.context.group_id,
+            txid: this.txid
+        }))
+        this.event_emitter.emit(TRANSACTION_STATE_PROCESSING, empty_trade_result)
+        return this
+    }
+
+    async check() {
+        this.check_tx_result_interval()
+        this.on_subscibe_transaction()
+    }
+
+    /**
+     * 从第三方服务(helius geyser ws)订阅Transaction结果
+     */
+    on_subscibe_transaction() {
+        this.event_emitter.once(LOCAL_EVENT_NAME.EVENT_WALLET_TRANSACTION + '#' + this.txid, (messageStr) => {
+            try {
+                this.trade_result_already_processed = true
+                log_debug('on events: EVENT_WALLET_TRANSACTION', messageStr)
+
+                let messageObj = messageStr
+                if(typeof messageStr === 'string') {
+                    messageObj = JSON.parse(messageStr)
+                }
+
+                const result = messageObj.params.result
+                const _txid = result.signature // Extract the signature
+                const slot = result.slot
+                log_info('check txid:', { _txid, txid: this.txid, slot})
+
+                // set txid for parse
+                result.transaction.transaction.signatures = [_txid]
+
+                let tx_result:ParsedTransactionWithMeta = {
+                    slot,
+                    transaction: result.transaction.transaction,
+                    meta: result.transaction.meta,
+                    blockTime: Date.now() / 1000,
+                    version: result.transaction.version
+                }
+                
+                let swap_result = this.transactionParser.parse_transaction_data(tx_result, this.pool_info)
+
+                let trade_result = this.map_swap_result_to_tx_result(swap_result)
+                if (trade_result.success) {
+                    this.event_emitter.emit(TRANSACTION_STATE_SUCCESS, trade_result)
+                } else {
+                    this.event_emitter.emit(TRANSACTION_STATE_FAILED, trade_result)
+                }
+
+                console.log('<----------------------------------------------------')
+                console.dir(trade_result, { depth: 8 })
+                console.log('---------------------------------------------------->')
+            } catch (err) {
+                log_error('parse geyser stream message error!', err)
+                return
+            }
+        })
+    }
+
+
+    /**
+     * 主动确认交易结果
+     */
+    async check_tx_result_interval() {
+        const check_start_time = Date.now()
+        const check_interval = parseInt(process.env.CHECK_TX_RESULT_INTERVAL_MILLS || '3000')
+        const check_timeout = parseInt(process.env.CHECK_TX_RESULT_TIMEOUT_MILLS || '10000')
+
+        log_info(`check transaction start: check_interval=${check_interval}, check_timeout=${check_timeout}`)
+
+        if(check_interval >=  check_timeout) {
+            log_warn(`check_interval=${check_interval} >= check_timeout=${check_timeout}, check_tx_result_interval failed!`)
+            return
+        }
+
+        const intervalId = setInterval(async () => {
+            this.check_count += 1
+            log_info(`check transaction: seq=[${this.check_count}], txhash= ${this.txid}, trace_id=${this.trace_id}`)
+            try {
+                if (Date.now() - check_start_time < check_timeout) {
+                    let tx_result:ParsedTransactionWithMeta = await this.connection.getParsedTransaction(this.txid, {
+                        commitment: COMMITMENT_LEVEL.CONFIRMED,
+                        maxSupportedTransactionVersion: 0,
+                    })
+                    if (isEmpty(tx_result)) {
+                        return
+                    }
+                    // 查询到结果
+                    clearInterval(intervalId)
+
+                    let swap_result = this.transactionParser.parse_transaction_data(tx_result, this.pool_info)
+                    let trade_result = this.map_swap_result_to_tx_result(swap_result)
+
+                    if(this.trade_result_already_processed) {
+                        log_warn(`trade_result_already_processed=${this.trade_result_already_processed}, ignore trade result fetch by interval check!`)
+                    } else {
+                        if (trade_result.success) {
+                            this.event_emitter.emit(TRANSACTION_STATE_SUCCESS, trade_result)
+                        } else {
+                            this.event_emitter.emit(TRANSACTION_STATE_FAILED, trade_result)
+                        }
+
+                        console.log('<====================================================')
+                        console.dir(trade_result, { depth: 8 })
+                        console.log('====================================================>')
+                    }
+                } else {
+                    // 超时未查询到结果
+                    clearInterval(intervalId)
+                }
+            } catch (err) {
+                // 解析结果异常
+                clearInterval(intervalId)
+                log_error('parse transaction error!', err)
+            }
+        }, check_interval)
+
+        this.intervalId = intervalId
+    }
+
+
+    map_swap_result_to_tx_result(swap_result: StandardSwapDetailType): TradeResultType {
+        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 = getServerInfo()
+
+        let order_end_time = Date.now()
+
+        let start_time = order_recv_time
+        let end_time = order_end_time
+        let total_time = end_time - start_time
+
+        // block_time 只精确到秒，估算耗时+1000ms
+        // let total_order_time = (order_block_time + 1000) - order_recv_time
+        let total_order_time = total_time
+
+        let time: TradeTimeFlowType = {
+            // Quote Consumed Time
+            block_time: quote_time.block_time,                  // 触发本次quote询价的交易，链上的出块时间
+            stream_time: quote_time.stream_time,                // 监听到链上发生新交易的时间（stream/webhook）
+            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,      // 询价耗时：price_time - stream_time
+
+            // Trade Consumed Time
+            order_send_time,                // cex 发送下单消息的时间
+            order_recv_time,                // dex 接收到下单消息的时间
+            order_submit_time,              // dex 提交交易时间
+            order_block_time,               // 交易所属block的出块时间
+            order_end_time,                 // dex 解析得到交易结果的时间
+            total_order_time,               // 交易总耗时: order_end_time - order_recv_time
+        }
+
+        let broadcast: TradeBroadcastType[] = []
+        let trade_strategy = this.context.trade_runtime.settings.strategy
+        let send_type = trade_strategy.broadcast_type as string
+        if (send_type === 'rpc') {
+            send_type = trade_strategy.speed === 'fast' ? 'mainnet' : 'mainnet-premium'
+        }
+        broadcast.push(
+            {
+                rpc: {
+                    read: 'qn',
+                    write: 'qn'
+                },  // quicknode | trongrid ...
+                type: send_type, // 主网，私单，自建节点
+                fee: gas_fee // gas
+            }
+        )
+
+        let trade_balance_change: TradeResultBalanceChangeType = {
+            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,
+        }
+
+        // 返回c_id给cex
+        const c_id = this.order_msg.c_id || ''
+
+        const trade_result: TradeResultType = {
+            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,
+            c_id
+        }
+
+        return trade_result
+    }
+
+}

package/src/trade/tx_result_parse.ts

@@ -0,0 +1,212 @@
+
+import { StandardPoolInfoType, StandardSwapDetailType, TradeGasFeeType } from '@clonegod/ttd-core';
+import { DEX_ID, log_info, TradeErrorCodeType } from '@clonegod/ttd-core/dist';
+import { ParsedTransactionWithMeta, PublicKey, TokenBalance } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+
+export class TransactionResultParser {
+
+    env_args: any
+    event_emitter: EventEmitter
+    wallet_pubkey: PublicKey
+
+    constructor(env_args: any, wallet_pubkey: PublicKey, event_emitter: EventEmitter) {
+        this.env_args = env_args
+        this.wallet_pubkey = wallet_pubkey
+        this.event_emitter = event_emitter
+    }
+
+    /**
+     * 解析 Transaction Data
+     */
+    parse_transaction_data(txData: ParsedTransactionWithMeta, pool_info: StandardPoolInfoType): StandardSwapDetailType {
+        let success: boolean = true
+        let error_code: string = undefined
+
+        let { blockTime, meta, transaction, slot } = txData
+
+        if (meta.err) {
+            // 交易失败，解析错误码！
+            success = false
+            error_code = 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 // blockTime - Unix timestamp
+
+        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) {
+                // SOL/POPCAT
+                price = Math.abs(tokenAChange / tokenBChange).toFixed(tokenA.decimals)
+            } else {
+                // SOL/USDT
+                price = Math.abs(tokenBChange / tokenAChange).toFixed(tokenB.decimals)
+            }
+        }
+
+        const base_fee = 5000
+        let priority_fee = 0
+        let total_fee = 0
+
+        total_fee = preBalances[0] - postBalances[0]
+        priority_fee = Math.abs(total_fee - base_fee)
+
+
+        let gas_fee: TradeGasFeeType = {
+            base_fee,
+            priority_fee,
+            total_fee
+        }
+
+        const tradeResult: StandardSwapDetailType = {
+            success,
+            error_code,
+            wallet: owner,
+            block_time: blockTime,
+            block_number: slot,
+            txid,
+            pool_address,
+            tokenA: {
+                ...tokenA,
+                pre_bal: tokenA_PreBalance,
+                post_bal: tokenA_PostBalance,
+                change: tokenAChange
+            },
+            tokenB: {
+                ...tokenB,
+                pre_bal: tokenB_PreBalance,
+                post_bal: tokenB_PostBalance,
+                change: tokenBChange
+            },
+            tx_price: price,
+            gas_fee
+        }
+        return tradeResult
+    }
+
+    getTokenBalance(owner: string, mint: string, tokenBalances: TokenBalance[]) {
+        const balance = tokenBalances?.find((e) => e.owner === owner && e.mint == mint)?.uiTokenAmount?.uiAmount
+        if (typeof balance !== 'undefined' && balance !== null) {
+            return balance
+        }
+        return 0
+    }
+}
+
+
+/**
+ * 解析交易失败的原因
+ * 
+ * @param failed_msg 交易失败的相关信息
+ * @returns 
+ */
+export const parse_tx_failed_error_code = (dex_id_list: string[], tx_failed_error_msg: string): string => {
+    log_info(`parse_tx_failed_error_code`, {
+        dex_id_list,
+        tx_failed_error_msg
+    })
+
+    let err_code = ""
+
+    if (dex_id_list.includes(DEX_ID.RAYDIUM_AMM)) {
+        err_code = parse_raydium_amm_failure(tx_failed_error_msg)
+    }
+    else if (dex_id_list.includes(DEX_ID.RAYDIUM_CLMM)) {
+        err_code = parse_raydium_clmm_failure(tx_failed_error_msg)
+    }
+    else if (dex_id_list.includes(DEX_ID.ORCA_CLMM)) {
+        err_code = parse_orca_failure(tx_failed_error_msg)
+    }
+
+    // common errors
+    if (!err_code) {
+        if (tx_failed_error_msg.includes('exceeded CUs meter at BPF instruction')) {
+            err_code = TradeErrorCodeType.ExceededCUsLimit
+        }
+
+        if (tx_failed_error_msg.includes('insufficient funds')) {
+            return TradeErrorCodeType.InsufficientFunds
+        }
+    }
+
+    if (!err_code) {
+        err_code = TradeErrorCodeType.UNKOWN
+    }
+
+    return err_code
+
+}
+
+
+/**
+ * Raydium AMM 错误码
+ * @param error_msg 
+ */
+function parse_raydium_amm_failure(error_msg: string) {
+    if (error_msg.includes('0x28')) {
+        return TradeErrorCodeType.InsufficientFunds
+    }
+    if (error_msg.includes('0x1e') || error_msg.includes('exceeds desired slippage limit')) {
+        return TradeErrorCodeType.AmountOutBelowMinimum
+    }
+    return null
+}
+
+/**
+ * Raydium CLMM 错误码
+ * @param error_msg 
+ */
+function parse_raydium_clmm_failure(error_msg: string) {
+    if (error_msg.includes('Computational budget exceeded')) {
+        return TradeErrorCodeType.ExceededCUsLimit
+    }
+    if (error_msg.includes('0x1786') || error_msg.includes('Too little output received')) {
+        return TradeErrorCodeType.AmountOutBelowMinimum
+    }
+    if (error_msg.includes('0x178c') || error_msg.includes('Invaild first tick array account')) {
+        return TradeErrorCodeType.InvalidTickArraySequence
+    }
+    return null
+}
+
+/**
+ * ORCA 错误码
+ *
+ * https://github.com/coral-xyz/anchor/blob/master/lang/src/error.rs#L185
+ */
+function parse_orca_failure(error_msg: string) {
+    if (error_msg.includes('0x1]') || error_msg.includes('insufficient funds')) {
+        return TradeErrorCodeType.InsufficientFunds
+    }
+    if (error_msg.includes('0x1794') || error_msg.includes('below minimum threshold')) {
+        return TradeErrorCodeType.AmountOutBelowMinimum
+    }
+    if (error_msg.includes('0xbc4') || error_msg.includes('expected this account to be already initialized')) {
+        return TradeErrorCodeType.AccountNotInitialized
+    }
+    if (error_msg.includes('0x1787') || error_msg.includes('Invalid tick array sequence')) {
+        return TradeErrorCodeType.InvalidTickArraySequence
+    }
+    return null
+}
+