@clonegod/ttd-sui-common 1.0.34 → 1.0.36

package/dist/ttd-sui-common/src/trade/abstract_sui_dex_trade_plus.js

@@ -0,0 +1,216 @@
+"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.AbstractSuiDexTradePlus = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const ed25519_1 = require("@mysten/sui/keypairs/ed25519");
+const client_1 = require("@mysten/sui/client");
+const index_1 = require("../index");
+const redis_1 = require("../redis");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+class AbstractSuiDexTradePlus extends dist_1.AbastrcatTrade {
+    constructor(appConfig, grpcClient) {
+        super();
+        this.appConfig = appConfig;
+        this.walletMode = 'multi';
+        this.walletAddresses = [];
+        this.currentWalletAddress = '';
+        this.grpcClient = grpcClient;
+        this.initConfigs();
+        this.chainNameLower = this.appConfig.env_args.chain_id.toLowerCase();
+        this.redisClient = new redis_1.SimpleRedisClient(`${this.chainNameLower}:tx`);
+    }
+    initSuiClient() {
+        const sui_rpc_url = process.env.SUI_RPC_URL || 'https://fullnode.mainnet.sui.io:443';
+        this.sui_client = new client_1.SuiClient({ url: sui_rpc_url });
+        (0, dist_1.log_info)(`Sui客户端已初始化: ${sui_rpc_url}`);
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.initSuiClient();
+            const walletGroupIds = process.env.SUI_WALLET_GROUP_IDS || '';
+            this.walletMode = walletGroupIds && walletGroupIds.trim().split(',').length > 0 ? 'multi' : 'single';
+            if (this.walletMode === 'multi') {
+                let wallet_infos = (0, dist_1.load_wallet_multi)(walletGroupIds.split(','), false);
+                this.group_wallets = wallet_infos.map(info => ed25519_1.Ed25519Keypair.fromSecretKey(info.private_key));
+                this.walletAddresses = this.group_wallets.map(keypair => keypair.getPublicKey().toSuiAddress());
+                (0, dist_1.log_info)(`组钱包已初始化，数量: ${this.group_wallets.length}`, this.walletAddresses);
+            }
+            else {
+                const { private_key } = this.appConfig.trade_runtime.wallet;
+                this.wallet = ed25519_1.Ed25519Keypair.fromSecretKey(private_key);
+                this.currentWalletAddress = this.wallet.getPublicKey().toSuiAddress();
+                this.walletAddresses = [this.currentWalletAddress];
+                (0, dist_1.log_info)(`单钱包已初始化，walletAddress= ${this.currentWalletAddress}`);
+            }
+            this.transactionSender = new index_1.SuiTxSender(this.appConfig, this.sui_client, this.grpcClient);
+        });
+    }
+    getWalletMode() {
+        return this.walletMode;
+    }
+    getSingleWallet() {
+        if (this.walletMode !== 'single' || !this.wallet) {
+            throw new Error('Single wallet not available in multi-wallet mode or not initialized');
+        }
+        return this.wallet;
+    }
+    getGroupWallets() {
+        if (this.walletMode !== 'multi' || !this.group_wallets) {
+            throw new Error('Group wallets not available in single-wallet mode or not initialized');
+        }
+        return this.group_wallets;
+    }
+    getWalletAddresses() {
+        return this.walletAddresses;
+    }
+    chooseWallet(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.getWalletMode() === 'single') {
+                return this.getSingleWallet();
+            }
+            const { inputToken } = this.determineInputOutputTokens(context.order_msg, context.pool_info);
+            console.log('inputToken', inputToken);
+            const requiredAmount = new decimal_js_1.default(context.order_msg.amount);
+            const wallet_assets = yield this.redisClient.hgetall('sui:wallet:assets');
+            if (!wallet_assets || Object.keys(wallet_assets).length === 0) {
+                throw new Error('没有找到钱包资产信息，请确保钱包监控服务正在运行');
+            }
+            const wallet_assets_map = {};
+            for (const [walletAddress, assetsJson] of Object.entries(wallet_assets)) {
+                try {
+                    wallet_assets_map[walletAddress] = JSON.parse(assetsJson);
+                }
+                catch (error) {
+                    console.warn(`解析钱包资产数据失败: ${walletAddress}`, error);
+                }
+            }
+            const availableWallets = [];
+            const allWallets = [];
+            for (const [walletAddress, assets] of Object.entries(wallet_assets_map)) {
+                try {
+                    const wallet = (_a = this.group_wallets) === null || _a === void 0 ? void 0 : _a.find(w => w.getPublicKey().toSuiAddress().toLowerCase() === walletAddress.toLowerCase());
+                    if (!wallet) {
+                        continue;
+                    }
+                    const tokenAsset = (_b = assets.tokens) === null || _b === void 0 ? void 0 : _b.find((token) => token.tokenaddr.toLowerCase() === inputToken.address.toLowerCase());
+                    let tokenBalance = (tokenAsset === null || tokenAsset === void 0 ? void 0 : tokenAsset.balance) || '0';
+                    const balanceDecimal = new decimal_js_1.default(tokenBalance);
+                    if (balanceDecimal.gte(requiredAmount)) {
+                        availableWallets.push({
+                            wallet,
+                            balance: tokenBalance
+                        });
+                    }
+                    else {
+                        console.log(`钱包 ${walletAddress} 余额不足: ${tokenBalance} ${inputToken.symbol} < ${requiredAmount} ${inputToken.symbol}`);
+                    }
+                    allWallets.push({
+                        wallet,
+                        balance: tokenBalance
+                    });
+                }
+                catch (error) {
+                    console.warn(`处理钱包资产时出错: ${walletAddress}`, error);
+                }
+            }
+            if (availableWallets.length === 0) {
+                let error_msg = `all wallets are insufficient, required: ${requiredAmount} ${inputToken.symbol}`;
+                (0, dist_1.log_warn)(error_msg);
+                allWallets.forEach((walletInfo, index) => {
+                    const walletAddress = walletInfo.wallet.getPublicKey().toSuiAddress();
+                    const shortAddress = walletAddress.substring(0, 6) + '...' + walletAddress.substring(walletAddress.length - 4);
+                    console.log(`${index + 1}. ${shortAddress}: ${walletInfo.balance} ${inputToken.symbol}`);
+                });
+                throw new Error(error_msg);
+            }
+            console.log('availableWallets', availableWallets.map(w => w.wallet.getPublicKey().toSuiAddress()));
+            const wallet_last_used = yield this.redisClient.hgetall('sui:wallet:last_used');
+            for (const availableWallet of availableWallets) {
+                const walletAddress = availableWallet.wallet.getPublicKey().toSuiAddress();
+                const lastUsedData = wallet_last_used === null || wallet_last_used === void 0 ? void 0 : wallet_last_used[walletAddress];
+                if (lastUsedData) {
+                    try {
+                        const lastUsedInfo = JSON.parse(lastUsedData);
+                        availableWallet.lastUsedAt = lastUsedInfo.lastUsedAt;
+                    }
+                    catch (error) {
+                        console.warn(`解析钱包最后使用时间失败: ${walletAddress}`, error);
+                    }
+                }
+                else {
+                    yield this.redisClient.hsetValue('sui:wallet:last_used', walletAddress, JSON.stringify({
+                        lastUsedAt: 0,
+                        lastUsedTime: new Date(0).toISOString()
+                    }), 24 * 60 * 60);
+                    availableWallet.lastUsedAt = 0;
+                }
+            }
+            let selectedWallet;
+            let selectionStrategy;
+            if (availableWallets.length === 1) {
+                selectedWallet = availableWallets[0].wallet;
+                selectionStrategy = 'OnlyOne';
+            }
+            else {
+                const hasUsageHistory = wallet_last_used && Object.keys(wallet_last_used).length > 0;
+                if (hasUsageHistory) {
+                    availableWallets.sort((a, b) => {
+                        const aTime = a.lastUsedAt || 0;
+                        const bTime = b.lastUsedAt || 0;
+                        return aTime - bTime;
+                    });
+                    selectedWallet = availableWallets[0].wallet;
+                    selectionStrategy = 'MaxLastUsed';
+                }
+                else {
+                    availableWallets.sort((a, b) => {
+                        const aBalance = new decimal_js_1.default(a.balance);
+                        const bBalance = new decimal_js_1.default(b.balance);
+                        return bBalance.cmp(aBalance);
+                    });
+                    selectedWallet = availableWallets[0].wallet;
+                    selectionStrategy = 'MaxBalance';
+                }
+            }
+            const selectedWalletAddress = selectedWallet.getPublicKey().toSuiAddress();
+            yield this.redisClient.hsetValue('sui:wallet:last_used', selectedWalletAddress, JSON.stringify({
+                lastUsedAt: Date.now(),
+                lastUsedTime: new Date().toISOString()
+            }), 24 * 60 * 60);
+            const selectedWalletInfo = availableWallets.find(w => w.wallet.getPublicKey().toSuiAddress() === selectedWalletAddress);
+            (0, dist_1.log_info)(`Choose wallet: ${selectionStrategy} -> ${selectedWalletAddress}, balance: ${selectedWalletInfo === null || selectedWalletInfo === void 0 ? void 0 : selectedWalletInfo.balance} ${inputToken.symbol}, required: ${requiredAmount} ${inputToken.symbol}`);
+            return selectedWallet;
+        });
+    }
+    determineInputOutputTokens(order_msg, pool_info) {
+        const { aToB } = order_msg;
+        const { tokenA, tokenB, quote_token } = pool_info;
+        const quoteToken = [tokenA, tokenB].find(token => token.symbol === quote_token);
+        const nonQuoteToken = [tokenA, tokenB].find(token => token.symbol !== quote_token);
+        const inputToken = aToB ? nonQuoteToken : quoteToken;
+        const outputToken = aToB ? quoteToken : nonQuoteToken;
+        if (!inputToken || !outputToken) {
+            throw new Error(`无法确定输入/输出代币: ${JSON.stringify({
+                tokenA: tokenA.symbol,
+                tokenB: tokenB.symbol,
+                quote: quote_token,
+                aToB
+            })}`);
+        }
+        return { inputToken, outputToken };
+    }
+}
+exports.AbstractSuiDexTradePlus = AbstractSuiDexTradePlus;

