@clonegod/ttd-sui-common 1.0.21 → 1.0.23

package/dist/grpc/gas-price-cache.js

@@ -15,7 +15,7 @@ class GasPriceCache {
     constructor(ledgerService) {
         this.cachedGasPrice = 0;
         this.lastUpdateTime = 0;
-        this.updateInterval = 5 * 60 * 1000;
+        this.updateInterval = 60 * 60 * 1000;
         this.ledgerService = ledgerService;
         this.startAutoRefresh();
     }
@@ -39,7 +39,7 @@ class GasPriceCache {
                 const epochRes = yield this.ledgerService.getEpoch();
                 this.cachedGasPrice = Number(epochRes['epoch']['reference_gas_price']);
                 this.lastUpdateTime = Date.now();
-                (0, dist_1.log_info)(`Gas price refreshed: ${this.cachedGasPrice} MIST (${this.cachedGasPrice / 1e9} SUI)`);
+                (0, dist_1.log_info)(`refreshGasPrice success: ${this.cachedGasPrice} MIST`);
             }
             catch (error) {
                 (0, dist_1.log_error)('refresh gas price failed', error);

package/dist/grpc/live-data-service.d.ts

@@ -6,5 +6,5 @@ export declare class LiveDataService {
     getBalance(owner: string, coinType: string): Promise<any>;
     listBalances(owner: string): Promise<unknown>;
     getCoinInfo(coinType: string): Promise<unknown>;
-    listOwnedObjects(owner: string, limit?: number, readMask?: string[]): Promise<unknown>;
+    listOwnedObjects(owner: string, coinType?: string, limit?: number, readMask?: string[]): Promise<unknown>;
 }

package/dist/grpc/live-data-service.js

@@ -62,10 +62,16 @@ class LiveDataService {
             });
         });
     }
