@clonegod/ttd-sui-common 2.0.9 → 2.0.10

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

@@ -61,6 +61,7 @@ export declare class CentralExecutor {
     private readonly maxRebuildRetries;
     constructor(core: ExecutorCore, opts?: CentralExecutorOptions);
     init(): Promise<void>;
+    private dumpAllCoins;
     private warmup;
     reconcileCoins(wallet: string, coinType: string, quietIfUnchanged?: boolean): Promise<void>;
     rebalanceWalletFunds(): Promise<void>;
@@ -68,6 +69,10 @@ export declare class CentralExecutor {
     private decimalsCache;
     private objectReader?;
     private getCoinDecimalsCached;
+    private coinSymbol;
+    private pairLabel;
+    private fmtAmount;
+    private walletBalancesLabel;
     private maintainCoinObjects;
     private execMaintenance;
     private poolGenericsCache;

package/dist/trade/executor/central_executor.js

@@ -48,6 +48,7 @@ class CentralExecutor {
         this.onBroadcastResult = opts.onBroadcastResult;
         this.tradeCoinTypesProvider = opts.tradeCoinTypes;
         this.tradePoolsProvider = opts.tradePools;
+        this.cache.setAmountFormatter((ct, raw) => this.fmtAmount(ct, raw));
     }
     async init() {
         const tradeIds = (process.env.SUI_WALLET_GROUP_IDS || '').split(',').map(s => s.trim()).filter(Boolean);
@@ -62,6 +63,28 @@ class CentralExecutor {
         }
         (0, dist_1.log_info)(`[executor] init: trade=${[...this.tradeWallets.keys()].join(',')} (单钱包模式: gas=各自地址余额), gasBudget=${this.gasBudget}`);
         await this.warmup();
+        await this.dumpAllCoins();
+    }
+    async dumpAllCoins() {
+        if (!this.tradeCoinTypesProvider)
+            return;
+        try {
+            const types = [...new Set((await this.tradeCoinTypesProvider()).map(t => (0, format_1.normalizeSuiTokenAddress)(t)))];
+            await Promise.all(types.map(t => this.getCoinDecimalsCached(t).catch(() => { })));
+            for (const w of this.tradeWallets.keys()) {
+                for (const t of types) {
+                    if (t === constants_1.SUI_TOKEN_ADDRESS.LONG) {
+                        this.cache.logCoinBreakdown(w, t, '启动一览');
+                        continue;
+                    }
+                    await this.reconcileCoins(w, t);
+                }
+            }
+            (0, dist_1.log_info)(`[executor] 启动 coin 一览完成: ${types.length} 币种 × ${this.tradeWallets.size} 钱包`);
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[executor] 启动 coin 一览失败（首笔将冷 reconcile）: ${e.message}`);
+        }
     }
     async warmup() {
         try {
@@ -208,6 +231,26 @@ class CentralExecutor {
         }
         return d;
     }
+    coinSymbol(coinType) { return coinType.split('::').pop() || coinType; }
+    pairLabel(req) {
+        return `${this.coinSymbol(this.inputCoinType(req))}→${this.coinSymbol(this.outputCoinType(req))}`;
+    }
+    fmtAmount(coinType, raw) {
+        const sym = this.coinSymbol(coinType);
+        const d = this.decimalsCache.get(coinType);
+        if (d == null)
+            return `${raw.toString()}(raw) ${sym}`;
+        const neg = raw < 0n, v = neg ? -raw : raw, base = 10n ** BigInt(d);
+        const intStr = (v / base).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+        const frac = (v % base).toString().padStart(d, '0').replace(/0+$/, '');
+        return `${neg ? '-' : ''}${intStr}${frac ? '.' + frac : ''} ${sym}`;
+    }
+    walletBalancesLabel(coinType) {
+        return [...this.tradeWallets.keys()].map(w => {
+            const { total, count } = this.cache.snapshot(w, coinType);
+            return `${w.slice(0, 8)}…=${this.fmtAmount(coinType, total)}(${count}枚)`;
+        }).join(', ');
+    }
     async maintainCoinObjects(addr, kp, coinType, opts) {
         const short = coinType.split('::').pop();
         const zeroMergeMin = Number(process.env.SUI_ZERO_COIN_MERGE_THRESHOLD || 3);
@@ -379,19 +422,27 @@ class CentralExecutor {
         const t0 = Date.now();
         req = await this.canonicalizeReq(req);
         const inType = this.inputCoinType(req);
+        await this.getCoinDecimalsCached(inType).catch(() => { });
         let wallet;
         try {
             wallet = this.chooseTradeWallet(req, inType, req.amountIn);
         }
         catch (e) {
-            (0, dist_1.log_warn)(`[executor] ${inType} 选钱包失败（${e.message}），按需 reconcile 后重试`);
+            (0, dist_1.log_warn)(`[executor] ${this.pairLabel(req)} 选钱包失败：需 ${this.fmtAmount(inType, req.amountIn)}，当前各钱包缓存 [${this.walletBalancesLabel(inType)}] → 按需 reconcile 重试`);
             await Promise.all([...this.tradeWallets.keys()].map(w => this.reconcileCoins(w, inType)));
-            wallet = this.chooseTradeWallet(req, inType, req.amountIn);
+            try {
+                wallet = this.chooseTradeWallet(req, inType, req.amountIn);
+            }
+            catch (e2) {
+                (0, dist_1.log_error)(`[executor] ${this.pairLabel(req)} 余额不足：需 ${this.fmtAmount(inType, req.amountIn)}，reconcile 后各钱包缓存仍 [${this.walletBalancesLabel(inType)}]`, e2);
+                throw e2;
+            }
         }
         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)`);
+        const acqTotal = inputRes.coins.reduce((s, c) => s + BigInt(c.balance), 0n);
+        (0, dist_1.log_info)(`[executor] coin 已占用 wallet=${wallet.slice(0, 8)}… ${this.pairLabel(req)} 取 ${inputRes.coins.length} 枚=${this.fmtAmount(inType, acqTotal)}（需 ${this.fmtAmount(inType, req.amountIn)}）选钱包+占币 ${tAcquire - t0}ms`);
         try {
             const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
             const tBuild = Date.now();
@@ -399,7 +450,7 @@ class CentralExecutor {
             const digest = await tx.getDigest();
             const tSign = Date.now();
             void this.broadcastAndCommit(txBytes, [senderSig], digest, wallet, req, inputRes.coins, inputTag);
-            (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}`);
+            (0, dist_1.log_info)(`[executor] swap 已签提交 digest=${digest} dex=${req.dexId} ${this.pairLabel(req)} in=${this.fmtAmount(inType, req.amountIn)} minOut=${this.fmtAmount(this.outputCoinType(req), req.minOut)} cost={build:${tBuild - tAcquire}ms, sign+digest:${tSign - tBuild}ms, total:${tSign - t0}ms}`);
             return { digest, submitted: true };
         }
         catch (e) {

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

@@ -2,10 +2,16 @@ import { CoinRef, CoinReservation, CoinObjectChange } from '../coin/types';
 export declare class InProcessCoinCache {
     private available;
     private inflight;
+    private committedAt;
+    private commitKey;
     private epochs;
     private epochKey;
     private bumpEpoch;
     mutationEpoch(wallet: string, coinType: string): number;
+    private amountFmt?;
+    setAmountFormatter(fn: (coinType: string, raw: bigint) => string): void;
+    private fmt;
+    logCoinBreakdown(wallet: string, coinType: string, reason: string, quiet?: boolean): void;
     private walletMap;
     private list;
     private sortDesc;

package/dist/trade/executor/coin_cache.js

@@ -6,8 +6,10 @@ class InProcessCoinCache {
     constructor() {
         this.available = new Map();
         this.inflight = new Map();
+        this.committedAt = new Map();
         this.epochs = new Map();
     }
+    commitKey(wallet, coinType, objectId) { return `${wallet}|${coinType}|${objectId}`; }
     epochKey(wallet, coinType) { return `${wallet}|${coinType}`; }
     bumpEpoch(wallet, coinType) {
         const k = this.epochKey(wallet, coinType);
@@ -16,6 +18,30 @@ class InProcessCoinCache {
     mutationEpoch(wallet, coinType) {
         return this.epochs.get(this.epochKey(wallet, coinType)) || 0;
     }
+    setAmountFormatter(fn) { this.amountFmt = fn; }
+    fmt(coinType, raw) { return this.amountFmt ? this.amountFmt(coinType, raw) : `${raw.toString()}(raw)`; }
+    logCoinBreakdown(wallet, coinType, reason, quiet = false) {
+        const l = this.list(wallet, coinType);
+        const total = l.reduce((s, c) => s + BigInt(c.balance), 0n);
+        const symbol = coinType.split('::').pop();
+        const detail = {
+            reason, wallet, symbol, coinType,
+            count: l.length,
+            total: this.fmt(coinType, total),
+            total_raw: total.toString(),
+            objects: l.map(c => ({
+                objectId: c.objectId,
+                version: c.version,
+                balance: this.fmt(coinType, BigInt(c.balance)),
+                balance_raw: c.balance,
+            })),
+        };
+        const header = `[coin-cache] ${reason} ${symbol} ${l.length}枚 total=${this.fmt(coinType, total)}`;
+        if (quiet)
+            (0, dist_1.log_debug)(header, detail);
+        else
+            (0, dist_1.log_info)(header, detail);
+    }
     walletMap(wallet) {
         let m = this.available.get(wallet);
         if (!m) {
@@ -54,18 +80,32 @@ class InProcessCoinCache {
                 r.coins.forEach(c => inflightIds.add(c.objectId));
         }
         const prev = new Map(this.list(wallet, coinType).map(c => [c.objectId, c]));
+        const freshIds = new Set(freshCoins.map(c => c.objectId));
         const kept = freshCoins
             .filter(c => !inflightIds.has(c.objectId))
             .map(c => { const old = prev.get(c.objectId); return old && BigInt(old.version) > BigInt(c.version) ? old : c; });
+        const keptIds = new Set(kept.map(c => c.objectId));
+        const now = Date.now();
+        const graceMs = Number(process.env.SUI_COIN_RECONCILE_GRACE_MS || 10000);
+        for (const [id, c] of prev) {
+            if (keptIds.has(id) || inflightIds.has(id) || freshIds.has(id))
+                continue;
+            const ts = this.committedAt.get(this.commitKey(wallet, coinType, id));
+            if (ts != null && now - ts < graceMs) {
+                kept.push(c);
+                keptIds.add(id);
+            }
+        }
+        for (const id of freshIds)
+            this.committedAt.delete(this.commitKey(wallet, coinType, id));
+        for (const id of prev.keys())
+            if (!keptIds.has(id))
+                this.committedAt.delete(this.commitKey(wallet, coinType, id));
         this.sortDesc(kept);
         const sig = (l) => l.map(c => `${c.objectId}@${c.version}:${c.balance}`).join(',');
         const unchanged = sig(kept) === sig(this.list(wallet, coinType));
         this.walletMap(wallet).set(coinType, kept);
-        const msg = `[coin-cache] reconcile ${wallet} ${coinType}: ${kept.length} avail (${inflightIds.size} inflight kept)`;
-        if (unchanged && quietIfUnchanged)
-            (0, dist_1.log_debug)(msg);
-        else
-            (0, dist_1.log_info)(msg);
+        this.logCoinBreakdown(wallet, coinType, `reconcile(${inflightIds.size}在途)`, unchanged && quietIfUnchanged);
         return true;
     }
     acquire(wallet, coinType, amount, txTag, maxCoins = 8) {
@@ -126,6 +166,7 @@ class InProcessCoinCache {
             const wallet = res.wallet;
             if (ch.kind === 'deleted') {
                 this.removeEverywhere(wallet, ch.coinType, ch.objectId);
+                this.committedAt.delete(this.commitKey(wallet, ch.coinType, ch.objectId));
                 continue;
             }
             if (ch.version == null || ch.digest == null) {
@@ -139,7 +180,10 @@ class InProcessCoinCache {
             const l = this.list(wallet, ch.coinType);
             l.push(ref);
             this.sortDesc(l);
+            this.committedAt.set(this.commitKey(wallet, ch.coinType, ch.objectId), Date.now());
         }
+        for (const ct of new Set(changes.map(c => c.coinType)))
+            this.logCoinBreakdown(res.wallet, ct, 'commit后');
     }
     abort(txTag, consumed) {
         const res = this.inflight.get(txTag);
@@ -150,6 +194,8 @@ class InProcessCoinCache {
         this.inflight.delete(txTag);
         this.bumpEpoch(res.wallet, res.coinType);
         if (consumed) {
+            for (const c of res.coins)
+                this.committedAt.delete(this.commitKey(res.wallet, res.coinType, c.objectId));
             (0, dist_1.log_warn)(`[coin-cache] abort consumed txTag=${txTag}（${res.coins.length} coin 交 reconcile 兜底）`);
             return;
         }

package/package.json

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