package/dist/ttd-sui-common/src/trade/check/index.d.ts

@@ -0,0 +1 @@
+export { TransactionResultChecker } from "./tx_result_checker";

package/dist/ttd-sui-common/src/trade/check/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionResultChecker = void 0;
+var tx_result_checker_1 = require("./tx_result_checker");
+Object.defineProperty(exports, "TransactionResultChecker", { enumerable: true, get: function () { return tx_result_checker_1.TransactionResultChecker; } });

package/dist/ttd-sui-common/src/trade/check/tx_result_checker.d.ts

@@ -0,0 +1,13 @@
+import { EnvArgs } from "@clonegod/ttd-core/dist";
+import { AbstractTransactionResultCheck } from "@clonegod/ttd-core/dist/trade";
+import { EventEmitter } from 'events';
+import { SuiTransactionParser } from "../parse/sui_tx_parser";
+import { LedgerService } from "../../index";
+export declare class TransactionResultChecker extends AbstractTransactionResultCheck {
+    transactionParser: SuiTransactionParser;
+    leadgerService: LedgerService;
+    constructor(env_args: EnvArgs, event_emitter: EventEmitter, wallet_address: string, ledgerService: LedgerService);
+    check_tx_result_interval(): Promise<void>;
+    on_subscibe_transaction(): void;
+    private processTransactionResult;
+}

