@clonegod/ttd-sui-common 1.0.103 → 2.0.2

package/dist/appconfig/sui_dex_env_args.js

@@ -10,7 +10,6 @@ class SuiDexEnvArgs extends sui_env_args_1.SuiEnvArgs {
         this.dex_id = (cfg.dex_id || '').toUpperCase();
         this.rpc_endpoint = cfg.rpc_endpoint;
         this.ws_endpoint = cfg.ws_endpoint;
-        this.grpc_endpoint = cfg.grpc_endpoint;
         this.pair = cfg.pair ?? '';
         this.group_id = cfg.group_id ?? '';
         this.quote_pool_address = cfg.quote_pool_address;

package/dist/appconfig/sui_env_args.js

@@ -11,6 +11,8 @@ class SuiEnvArgs extends dist_1.EnvArgs {
         this.server_id = cfg.server_id ?? '';
         this.redis_host = cfg.redis_host;
         this.redis_port = String(cfg.redis_port);
+        this.grpc_endpoint = cfg.grpc_endpoint;
+        this.grpc_token = cfg.grpc_token ?? '';
         this.server_ip_list = cfg.server_ip_list ?? '';
         this.ip_exclude_prefix = cfg.ip_exclude_prefix ?? '';
         this.config_center_host = cfg.config_center_host;

package/dist/grpc/sui-grpc-client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SuiGrpcClient = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
 const grpc_connection_1 = require("./grpc-connection");
 const ledger_service_1 = require("./ledger-service");
 const state_service_1 = require("./state-service");
@@ -13,7 +14,11 @@ class SuiGrpcClient {
         this.init();
     }
     init() {
-        const grpcClient = grpc_connection_1.GrpcConnection.getInstance(process.env.SUI_GRPC_ENDPOINT, process.env.SUI_GRPC_TOKEN);
+        const { grpc_endpoint, grpc_token } = (0, dist_1.getCoreEnv)();
+        if (!grpc_endpoint || !grpc_token) {
+            throw new Error('GRPC_ENDPOINT / GRPC_TOKEN 未配置（SuiGrpcClient 需 gRPC 端点）');
+        }
+        const grpcClient = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
         this.ledgerService = new ledger_service_1.LedgerService(grpcClient);
         this.transactionService = new transaction_service_1.TransactionService(grpcClient);
         this.stateService = new state_service_1.StateService(grpcClient);

package/dist/index.d.ts

@@ -8,4 +8,3 @@ export * from './constants';
 export * from './appconfig';
 export * from './trade';
 export * from './redis';
-export * from './rpc';

package/dist/index.js

@@ -24,4 +24,3 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./appconfig"), exports);
 __exportStar(require("./trade"), exports);
 __exportStar(require("./redis"), exports);
-__exportStar(require("./rpc"), exports);

package/dist/test/test.js

@@ -49,10 +49,10 @@ const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
 });
 const suiProto = grpc.loadPackageDefinition(packageDefinition);
 const LedgerService = suiProto.sui.rpc.v2.LedgerService;
-const endpoint = process.env.SUI_GRPC_ENDPOINT;
-const token = process.env.SUI_GRPC_TOKEN;
+const endpoint = process.env.GRPC_ENDPOINT;
+const token = process.env.GRPC_TOKEN;
 if (!endpoint || !token) {
-    throw new Error('SUI_GRPC_ENDPOINT and SUI_GRPC_TOKEN must be set');
+    throw new Error('GRPC_ENDPOINT and GRPC_TOKEN must be set');
 }
 const client = new LedgerService(endpoint, grpc.credentials.createSsl(), {
     'grpc.keepalive_time_ms': 30000,

package/dist/test/test_checkpoint.js

@@ -5,8 +5,8 @@ const fs_1 = require("fs");
 const grpc_connection_1 = require("../grpc/grpc-connection");
 const subscription_service_1 = require("../grpc/subscription-service");
 const utils_1 = require("../utils");
-const grpc_endpoint = process.env.SUI_GRPC_ENDPOINT;
-const grpc_token = process.env.SUI_GRPC_TOKEN;
+const grpc_endpoint = process.env.GRPC_ENDPOINT;
+const grpc_token = process.env.GRPC_TOKEN;
 const test_subscribe_checkpoints = async () => {
     const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
     const subscriptionService = new subscription_service_1.SubscriptionService(connection);

package/dist/test/test_grpc.js

@@ -4,8 +4,8 @@ const dist_1 = require("@clonegod/ttd-core/dist");
 const grpc_connection_1 = require("../grpc/grpc-connection");
 const ledger_service_1 = require("../grpc/ledger-service");
 const state_service_1 = require("../grpc/state-service");
-const grpc_endpoint = process.env.SUI_GRPC_ENDPOINT;
-const grpc_token = process.env.SUI_GRPC_TOKEN;
+const grpc_endpoint = process.env.GRPC_ENDPOINT;
+const grpc_token = process.env.GRPC_TOKEN;
 const test_get_service_info = async () => {
     const connection = grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
     const ledgerService = new ledger_service_1.LedgerService(connection);

package/dist/trade/abstract_sui_dex_trade.d.ts

@@ -0,0 +1,43 @@
+import { QuoteResultType } from "@clonegod/ttd-core";
+import { AbastrcatTrade, AppConfig, CHAIN_ID, TradeContext } from "@clonegod/ttd-core/dist";
+import { SuiClient } from "@mysten/sui/client";
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { Transaction } from '@mysten/sui/transactions';
+import { PoolObjectInfo, SuiGrpcClient, SuiTxSender } from '../index';
+import { SimpleRedisClient } from '../redis';
+import { ExecutorWsClient } from './executor';
+export declare abstract class AbstractSuiDexTrade extends AbastrcatTrade {
+    protected appConfig: AppConfig;
+    chain_id: CHAIN_ID.SUI;
+    protected group_wallets: Ed25519Keypair[];
+    protected wallet: Ed25519Keypair;
+    protected walletMode: 'single' | 'multi';
+    sui_client: SuiClient;
+    grpcClient: SuiGrpcClient;
+    transactionSender: SuiTxSender;
+    protected redisClient: SimpleRedisClient;
+    protected executorClient: ExecutorWsClient;
+    walletAddresses: string[];
+    currentWalletAddress: string;
+    protected chainNameLower: string;
+    constructor(appConfig: AppConfig, grpcClient: SuiGrpcClient);
+    init(): Promise<void>;
+    private initSuiClient;
+    protected getWalletMode(): 'single' | 'multi';
+    protected getSingleWallet(): Ed25519Keypair;
+    protected getGroupWallets(): Ed25519Keypair[];
+    protected getWalletAddresses(): string[];
+    protected chooseWallet(context: TradeContext): Promise<Ed25519Keypair>;
+    protected determineInputOutputTokens(order_msg: any, pool_info: any): {
+        inputToken: any;
+        outputToken: any;
+    };
+    local_calculate_output_amt(context: TradeContext): QuoteResultType;
+    protected getWalletAssetsFromRedis(walletAddress: string): Promise<any>;
+    protected getObjectInfo(objectId: string): Promise<PoolObjectInfo | null>;
+    protected compareBigIntBalance(a: any, b: any): number;
+    protected mergeTokenObjects(tx: Transaction, primaryCoin: any, objectsToMerge: any[], tokenSymbol: string): void;
+    protected try_refresh_wallet_objects(wallet: string, txid: string, context: TradeContext, initial_delay_ms?: number, try_times?: number, try_delay_ms?: number): Promise<void>;
+    execute(context: TradeContext, _retryCount?: number): Promise<string>;
+    protected abstract initConfigs(): Promise<void>;
+}

package/dist/trade/abstract_sui_dex_trade.js

@@ -0,0 +1,380 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSuiDexTrade = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const client_1 = require("@mysten/sui/client");
+const ed25519_1 = require("@mysten/sui/keypairs/ed25519");
+const transactions_1 = require("@mysten/sui/transactions");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const index_1 = require("../index");
+const redis_1 = require("../redis");
+const executor_1 = require("./executor");
+const tx_result_channel_1 = require("./tx_result_channel");
+class AbstractSuiDexTrade extends dist_1.AbastrcatTrade {
+    constructor(appConfig, grpcClient) {
+        super();
+        this.appConfig = appConfig;
+        this.walletMode = 'multi';
+        this.walletAddresses = [];
+        this.currentWalletAddress = '';
+        this.grpcClient = grpcClient;
+        this.chainNameLower = this.appConfig.env_args.chain_id.toLowerCase();
+        this.redisClient = new redis_1.SimpleRedisClient(`${this.chainNameLower}:tx`);
+    }
+    async init() {
+        this.initSuiClient();
+        await this.initConfigs();
+        const walletGroupIds = process.env.SUI_WALLET_GROUP_IDS || process.env.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)(`init wallet mode: multi, wallet count: ${this.group_wallets.length}, walletAddresses: ${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)(`init wallet mode: single, walletAddress= ${this.currentWalletAddress}`);
+        }
+        this.transactionSender = new index_1.SuiTxSender(this.appConfig, this.sui_client, this.grpcClient);
+        this.executorClient = new executor_1.ExecutorWsClient();
+        const txResultChannel = (0, tx_result_channel_1.get_sui_tx_result_channel)();
+        this.appConfig.arb_cache.redis_cmd.subscribe(txResultChannel, (message) => {
+            try {
+                const msg = JSON.parse(message);
+                if (msg.digest)
+                    this.appConfig.emit(`SUI_TX_RESULT_${msg.digest}`, msg.digest);
+            }
+            catch (e) {
+                (0, dist_1.log_warn)(`[trade] bad tx result msg`, message);
+            }
+        });
+    }
+    initSuiClient() {
+        const sui_rpc_url = process.env.RPC_ENDPOINT || 'https://fullnode.mainnet.sui.io:443';
+        this.sui_client = new client_1.SuiClient({ url: sui_rpc_url });
+        (0, dist_1.log_info)(`init sui client, rpc_url: ${sui_rpc_url}`);
+    }
+    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;
+    }
+    async chooseWallet(context) {
+        if (this.getWalletMode() === 'single') {
+            return this.getSingleWallet();
+        }
+        const lockIdentifier = `choose_wallet`;
+        const lockKey = `${this.chainNameLower}:lock:${lockIdentifier}`;
+        const lockValue = `${Math.random().toString(36).substring(2, 15)}`;
+        let lockAcquired = false;
+        const start_time = Date.now();
+        const maxRetryTime = 200;
+        const retryDelay = 20;
+        do {
+            lockAcquired = await this.redisClient.acquireLock(lockKey, lockValue, 2);
+            if (lockAcquired) {
+                break;
+            }
+            await (0, dist_1.sleep)(retryDelay);
+        } while (!lockAcquired && Date.now() - start_time < maxRetryTime);
+        if (!lockAcquired) {
+            throw new Error(`choose wallet, acquire lock failed: ${lockKey}, took ${Date.now() - start_time}ms`);
+        }
+        (0, dist_1.log_info)(`choose wallet, acquire lock success: ${lockKey}, took ${Date.now() - start_time}ms`);
+        try {
+            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 = await 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 = this.group_wallets?.find(w => w.getPublicKey().toSuiAddress().toLowerCase() === walletAddress.toLowerCase());
+                    if (!wallet) {
+                        continue;
+                    }
+                    const tokenAsset = assets.tokens?.find((token) => (0, index_1.normalizeSuiTokenAddress)(token.address) === (0, index_1.normalizeSuiTokenAddress)(inputToken.address));
+                    let tokenBalance = 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 = await this.redisClient.hgetall('sui:wallet:last_used');
+            for (const availableWallet of availableWallets) {
+                const walletAddress = availableWallet.wallet.getPublicKey().toSuiAddress();
+                const lastUsedData = wallet_last_used?.[walletAddress];
+                if (lastUsedData) {
+                    try {
+                        const lastUsedInfo = JSON.parse(lastUsedData);
+                        availableWallet.lastUsedAt = lastUsedInfo.lastUsedAt;
+                    }
+                    catch (error) {
+                        console.warn(`解析钱包最后使用时间失败: ${walletAddress}`, error);
+                    }
+                }
+                else {
+                    await 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();
+            await 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?.balance} ${inputToken.symbol}, required: ${requiredAmount} ${inputToken.symbol}`);
+            return selectedWallet;
+        }
+        catch (error) {
+            (0, dist_1.log_error)(`choose wallet failed, error: ${error.message}`, error);
+            throw error;
+        }
+        finally {
+            await this.redisClient.releaseLock(lockKey, lockValue);
+        }
+    }
+    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 };
+    }
+    local_calculate_output_amt(context) {
+        const { price_msg, order_msg, pool_info, trade_runtime, slippage_bps } = context;
+        let { ask, bid } = price_msg;
+        const { aToB, amount: uiAmount, price: cex_order_price } = order_msg;
+        let { inputToken, outputToken } = (0, dist_1.get_input_out_token)(pool_info, aToB);
+        let amountIn = new decimal_js_1.default(uiAmount).mul(10 ** inputToken.decimals);
+        let slippage = slippage_bps / 10000;
+        let price;
+        let amountOut;
+        let amountOutMin;
+        if (aToB) {
+            price = cex_order_price ?? bid.price;
+            amountOut = new decimal_js_1.default(uiAmount).mul(price).mul(10 ** outputToken.decimals);
+            amountOutMin = amountOut.mul(1 - slippage);
+        }
+        else {
+            price = cex_order_price ?? ask.price;
+            amountOut = new decimal_js_1.default(uiAmount).div(price).mul(10 ** outputToken.decimals);
+            amountOutMin = amountOut.mul(1 - slippage);
+        }
+        let quote_result = {
+            inputToken,
+            outputToken,
+            amountIn: Number(amountIn.toFixed(0)),
+            amountOut: Number(amountOut.toFixed(0)),
+            amountOutMin: Number(amountOutMin.toFixed(0)),
+            slippageBps: slippage_bps,
+            priceImpact: 0,
+            price: price.toString()
+        };
+        return quote_result;
+    }
+    async getWalletAssetsFromRedis(walletAddress) {
+        try {
+            const redisClient = this.appConfig.arb_cache.redis_cmd.redis_client;
+            const walletAssetsJson = await redisClient.HGET('sui:wallet:assets', walletAddress);
+            if (!walletAssetsJson) {
+                return null;
+            }
+            return JSON.parse(walletAssetsJson);
+        }
+        catch (error) {
+            (0, dist_1.log_error)(`从Redis获取钱包资产信息失败`, error);
+            throw error;
+        }
+    }
+    async getObjectInfo(objectId) {
+        try {
+            let startTime = Date.now();
+            const objectResponse = await this.grpcClient.ledgerService.getObject(objectId, [
+                'object_id',
+                'version',
+                'digest',
+                'owner',
+            ]);
+            let objectInfo = null;
+            if (objectResponse.object) {
+                objectInfo = {
+                    objectId: objectId,
+                    version: objectResponse.object.version,
+                    digest: objectResponse.object.digest,
+                    initialSharedVersion: objectResponse.object.owner.version
+                };
+            }
+            (0, dist_1.log_info)(`get object info success, cost: ${Date.now() - startTime} ms`, objectInfo);
+            return objectInfo;
+        }
+        catch (error) {
+            (0, dist_1.log_error)(`get object info failed, object_id=${objectId}`, error);
+            return null;
+        }
+    }
+    compareBigIntBalance(a, b) {
+        const balanceA = BigInt(a?.balance || '0');
+        const balanceB = BigInt(b?.balance || '0');
+        if (balanceA > balanceB)
+            return -1;
+        if (balanceA < balanceB)
+            return 1;
+        return 0;
+    }
+    mergeTokenObjects(tx, primaryCoin, objectsToMerge, tokenSymbol) {
+        if (objectsToMerge.length === 0)
+            return;
+        const other_objects = objectsToMerge.map((obj) => {
+            if (obj.version && obj.digest) {
+                return tx.object(transactions_1.Inputs.ObjectRef({
+                    objectId: obj.objectId,
+                    version: obj.version,
+                    digest: obj.digest
+                }));
+            }
+            else {
+                throw new Error(`${tokenSymbol} 对象 ${obj.objectId} 数据不完整`);
+            }
+        });
+        tx.mergeCoins(primaryCoin, other_objects);
+        (0, dist_1.log_info)(`✅ ${tokenSymbol} 进行对象合并，涉及 ${other_objects.length} 个对象`);
+    }
+    async try_refresh_wallet_objects(wallet, txid, context, initial_delay_ms = 0, try_times = 5, try_delay_ms = 300) {
+        for (let i = 0; i < try_times; i++) {
+            let delay_ms = initial_delay_ms + i * try_delay_ms;
+            setTimeout(() => {
+                let group_id = this.appConfig.trade_runtime.group.id;
+                let coin_types = [context.pool_info.tokenA.address, context.pool_info.tokenB.address];
+                this.appConfig.arb_cache.redis_event_publisher.publish_wallet_raw_tx_event(group_id, wallet, { group_id, wallet, txid, coin_types, remark: `PRE_REFRESH_OBJECTS_${i}` });
+            }, delay_ms);
+            (0, dist_1.log_info)(`try_refresh_wallet_objects, txid=${txid}, i=${i}, delay_ms=${delay_ms}ms`);
+        }
+    }
+    async execute(context, _retryCount) {
+        const q = this.local_calculate_output_amt(context);
+        const { pool_info } = context;
+        const coinTypeA = (0, index_1.normalizeSuiTokenAddress)(pool_info.tokenA.address);
+        const coinTypeB = (0, index_1.normalizeSuiTokenAddress)(pool_info.tokenB.address);
+        const inAddr = (0, index_1.normalizeSuiTokenAddress)(q.inputToken.address);
+        const a2b = inAddr === coinTypeA;
+        const req = {
+            dexId: (pool_info.dex_id || this.appConfig.trade_runtime.dex_id),
+            poolId: pool_info.pool_address,
+            coinTypeA,
+            coinTypeB,
+            a2b,
+            amountIn: BigInt(q.amountIn),
+            minOut: BigInt(q.amountOutMin),
+            sqrtPriceLimit: 0n,
+        };
+        (0, dist_1.log_info)(`[trade] 转发 swap 给集中执行器`, {
+            dex_id: req.dexId, pair: pool_info.pair, a2b, amountIn: req.amountIn.toString(), minOut: req.minOut.toString(),
+        });
+        const res = await this.executorClient.requestSwap(req);
+        if (!res.submitted) {
+            throw new Error(`集中执行器提交失败: ${res.error}`);
+        }
+        return res.digest;
+    }
+}
+exports.AbstractSuiDexTrade = AbstractSuiDexTrade;

package/dist/trade/executor/core_channel.js

@@ -23,10 +23,11 @@ const GRPC_CLIENT_OPTIONS = {
     'grpc.max_reconnect_backoff_ms': 30000,
 };
 function buildGrpcCore(opts = {}) {
-    const endpoint = opts.endpoint ?? process.env.SUI_GRPC_ENDPOINT;
-    const token = opts.token ?? process.env.SUI_GRPC_TOKEN;
+    const coreEnv = (0, dist_1.getCoreEnv)();
+    const endpoint = opts.endpoint ?? coreEnv.grpc_endpoint;
+    const token = opts.token ?? coreEnv.grpc_token;
     if (!endpoint)
-        throw new Error('SUI_GRPC_ENDPOINT 未配置（集中执行器需 gRPC 端点）');
+        throw new Error('GRPC_ENDPOINT 未配置（集中执行器需 gRPC 端点）');
     const transport = new grpc_transport_1.GrpcTransport({
         host: endpoint,
         channelCredentials: grpc_js_1.ChannelCredentials.createSsl(),

package/dist/trade/index.d.ts

@@ -5,4 +5,4 @@ export * from './coin';
 export * from './swap';
 export * from './executor';
 export * from './tx_result_channel';
-export * from './abstract_sui_dex_trade_plus';
+export * from './abstract_sui_dex_trade';

package/dist/trade/index.js

@@ -21,4 +21,4 @@ __exportStar(require("./coin"), exports);
 __exportStar(require("./swap"), exports);
 __exportStar(require("./executor"), exports);
 __exportStar(require("./tx_result_channel"), exports);
-__exportStar(require("./abstract_sui_dex_trade_plus"), exports);
+__exportStar(require("./abstract_sui_dex_trade"), exports);

package/dist/trade/test/test_parse_sui_tx_result.js

@@ -9,8 +9,8 @@ const sui_tx_parser_1 = require("../parse/sui_tx_parser");
 const index_1 = require("../../index");
 const index_2 = require("../../index");
 async function test_get_tx_result() {
-    const grpc_endpoint = process.env.SUI_GRPC_ENDPOINT || '';
-    const grpc_token = process.env.SUI_GRPC_TOKEN || '';
+    const grpc_endpoint = process.env.GRPC_ENDPOINT || '';
+    const grpc_token = process.env.GRPC_TOKEN || '';
     const grpcConnection = index_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token);
     const ledgerService = new index_1.LedgerService(grpcConnection);
     let wallet_address = '0x6367c8755b8c39cab7305bfa75cb17d050508d2e55f6862a7682377ad6d46ee7';

package/package.json

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