@clonegod/ttd-sui-common 2.0.4 → 2.0.6

package/dist/grpc/grpc-connection.js

@@ -64,9 +64,11 @@ class GrpcConnection {
         'grpc.max_reconnect_backoff_ms': 30000,
         'grpc.enable_retries': 1,
         'grpc.retry_buffer_size': 256 * 1024,
+        'grpc-node.flow_control_window': 8 * 1024 * 1024,
+        'grpc-node.max_session_memory': 64,
+        'grpc.default_compression_algorithm': 2,
         'grpc.http2.max_frame_size': 16384,
         'grpc.http2.max_header_list_size': 16384,
-        'grpc.http2.initial_window_size': 65535,
     }; }
     getChannel() {
         if (!this.channel) {

package/dist/grpc/grpc_provider_registry.d.ts

@@ -9,6 +9,6 @@ interface RedisLike {
     hgetall(key: string): Promise<Record<string, string> | null>;
     subscribe(channel: string, listener: (message: string) => void): Promise<void> | void;
 }
-export declare function resolveGrpcProvider(redis: RedisLike, chainId: string): Promise<GrpcProviderConfig>;
-export declare function watchGrpcProviderChange(redis: RedisLike, chainId: string, active: GrpcProviderConfig, onChange: (next: GrpcProviderConfig | null) => void): void;
+export declare function resolveGrpcProvider(redis: RedisLike, chainId: string, preferId?: string): Promise<GrpcProviderConfig>;
+export declare function watchGrpcProviderChange(redis: RedisLike, chainId: string, active: GrpcProviderConfig, onChange: (next: GrpcProviderConfig | null) => void, preferId?: string): void;
 export {};

package/dist/grpc/grpc_provider_registry.js

@@ -11,7 +11,7 @@ function getRpcProvidersKey(chainId) {
 function getRpcConfigChangeChannel(chainId) {
     return `${chainId.toLowerCase()}:rpc:config:change`;
 }
-async function resolveGrpcProvider(redis, chainId) {
+async function resolveGrpcProvider(redis, chainId, preferId) {
     const key = getRpcProvidersKey(chainId);
     const map = (await redis.hgetall(key)) || {};
     const candidates = [];
@@ -28,6 +28,16 @@ async function resolveGrpcProvider(redis, chainId) {
     if (candidates.length === 0) {
         throw new Error(`[grpc-registry] ${key} 无 enabled 的 grpc provider —— 请在 trade-analyze Config/RPC 页新增 type=grpc 的 Provider（grpc_endpoint 填 host:port，auth_token 填 x-token）`);
     }
+    if (preferId) {
+        const preferred = candidates.find(c => c.id === preferId);
+        if (!preferred) {
+            throw new Error(`[grpc-registry] 指定的 grpc provider '${preferId}' 不存在或未 enabled（${key} 可用: ${candidates.map(c => c.id).join(',')}）`);
+        }
+        if (!preferred.auth_token)
+            (0, dist_1.log_warn)(`[grpc-registry] provider ${preferred.id} auth_token 为空，按无鉴权端点连接`);
+        (0, dist_1.log_info)(`[grpc-registry] 使用指定 provider: ${preferred.id}`);
+        return { id: preferred.id, endpoint: preferred.grpc_endpoint, token: preferred.auth_token || '' };
+    }
     candidates.sort((a, b) => (b.default_for_quote === true ? 1 : 0) - (a.default_for_quote === true ? 1 : 0)
         || a.id.localeCompare(b.id));
     const picked = candidates[0];
@@ -39,13 +49,13 @@ async function resolveGrpcProvider(redis, chainId) {
     }
     return { id: picked.id, endpoint: picked.grpc_endpoint, token: picked.auth_token || '' };
 }
-function watchGrpcProviderChange(redis, chainId, active, onChange) {
+function watchGrpcProviderChange(redis, chainId, active, onChange, preferId) {
     const channel = getRpcConfigChangeChannel(chainId);
     redis.subscribe(channel, (message) => {
         void (async () => {
             let next;
             try {
-                next = await resolveGrpcProvider(redis, chainId);
+                next = await resolveGrpcProvider(redis, chainId, preferId);
             }
             catch {
                 next = null;

package/dist/quote/abstract_dex_quote.d.ts

@@ -53,6 +53,8 @@ export declare abstract class AbstractDexQuote<C extends SuiChainOps = SuiChainO
     private registerEventHandlers;
     private assertValidBlockNumber;
     private isStaleUpdate;
+    private appliedSwapWatermark;
+    private shouldApplySwapState;
     private handleBlockUpdateEvent;
     private calculateQuote;
     private calculateQuoteForPool;

package/dist/quote/abstract_dex_quote.js

@@ -12,6 +12,7 @@ class AbstractDexQuote {
         this.lastPublished = new Map();
         this.quotePriceVerify = new quote_price_verify_1.QuotePriceVerify();
         this.MIN_QUOTE_INTERVAL_MS = Math.max(3000, parseInt(process.env.MIN_QUOTE_INTERVAL_MS || '10000', 10) || 10000);
+        this.appliedSwapWatermark = new Map();
         this.appConfig = appConfig;
         this.chain = chain;
     }
@@ -58,8 +59,15 @@ class AbstractDexQuote {
         const last = this.lastPublished.get(poolAddr);
         return !!last && (block < last.block || (block === last.block && txIndex <= last.txIndex));
     }
+    shouldApplySwapState(poolAddr, block, txIndex) {
+        const last = this.appliedSwapWatermark.get(poolAddr);
+        if (last && (block < last.block || (block === last.block && txIndex <= last.txIndex)))
+            return false;
+        this.appliedSwapWatermark.set(poolAddr, { block, txIndex });
+        return true;
+    }
     async handleBlockUpdateEvent(eventData) {
-        const { blockNumber, blockTime } = JSON.parse(eventData);
+        const { blockNumber, blockTimestampMs: blockTime } = JSON.parse(eventData);
         this.assertValidBlockNumber(blockNumber, `${this.dexId} block-event`);
         for (const poolInfo of this.poolInfoMap.values()) {
             const poolAddress = poolInfo.pool_address;
@@ -87,7 +95,11 @@ class AbstractDexQuote {
                 return { bundle: null, verifyLog };
         }
         this.assertValidBlockNumber(evt.blockNumber, `${this.dexId} ${poolInfo.pool_name} ${eventType}`);
-        await this.refreshStateFromEvent(poolInfo, evt);
+        const skipApply = eventType === 'swap'
+            && Number.isInteger(evt.txIndex)
+            && !this.shouldApplySwapState(poolInfo.pool_address, evt.blockNumber, evt.txIndex);
+        if (!skipApply)
+            await this.refreshStateFromEvent(poolInfo, evt);
         if (Number.isInteger(evt.txIndex) && this.isStaleUpdate(poolInfo.pool_address, evt.blockNumber, evt.txIndex))
             return { bundle: null, verifyLog };
         const bundle = await this.calculateQuoteForPool(poolInfo, evt.blockTime, evt.blockNumber, evt);

package/dist/trade/abstract_sui_dex_trade.js

@@ -46,7 +46,7 @@ class AbstractSuiDexTrade extends dist_1.AbastrcatTrade {
             try {
                 const msg = JSON.parse(message);
                 if (msg.digest)
-                    this.appConfig.emit(`SUI_TX_RESULT_${msg.digest}`, msg.digest);
+                    this.appConfig.emit(`SUI_TX_RESULT_${msg.digest}`, msg.receipt ?? msg.digest);
             }
             catch (e) {
                 (0, dist_1.log_warn)(`[trade] bad tx result msg`, message);

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

@@ -10,5 +10,6 @@ export declare class TransactionResultChecker extends AbstractTransactionResultC
     private isValidTransactionResult;
     check_tx_result_interval(): Promise<void>;
     on_subscibe_transaction(): void;
+    private ensureCheckpoint;
     private processTransactionResult;
 }

package/dist/trade/check/tx_result_checker.js

@@ -59,6 +59,7 @@ class TransactionResultChecker extends trade_1.AbstractTransactionResultCheck {
         this.event_emitter.once(`SUI_TX_RESULT_${this.txid}`, async (response) => {
             (0, dist_1.log_info)(`receive tx result notification, txid=${this.txid}`);
             if (response.transaction) {
+                await this.ensureCheckpoint(response);
                 this.processTransactionResult(response, 'grpc');
                 return;
             }
@@ -86,6 +87,25 @@ class TransactionResultChecker extends trade_1.AbstractTransactionResultCheck {
             }
         });
     }
+    async ensureCheckpoint(receipt) {
+        if (receipt.transaction?.checkpoint)
+            return;
+        for (let i = 0; i < 10; i++) {
+            try {
+                const r = await this.leadgerService.getTransaction(this.txid, ['checkpoint', 'timestamp']);
+                const t = r?.transaction;
+                if (t?.checkpoint) {
+                    receipt.transaction.checkpoint = t.checkpoint;
+                    if (t.timestamp)
+                        receipt.transaction.timestamp = t.timestamp;
+                    return;
+                }
+            }
+            catch { }
+            await (0, dist_1.sleep)(200);
+        }
+        (0, dist_1.log_warn)(`ensureCheckpoint: 补查超窗仍无 checkpoint 号, txid=${this.txid}（block_number 将为 0）`);
+    }
     async processTransactionResult(txReceipt, source) {
         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!`);

package/dist/trade/executor/central_executor.d.ts

@@ -30,6 +30,9 @@ export interface CentralExecutorOptions {
         digest: string;
         success: boolean;
         error?: string;
+        receipt?: {
+            transaction: any;
+        };
     }) => void;
 }
 type TxResponse = SuiClientTypes.Transaction<{
@@ -64,6 +67,7 @@ export declare class CentralExecutor {
     private registerShared;
     submitSwap(req: SwapExecRequest): Promise<SwapSubmitResult>;
     private broadcastAndCommit;
+    private toCheckerReceipt;
     private reconcileAfterFailure;
     simulateSwap(req: SwapExecRequest): Promise<TxResponse>;
     private buildSwapTx;

package/dist/trade/executor/central_executor.js

@@ -208,16 +208,21 @@ class CentralExecutor {
         tx.object(transactions_1.Inputs.SharedObjectRef({ objectId, initialSharedVersion, mutable }));
     }
     async submitSwap(req) {
+        const t0 = Date.now();
         const inType = this.inputCoinType(req);
         const wallet = this.chooseTradeWallet(req, inType, req.amountIn);
         const inputTag = this.nextTag('in');
         const inputRes = this.cache.acquire(wallet, inType, req.amountIn, inputTag);
+        const tAcquire = Date.now();
+        (0, dist_1.log_info)(`[executor] coin 已占用 wallet=${wallet.slice(0, 10)}… ${inputRes.coins.length} 个 ${inType.split('::').pop()} (选钱包+占币 ${tAcquire - t0}ms)`);
         try {
             const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
+            const tBuild = Date.now();
             const { signature: senderSig } = await this.tradeWallets.get(wallet).signTransaction(txBytes);
             const digest = await tx.getDigest();
+            const tSign = Date.now();
             void this.broadcastAndCommit(txBytes, [senderSig], digest, wallet, inType, this.outputCoinType(req), inputRes.coins, inputTag);
-            (0, dist_1.log_info)(`[executor] swap 已签提交 digest=${digest} dex=${req.dexId} ${req.a2b ? 'a2b' : 'b2a'} in=${req.amountIn}`);
+            (0, dist_1.log_info)(`[executor] swap 已签提交 digest=${digest} dex=${req.dexId} ${req.a2b ? 'a2b' : 'b2a'} in=${req.amountIn} cost={build:${tBuild - tAcquire}ms, sign+digest:${tSign - tBuild}ms, total:${tSign - t0}ms}`);
             return { digest, submitted: true };
         }
         catch (e) {
@@ -227,6 +232,7 @@ class CentralExecutor {
         }
     }
     async broadcastAndCommit(txBytes, signatures, digest, wallet, inType, outType, inputCoins, inputTag) {
+        const tBroadcast = Date.now();
         try {
             const resp = await this.core.executeTransaction({ transaction: txBytes, signatures, include: { effects: true, objectTypes: true, balanceChanges: true } });
             const tr = resp.Transaction;
@@ -241,20 +247,44 @@ class CentralExecutor {
             if (!success) {
                 this.cache.abort(inputTag, true);
                 this.reconcileAfterFailure(wallet, inType, outType);
-                (0, dist_1.log_warn)(`[executor] swap 链上失败 digest=${digest} err=${error}`);
-                this.onBroadcastResult?.({ digest, success: false, error });
+                (0, dist_1.log_warn)(`[executor] swap 链上失败 digest=${digest} err=${error} broadcast=${Date.now() - tBroadcast}ms`);
+                this.onBroadcastResult?.({ digest, success: false, error, receipt: this.toCheckerReceipt(tr, digest) });
                 return;
             }
             await this.onSuccess(tr, wallet, inType, outType, inputCoins, inputTag);
-            (0, dist_1.log_info)(`[executor] swap quorum-executed 确认 digest=${digest}`);
-            this.onBroadcastResult?.({ digest, success: true });
+            (0, dist_1.log_info)(`[executor] swap quorum-executed 确认 digest=${digest} broadcast=${Date.now() - tBroadcast}ms`);
+            this.onBroadcastResult?.({ digest, success: true, receipt: this.toCheckerReceipt(tr, digest) });
         }
         catch (e) {
             this.cache.abort(inputTag, true);
             this.reconcileAfterFailure(wallet, inType, outType);
-            (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest}`, e);
+            (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest} broadcast=${Date.now() - tBroadcast}ms`, e);
         }
     }
+    toCheckerReceipt(tr, digest) {
+        const eff = tr.effects;
+        const status = eff?.status?.success
+            ? { success: true }
+            : { success: false, error: { kind: eff?.status?.error?.message ?? JSON.stringify(eff?.status?.error ?? 'unknown') } };
+        const g = eff?.gasUsed ?? {};
+        return {
+            transaction: {
+                digest,
+                effects: {
+                    status,
+                    gas_used: {
+                        computation_cost: g.computationCost,
+                        storage_cost: g.storageCost,
+                        storage_rebate: g.storageRebate,
+                        non_refundable_storage_fee: g.nonRefundableStorageFee,
+                    },
+                },
+                balance_changes: (tr.balanceChanges ?? []).map((b) => ({
+                    address: b.address, coin_type: b.coinType, amount: b.amount,
+                })),
+            },
+        };
+    }
     reconcileAfterFailure(wallet, inType, outType) {
         for (const t of new Set([inType, outType, constants_1.SUI_TOKEN_ADDRESS.LONG]))
             void this.reconcileCoins(wallet, t);

package/dist/trade/executor/core_channel.js

@@ -21,6 +21,9 @@ const GRPC_CLIENT_OPTIONS = {
     'grpc.max_send_message_length': 8 * 1024 * 1024,
     'grpc.initial_reconnect_backoff_ms': 1000,
     'grpc.max_reconnect_backoff_ms': 30000,
+    'grpc-node.flow_control_window': 8 * 1024 * 1024,
+    'grpc-node.max_session_memory': 64,
+    'grpc.default_compression_algorithm': 2,
 };
 function buildGrpcCore(opts = {}) {
     const endpoint = opts.endpoint ?? (0, dist_1.getCoreEnv)().grpc_endpoint;

package/dist/trade/executor/executor_ws_client.js

@@ -19,7 +19,7 @@ class ExecutorWsClient {
         });
         this.ws.onMessage((data) => {
             try {
-                const env = JSON.parse(typeof data === 'string' ? data : data.toString());
+                const env = (typeof data === 'string' ? JSON.parse(data) : data);
                 const p = this.pending.get(env.reqId);
                 if (!p)
                     return;

package/dist/trade/parse/sui_tx_parser.js

@@ -177,7 +177,7 @@ class SuiTransactionParser {
         return Date.now();
     }
     extractCheckpoint(receipt) {
-        return parseInt(receipt.checkpoint || '0');
+        return parseInt(receipt.transaction?.checkpoint || receipt.checkpoint || '0');
     }
 }
 exports.SuiTransactionParser = SuiTransactionParser;

package/dist/trade/tx_result_channel.d.ts

@@ -4,4 +4,7 @@ export interface SuiTxResultMsg {
     success?: boolean;
     error?: string;
     source?: 'executor' | 'stream-trade';
+    receipt?: {
+        transaction: any;
+    };
 }

package/dist/type/index.d.ts

@@ -1,8 +1,9 @@
 export interface BlockUpdateEvent {
-    blockHash: string;
     blockNumber: number;
-    blockTime: number;
-    transactions: TransactionData[];
+    blockTimestamp: number;
+    blockTimestampMs: number;
+    recvBlockTime: number;
+    blockHash?: string;
 }
 export interface TransactionData {
     txHash: string;

package/package.json

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