package/dist/ttd-sui-common/src/trade/check/tx_result_checker.js

@@ -0,0 +1,111 @@
+"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 trade_1 = require("@clonegod/ttd-core/dist/trade");
+const sui_tx_parser_1 = require("../parse/sui_tx_parser");
+const index_1 = require("../../index");
+class TransactionResultChecker extends trade_1.AbstractTransactionResultCheck {
+    constructor(env_args, event_emitter, wallet_address, ledgerService) {
+        super(env_args, event_emitter);
+        this.transactionParser = new sui_tx_parser_1.SuiTransactionParser(wallet_address);
+        this.leadgerService = ledgerService;
+    }
+    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 || '30000');
+            if (check_interval >= check_timeout) {
+                return;
+            }
+            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 txReceipt = yield this.leadgerService.getTransaction(this.txid, ['*']);
+                        if (!txReceipt || (0, dist_1.isEmpty)(txReceipt)) {
+                            return;
+                        }
+                        txReceipt['transaction']['signatures'] = [];
+                        txReceipt = (0, index_1.decodeBytes)(txReceipt);
+                        (0, dist_1.log_info)(`Received transaction result via polling: ${this.txid}`);
+                        clearInterval(intervalId);
+                        yield this.processTransactionResult(txReceipt, 'interval');
+                    }
+                    else {
+                        clearInterval(intervalId);
+                    }
+                }
+                catch (err) {
+                    clearInterval(intervalId);
+                    (0, dist_1.log_error)('parse transaction error!', err);
+                }
+            }), check_interval);
+            this.intervalId = intervalId;
+        });
+    }
+    on_subscibe_transaction() {
+        this.event_emitter.once(`SUI_TX_RESULT_${this.txid}`, (response) => __awaiter(this, void 0, void 0, function* () {
+            (0, dist_1.log_info)(`receive tx result notification, txid=${this.txid}`);
+            if (response.transaction) {
+                this.processTransactionResult(response, 'grpc');
+                return;
+            }
+            for (let i = 1; i <= 6; i++) {
+                (0, dist_1.log_info)(`re-fetch tx result by ledgerService start, i=${i}, txid=${this.txid}`);
+                try {
+                    let txReceipt = yield this.leadgerService.getTransaction(this.txid, ['*']);
+                    if (txReceipt) {
+                        this.processTransactionResult(txReceipt, 'grpc2');
+                        break;
+                    }
+                }
+                catch (error) {
+                    (0, dist_1.log_warn)(`re-fetch tx result by ledgerService failed, i=${i}, txid=${this.txid}, error=${error.message}`);
+                }
+                yield (0, dist_1.sleep)(1000);
+            }
+        }));
+    }
+    processTransactionResult(txReceipt, source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 ${source} check!`);
+                return;
+            }
+            const swap_detail = yield this.transactionParser.parseTransaction(txReceipt, this.pool_info);
+            let trade_result = this.map_swap_result_to_tx_result(swap_detail);
+            this.trade_result_already_processed = true;
+            if (this.intervalId) {
+                clearInterval(this.intervalId);
+                this.intervalId = null;
+            }
+            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);
+            }
+            if (source === 'interval') {
+                console.log('--------------------- Transaction Result from Polling ---------------------');
+            }
+            else {
+                console.log('--------------------- Transaction Result from GRPC ---------------------');
+            }
+            console.log(JSON.stringify(trade_result, null, 2));
+            console.log('-----------------------------------------------------------------------------');
+        });
+    }
+}
+exports.TransactionResultChecker = TransactionResultChecker;

package/dist/ttd-sui-common/src/trade/index.d.ts

@@ -0,0 +1,4 @@
+export * from './send_tx';
+export * from './check';
+export * from './parse';
+export * from './abstract_sui_dex_trade_plus';

package/dist/ttd-sui-common/src/trade/index.js

@@ -0,0 +1,20 @@
+"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("./send_tx"), exports);
+__exportStar(require("./check"), exports);
+__exportStar(require("./parse"), exports);
+__exportStar(require("./abstract_sui_dex_trade_plus"), exports);

package/dist/ttd-sui-common/src/trade/parse/index.d.ts

@@ -0,0 +1 @@
+export { SuiTransactionParser } from "./sui_tx_parser";

package/dist/ttd-sui-common/src/trade/parse/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiTransactionParser = void 0;
+var sui_tx_parser_1 = require("./sui_tx_parser");
+Object.defineProperty(exports, "SuiTransactionParser", { enumerable: true, get: function () { return sui_tx_parser_1.SuiTransactionParser; } });

package/dist/ttd-sui-common/src/trade/parse/sui_tx_parser.d.ts

@@ -0,0 +1,13 @@
+import { StandardPoolInfoType, StandardSwapDetailType } from "@clonegod/ttd-core";
+export declare class SuiTransactionParser {
+    private walletAddress;
+    constructor(walletAddress: string);
+    parseTransaction(receipt: any, poolInfo: StandardPoolInfoType): Promise<StandardSwapDetailType>;
+    parse_transaction_result(tx_receipt: any, pool_info: StandardPoolInfoType): Promise<StandardSwapDetailType>;
+    private calculateGasFee;
+    private calc_tx_price;
+    private create_failed_result;
+    private parseErrorMsgToErrorCode;
+    private extractTimestamp;
+    private extractCheckpoint;
+}

package/dist/ttd-sui-common/src/trade/parse/sui_tx_parser.js

@@ -0,0 +1,167 @@
+"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.SuiTransactionParser = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const index_1 = require("../../index");
+class SuiTransactionParser {
+    constructor(walletAddress) {
+        this.walletAddress = walletAddress;
+    }
+    parseTransaction(receipt, poolInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            try {
+                if (((_c = (_b = (_a = receipt.transaction) === null || _a === void 0 ? void 0 : _a.effects) === null || _b === void 0 ? void 0 : _b.status) === null || _c === void 0 ? void 0 : _c.success) !== true || ((_e = (_d = receipt.transaction) === null || _d === void 0 ? void 0 : _d.balance_changes) === null || _e === void 0 ? void 0 : _e.length) === 0) {
+                    console.log('Transaction failed', {
+                        txid: (_f = receipt.transaction) === null || _f === void 0 ? void 0 : _f.digest,
+                        success: (_j = (_h = (_g = receipt.transaction) === null || _g === void 0 ? void 0 : _g.effects) === null || _h === void 0 ? void 0 : _h.status) === null || _j === void 0 ? void 0 : _j.success,
+                        balance_changes: (_l = (_k = receipt.transaction) === null || _k === void 0 ? void 0 : _k.balance_changes) === null || _l === void 0 ? void 0 : _l.length,
+                        reason: (_q = (_p = (_o = (_m = receipt.transaction) === null || _m === void 0 ? void 0 : _m.effects) === null || _o === void 0 ? void 0 : _o.status) === null || _p === void 0 ? void 0 : _p.error) === null || _q === void 0 ? void 0 : _q.kind
+                    });
+                    throw new Error('Transaction failed');
+                }
+                return yield this.parse_transaction_result(receipt, poolInfo);
+            }
+            catch (error) {
+                console.error('Error parsing transaction:', error);
+                return this.create_failed_result(receipt, poolInfo, error.message);
+            }
+        });
+    }
+    parse_transaction_result(tx_receipt, pool_info) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const txid = ((_a = tx_receipt.transaction) === null || _a === void 0 ? void 0 : _a.digest) || '';
+            let swap_detail = null;
+            let tokenAChangeAmount = new decimal_js_1.default(0);
+            let tokenBChangeAmount = new decimal_js_1.default(0);
+            const balanceChanges = ((_b = tx_receipt.transaction) === null || _b === void 0 ? void 0 : _b.balance_changes) || [];
+            console.dir({ txid, balance_changes: balanceChanges }, { depth: 4 });
+            for (const change of balanceChanges) {
+                if (change.address.toLowerCase() !== this.walletAddress.toLowerCase()) {
+                    continue;
+                }
+                const amount = new decimal_js_1.default(change.amount);
+                const coinType = change.coin_type;
+                const normalizedCoinType = (0, index_1.normalizeSuiTokenAddress)(coinType);
+                const poolTokenAAddress = (0, index_1.normalizeSuiTokenAddress)(pool_info.tokenA.address);
+                const poolTokenBAddress = (0, index_1.normalizeSuiTokenAddress)(pool_info.tokenB.address);
+                if (normalizedCoinType === poolTokenAAddress) {
+                    tokenAChangeAmount = amount.div(Math.pow(10, pool_info.tokenA.decimals));
+                }
+                if (normalizedCoinType === poolTokenBAddress) {
+                    tokenBChangeAmount = amount.div(Math.pow(10, pool_info.tokenB.decimals));
+                }
+            }
+            let tx_price = this.calc_tx_price(tokenAChangeAmount, tokenBChangeAmount, pool_info);
+            swap_detail = {
+                tokenA: Object.assign(Object.assign({}, pool_info.tokenA), { pre_bal: 0, post_bal: 0, change: tokenAChangeAmount }),
+                tokenB: Object.assign(Object.assign({}, pool_info.tokenB), { pre_bal: 0, post_bal: 0, change: tokenBChangeAmount }),
+                tx_price,
+            };
+            const gasFee = this.calculateGasFee(tx_receipt);
+            return {
+                success: true,
+                error_code: '',
+                wallet: this.walletAddress,
+                txid,
+                block_time: this.extractTimestamp(tx_receipt),
+                block_number: this.extractCheckpoint(tx_receipt),
+                pool_address: pool_info.pool_address,
+                tokenA: Object.assign(Object.assign({}, pool_info.tokenA), { pre_bal: 0, post_bal: 0, change: ((_d = (_c = swap_detail === null || swap_detail === void 0 ? void 0 : swap_detail.tokenA) === null || _c === void 0 ? void 0 : _c.change) === null || _d === void 0 ? void 0 : _d.toNumber()) || 0 }),
+                tokenB: Object.assign(Object.assign({}, pool_info.tokenB), { pre_bal: 0, post_bal: 0, change: ((_f = (_e = swap_detail === null || swap_detail === void 0 ? void 0 : swap_detail.tokenB) === null || _e === void 0 ? void 0 : _e.change) === null || _f === void 0 ? void 0 : _f.toNumber()) || 0 }),
+                tx_price: (swap_detail === null || swap_detail === void 0 ? void 0 : swap_detail.tx_price) || '0',
+                gas_fee: gasFee
+            };
+        });
+    }
+    calculateGasFee(receipt) {
+        var _a, _b;
+        const gasUsed = (_b = (_a = receipt.transaction) === null || _a === void 0 ? void 0 : _a.effects) === null || _b === void 0 ? void 0 : _b.gas_used;
+        if (!gasUsed) {
+            return {
+                base_fee: 0,
+                priority_fee: 0,
+                total_fee: 0
+            };
+        }
+        const computationCost = new decimal_js_1.default(gasUsed.computation_cost || 0);
+        const storageCost = new decimal_js_1.default(gasUsed.storage_cost || 0);
+        const storageRebate = new decimal_js_1.default(gasUsed.storage_rebate || 0);
+        const nonRefundableStorageFee = new decimal_js_1.default(gasUsed.non_refundable_storage_fee || 0);
+        const totalCost = computationCost.plus(storageCost).minus(storageRebate).plus(nonRefundableStorageFee);
+        const totalCostInSui = totalCost.div(Math.pow(10, 9));
+        return {
+            base_fee: computationCost.div(Math.pow(10, 9)).toNumber(),
+            priority_fee: storageCost.div(Math.pow(10, 9)).toNumber(),
+            total_fee: totalCostInSui.toNumber()
+        };
+    }
+    calc_tx_price(tokenAChange, tokenBChange, pool_info) {
+        if (tokenAChange.eq(0) || tokenBChange.eq(0)) {
+            return '0';
+        }
+        if (pool_info.quote_token === pool_info.tokenA.symbol) {
+            return tokenAChange.abs().div(tokenBChange.abs()).toFixed(12);
+        }
+        if (pool_info.quote_token === pool_info.tokenB.symbol) {
+            return tokenBChange.abs().div(tokenAChange.abs()).toFixed(12);
+        }
+        return '0';
+    }
+    create_failed_result(txReceipt, poolInfo, errorMessage) {
+        var _a;
+        const gasFee = this.calculateGasFee(txReceipt);
+        return {
+            success: false,
+            error_code: this.parseErrorMsgToErrorCode(errorMessage),
+            wallet: this.walletAddress,
+            txid: ((_a = txReceipt.transaction) === null || _a === void 0 ? void 0 : _a.digest) || '',
+            block_time: this.extractTimestamp(txReceipt),
+            block_number: this.extractCheckpoint(txReceipt),
+            pool_address: poolInfo.pool_address,
+            tokenA: Object.assign(Object.assign({}, poolInfo.tokenA), { pre_bal: 0, post_bal: 0, change: 0 }),
+            tokenB: Object.assign(Object.assign({}, poolInfo.tokenB), { pre_bal: 0, post_bal: 0, change: 0 }),
+            tx_price: '0',
+            gas_fee: gasFee
+        };
+    }
+    parseErrorMsgToErrorCode(errorMessage) {
+        (0, dist_1.log_info)(`parseErrorMsgToErrorCode: errorMessage=${errorMessage}`);
+        if (errorMessage.includes('Insufficient funds')) {
+            return dist_1.TradeErrorCodeType.InsufficientFunds;
+        }
+        if (errorMessage.includes('Amount out below minimum')) {
+            return dist_1.TradeErrorCodeType.AmountOutBelowMinimum;
+        }
+        if (errorMessage.includes('Slippage tolerance exceeded')) {
+            return dist_1.TradeErrorCodeType.AmountOutBelowMinimum;
+        }
+        return dist_1.TradeErrorCodeType.UNKOWN;
+    }
+    extractTimestamp(receipt) {
+        var _a;
+        const timestamp = (_a = receipt.transaction) === null || _a === void 0 ? void 0 : _a.timestamp;
+        if (timestamp === null || timestamp === void 0 ? void 0 : timestamp.seconds) {
+            return parseInt(timestamp.seconds) * 1000;
+        }
+        return Date.now();
+    }
+    extractCheckpoint(receipt) {
+        return parseInt(receipt.checkpoint || '0');
+    }
+}
+exports.SuiTransactionParser = SuiTransactionParser;

package/dist/ttd-sui-common/src/trade/send_tx/index.d.ts

@@ -0,0 +1,10 @@
+import { AppConfig } from "@clonegod/ttd-core/dist";
+import { SuiClient } from "@mysten/sui/client";
+import { SuiGrpcClient } from "../../index";
+export declare class SuiTxSender {
+    appConfig: AppConfig;
+    sui_client: SuiClient;
+    grpcClient: SuiGrpcClient;
+    constructor(appConfig: AppConfig, sui_client: SuiClient, grpcClient: SuiGrpcClient);
+    send_tx: (signedTxBytes: string, signature: string, txDigest: string) => Promise<void>;
+}

package/dist/ttd-sui-common/src/trade/send_tx/index.js

@@ -0,0 +1,48 @@
+"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.SuiTxSender = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class SuiTxSender {
+    constructor(appConfig, sui_client, grpcClient) {
+        this.send_tx = (signedTxBytes, signature, txDigest) => __awaiter(this, void 0, void 0, function* () {
+            const bcsBytes = Buffer.from(signedTxBytes, 'base64');
+            const signatureBytes = Buffer.from(signature, 'base64');
+            try {
+                let _response = yield this.sui_client.executeTransactionBlock({
+                    transactionBlock: signedTxBytes,
+                    signature: signature,
+                    options: {
+                        showEvents: true,
+                        showBalanceChanges: true,
+                        showObjectChanges: true,
+                        showEffects: true
+                    }
+                });
+                this.appConfig.emit(`SUI_TX_RESULT_${txDigest}`, txDigest);
+            }
+            catch (error) {
+                (0, dist_1.log_error)(`send tx by rpc failed!!! txid=${txDigest}`, error);
+                try {
+                    let response = yield this.grpcClient.transactionService.executeTransaction(bcsBytes, signatureBytes);
+                    this.appConfig.emit(`SUI_TX_RESULT_${txDigest}`, response);
+                }
+                catch (error) {
+                    (0, dist_1.log_error)(`send tx by grpc failed!!! txid=${txDigest}`, error);
+                }
+            }
+        });
+        this.appConfig = appConfig;
+        this.sui_client = sui_client;
+        this.grpcClient = grpcClient;
+    }
+}
+exports.SuiTxSender = SuiTxSender;

package/dist/ttd-sui-common/src/trade/test/test_parse_sui_tx_result.d.ts

@@ -0,0 +1 @@
+export {};