-    listOwnedObjects(owner, limit, readMask) {
+    listOwnedObjects(owner, coinType, limit, readMask) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
                 const request = { owner };
+                if (coinType) {
+                    const objectType = coinType.startsWith('0x2::coin::Coin<')
+                        ? coinType
+                        : `0x2::coin::Coin<${coinType}>`;
+                    request.object_type = objectType;
+                }
                 if (limit)
                     request.page_size = limit;
                 if (readMask && readMask.length > 0) {

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from './type';
 export * from './grpc';
 export * from './utils';
 export * from './constants';
+export * from './trade';

package/dist/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./type"), exports);
 __exportStar(require("./grpc"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./trade"), exports);

package/dist/test/test_grpc.js

@@ -69,15 +69,16 @@ const test_get_coin_info = (coin_type) => __awaiter(void 0, void 0, void 0, func
     const coinInfo = yield liveDataService.getCoinInfo(coin_type);
     (0, dist_1.log_info)(`coinInfo`, coinInfo);
 });
-const test_list_owned_objects = (wallet_address) => __awaiter(void 0, void 0, void 0, function* () {
+const test_list_owned_objects = (wallet_address, coin_type) => __awaiter(void 0, void 0, void 0, function* () {
     const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
     const liveDataService = new live_data_service_1.LiveDataService(connection);
-    const ownedObjects = yield liveDataService.listOwnedObjects(wallet_address);
+    const ownedObjects = yield liveDataService.listOwnedObjects(wallet_address, coin_type);
     (0, dist_1.log_info)(`ownedObjects`, ownedObjects);
 });
 const main = () => __awaiter(void 0, void 0, void 0, function* () {
-    test_get_epoch();
     const wallet_address = '0x6367c8755b8c39cab7305bfa75cb17d050508d2e55f6862a7682377ad6d46ee7';
     const usdc_coin_type = '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC';
+    const take_coin_type = '0x76a49ebaf991fa2d4cb6a352af14425d453fe2ba6802b5ed2361b227150b6689::take::TAKE';
+    test_list_owned_objects(wallet_address, take_coin_type);
 });
 main();

package/dist/trade/check/index.d.ts

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

package/dist/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/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/trade/check/tx_result_checker.js

@@ -0,0 +1,102 @@
+"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) => {
+            (0, dist_1.log_info)(`receive tx result notification, txid=${this.txid}`);
+            if (response.transaction) {
+                this.processTransactionResult(response, 'grpc');
+            }
+            else {
+                (0, dist_1.log_warn)(`re-fetch tx result by ledgerService, txid=${this.txid}`);
+                this.leadgerService.getTransaction(this.txid, ['*']).then((txReceipt) => {
+                    this.processTransactionResult(txReceipt, 'grpc2');
+                });
+            }
+        });
+    }
+    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/trade/index.d.ts

@@ -0,0 +1,3 @@
+export * from './send_tx';
+export * from './check';
+export * from './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("./send_tx"), exports);
+__exportStar(require("./check"), exports);
+__exportStar(require("./parse"), exports);

package/dist/trade/parse/index.d.ts

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

package/dist/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/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/trade/parse/sui_tx_parser.js

@@ -0,0 +1,165 @@
+"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;
+            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) {
+                    console.log('Transaction failed', {
+                        txid: (_d = receipt.transaction) === null || _d === void 0 ? void 0 : _d.digest,
+                        success: (_g = (_f = (_e = receipt.transaction) === null || _e === void 0 ? void 0 : _e.effects) === null || _f === void 0 ? void 0 : _f.status) === null || _g === void 0 ? void 0 : _g.success,
+                        balance_changes: (_j = (_h = receipt.transaction) === null || _h === void 0 ? void 0 : _h.balance_changes) === null || _j === void 0 ? void 0 : _j.length,
+                        reason: (_o = (_m = (_l = (_k = receipt.transaction) === null || _k === void 0 ? void 0 : _k.effects) === null || _l === void 0 ? void 0 : _l.status) === null || _m === void 0 ? void 0 : _m.error) === null || _o === void 0 ? void 0 : _o.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;
+            let swap_detail = null;
+            let tokenAChangeAmount = new decimal_js_1.default(0);
+            let tokenBChangeAmount = new decimal_js_1.default(0);
+            const balanceChanges = ((_a = tx_receipt.transaction) === null || _a === void 0 ? void 0 : _a.balance_changes) || [];
+            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: ((_b = tx_receipt.transaction) === null || _b === void 0 ? void 0 : _b.digest) || '',
+                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/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) => void;
+}

package/dist/trade/send_tx/index.js

@@ -0,0 +1,48 @@
+"use strict";
+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) => {
+            const promises = [];
+            const bcsBytes = Buffer.from(signedTxBytes, 'base64');
+            const signatureBytes = Buffer.from(signature, 'base64');
+            const grpcPromise = this.grpcClient.transactionService.executeTransaction(bcsBytes, signatureBytes)
+                .then((response) => { return { type: 'grpc', success: true, response }; })
+                .catch((error) => {
+                (0, dist_1.log_error)(`submit tx to grpc failed`, error);
+                return { type: 'grpc', success: false, error };
+            });
+            promises.push(grpcPromise);
+            const rpcPromise = this.sui_client.executeTransactionBlock({
+                transactionBlock: signedTxBytes,
+                signature: signature,
+                options: {
+                    showEvents: true,
+                    showBalanceChanges: true,
+                    showObjectChanges: true,
+                    showEffects: true
+                }
+            }).then((response) => {
+                return { type: 'rpc', success: true, response };
+            }).catch((error) => {
+                (0, dist_1.log_error)(`submit tx to sui_client failed`, error);
+                return { type: 'rpc', success: false, error };
+            });
+            promises.push(rpcPromise);
+            Promise.race(promises).then((result) => {
+                if (result.type === 'rpc') {
+                    this.appConfig.emit(`SUI_TX_RESULT_${txDigest}`, txDigest);
+                }
+                if (result.type === 'grpc') {
+                    this.appConfig.emit(`SUI_TX_RESULT_${txDigest}`, result.response);
+                }
+            });
+        };
+        this.appConfig = appConfig;
+        this.sui_client = sui_client;
+        this.grpcClient = grpcClient;
+    }
+}
+exports.SuiTxSender = SuiTxSender;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-sui-common",
-    "version": "1.0.21",
+    "version": "1.0.23",
     "description": "Sui common library",
     "license": "UNLICENSED",
     "main": "dist/index.js",