@clonegod/ttd-sui-common 2.0.9 → 2.0.11

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

@@ -61,13 +61,19 @@ 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>;
     private rebalanceOne;
+    private selectWalletWithBalance;
     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 {
@@ -194,6 +217,17 @@ class CentralExecutor {
                 return;
         }
     }
+    async selectWalletWithBalance(inType, amount) {
+        let best = null;
+        for (const w of this.tradeWallets.keys()) {
+            const objs = this.cache.snapshot(w, inType).total;
+            const b = await this.core.getBalance({ owner: w, coinType: inType });
+            const ab = BigInt(b.balance.addressBalance ?? '0');
+            if (objs + ab >= amount && (!best || objs + ab > best.sum))
+                best = { wallet: w, addressBalance: ab, sum: objs + ab };
+        }
+        return best ? { wallet: best.wallet, addressBalance: best.addressBalance } : null;
+    }
     async getCoinDecimalsCached(coinType) {
         let d = this.decimalsCache.get(coinType);
         if (d == null) {
@@ -208,6 +242,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,27 +433,49 @@ class CentralExecutor {
         const t0 = Date.now();
         req = await this.canonicalizeReq(req);
         const inType = this.inputCoinType(req);
-        let wallet;
+        await this.getCoinDecimalsCached(inType).catch(() => { });
+        let wallet = '';
+        let inputCoins = [];
+        let inputTag = '';
+        let shortfall = 0n;
         try {
             wallet = this.chooseTradeWallet(req, inType, req.amountIn);
+            inputTag = this.nextTag('in');
+            inputCoins = this.cache.acquire(wallet, inType, req.amountIn, inputTag).coins;
         }
         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);
+                inputTag = this.nextTag('in');
+                inputCoins = this.cache.acquire(wallet, inType, req.amountIn, inputTag).coins;
+            }
+            catch (e2) {
+                const picked = await this.selectWalletWithBalance(inType, req.amountIn);
+                if (!picked) {
+                    (0, dist_1.log_error)(`[executor] ${this.pairLabel(req)} 余额不足：需 ${this.fmtAmount(inType, req.amountIn)}，对象+address-balance 仍不够 [${this.walletBalancesLabel(inType)}]`, e2);
+                    throw e2;
+                }
+                wallet = picked.wallet;
+                inputTag = this.nextTag('in');
+                inputCoins = this.cache.acquireAvailable(wallet, inType, req.amountIn, inputTag);
+                const objSum = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+                shortfall = req.amountIn - objSum;
+            }
         }
-        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 = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+        const shortStr = shortfall > 0n ? ` + address-balance 补 ${this.fmtAmount(inType, shortfall)}` : '';
+        (0, dist_1.log_info)(`[executor] coin 已占用 wallet=${wallet.slice(0, 8)}… ${this.pairLabel(req)} 取 ${inputCoins.length} 枚=${this.fmtAmount(inType, acqTotal)}${shortStr}（需 ${this.fmtAmount(inType, req.amountIn)}）选钱包+占币 ${tAcquire - t0}ms`);
         try {
-            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
+            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputCoins, shortfall);
             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, 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}`);
+            void this.broadcastAndCommit(txBytes, [senderSig], digest, wallet, req, inputCoins, inputTag, 0, shortfall > 0n);
+            (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) {
@@ -408,7 +484,7 @@ class CentralExecutor {
             return { digest: '', submitted: false, error: e.message };
         }
     }
-    async broadcastAndCommit(txBytes, signatures, digest, wallet, req, inputCoins, inputTag, attempt = 0) {
+    async broadcastAndCommit(txBytes, signatures, digest, wallet, req, inputCoins, inputTag, attempt = 0, usedAddressBalance = false) {
         const inType = this.inputCoinType(req);
         const outType = this.outputCoinType(req);
         const tBroadcast = Date.now();
@@ -430,13 +506,13 @@ class CentralExecutor {
                 this.onBroadcastResult?.({ digest, success: false, error, receipt: this.toCheckerReceipt(tr, digest) });
                 return;
             }
-            await this.onSuccess(tr, wallet, req, inputCoins, inputTag);
+            await this.onSuccess(tr, wallet, req, inputCoins, inputTag, usedAddressBalance);
             (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);
-            if (this.isRebuildableObjectError(e) && attempt < this.maxRebuildRetries) {
+            if (!usedAddressBalance && this.isRebuildableObjectError(e) && attempt < this.maxRebuildRetries) {
                 (0, dist_1.log_warn)(`[executor] swap 输入对象版本陈旧，定向刷新 ${inType.split('::').pop()} + 重建重发（第 ${attempt + 1}/${this.maxRebuildRetries} 次）digest=${digest}: ${e.message}`);
                 await this.reconcileCoins(wallet, inType);
                 const retry = await this.rebuildSwap(req, wallet);
@@ -551,17 +627,26 @@ class CentralExecutor {
             }
         }
     }
-    async buildSwapTx(req, wallet, inputCoins) {
+    async buildSwapTx(req, wallet, inputCoins, shortfall = 0n) {
         const tx = new transactions_1.Transaction();
         tx.setSender(wallet);
         await this.registerShared(tx, req.poolId, true);
         await this.registerShared(tx, (0, swap_1.configSharedObjectId)(req.dexId), true);
         tx.object(transactions_1.Inputs.SharedObjectRef({ objectId: swap_1.SUI_CLOCK_ID, initialSharedVersion: '1', mutable: false }));
-        const primary = tx.object(transactions_1.Inputs.ObjectRef(inputCoins[0]));
-        if (inputCoins.length > 1) {
-            tx.mergeCoins(primary, inputCoins.slice(1).map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
+        const inType = this.inputCoinType(req);
+        const usedBalance = shortfall > 0n || inputCoins.length === 0;
+        let inCoin;
+        if (inputCoins.length === 0) {
+            inCoin = (0, transactions_1.coinWithBalance)({ type: inType, balance: req.amountIn });
+        }
+        else {
+            const primary = tx.object(transactions_1.Inputs.ObjectRef(inputCoins[0]));
+            if (inputCoins.length > 1)
+                tx.mergeCoins(primary, inputCoins.slice(1).map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
+            if (shortfall > 0n)
+                tx.mergeCoins(primary, [(0, transactions_1.coinWithBalance)({ type: inType, balance: shortfall })]);
+            [inCoin] = tx.splitCoins(primary, [tx.pure.u64(req.amountIn)]);
         }
-        const [inCoin] = tx.splitCoins(primary, [tx.pure.u64(req.amountIn)]);
         const { outputCoin, leftoverCoins } = (0, swap_1.buildSwapMoveCall)(req.dexId, tx, {
             coinTypeA: req.coinTypeA, coinTypeB: req.coinTypeB, poolId: req.poolId,
             a2b: req.a2b, byAmountIn: true, amount: req.amountIn,
@@ -572,20 +657,26 @@ class CentralExecutor {
         tx.setExpiration(await this.getValidDuringExpiration());
         tx.setGasBudget(this.gasBudget);
         tx.setGasPrice(await this.getGasPrice());
-        const txBytes = await tx.build();
+        const txBytes = usedBalance ? await tx.build({ client: this.core.rawClient }) : await tx.build();
         return { txBytes, tx };
     }
-    async onSuccess(tr, wallet, req, inputCoins, inputTag) {
+    async onSuccess(tr, wallet, req, inputCoins, inputTag, usedAddressBalance = false) {
         const inType = this.inputCoinType(req);
         const outType = this.outputCoinType(req);
-        const inputTotal = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
-        const inputChanges = (0, effects_1.extractSwapInputChanges)(tr.effects, {
-            wallet, inCoinType: inType,
-            primaryId: inputCoins[0].objectId,
-            reservedInputIds: inputCoins.map(c => c.objectId),
-            inputTotal, amountIn: req.amountIn,
-        });
-        this.cache.commit(inputTag, inputChanges);
+        if (usedAddressBalance) {
+            this.cache.abort(inputTag, true);
+            await this.reconcileCoins(wallet, inType);
+        }
+        else {
+            const inputTotal = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+            const inputChanges = (0, effects_1.extractSwapInputChanges)(tr.effects, {
+                wallet, inCoinType: inType,
+                primaryId: inputCoins[0].objectId,
+                reservedInputIds: inputCoins.map(c => c.objectId),
+                inputTotal, amountIn: req.amountIn,
+            });
+            this.cache.commit(inputTag, inputChanges);
+        }
         if (this.reconcileAfterTx) {
             void this.postTradeRebalance(wallet, inType, outType);
         }

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

@@ -2,16 +2,23 @@ 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;
     seed(wallet: string, coinType: string, coins: CoinRef[]): void;
     reconcile(wallet: string, coinType: string, freshCoins: CoinRef[], epochAtStart?: number, quietIfUnchanged?: boolean): boolean;
     acquire(wallet: string, coinType: string, amount: bigint, txTag: string, maxCoins?: number): CoinReservation;
+    acquireAvailable(wallet: string, coinType: string, amount: bigint, txTag: string): CoinRef[];
     reserve(wallet: string, coinType: string, objectIds: string[], txTag: string): CoinRef[] | null;
     hasInflight(wallet: string, coinType: string): boolean;
     commit(txTag: string, changes: CoinObjectChange[]): void;

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,36 @@ 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 avail = this.list(wallet, coinType);
+        const inUse = [];
+        for (const r of this.inflight.values()) {
+            if (r.wallet === wallet && r.coinType === coinType)
+                inUse.push(...r.coins);
+        }
+        const symbol = coinType.split('::').pop();
+        const sum = (cs) => cs.reduce((s, c) => s + BigInt(c.balance), 0n);
+        const availT = sum(avail), useT = sum(inUse), grand = availT + useT;
+        const mapObj = (cs) => cs.map(c => ({
+            objectId: c.objectId,
+            version: c.version,
+            balance: this.fmt(coinType, BigInt(c.balance)),
+        }));
+        const detail = {
+            reason, wallet, symbol, coinType,
+            total: this.fmt(coinType, grand),
+            available_count: avail.length, available_total: this.fmt(coinType, availT), available: mapObj(avail),
+            in_use_count: inUse.length, in_use_total: this.fmt(coinType, useT), in_use: mapObj(inUse),
+        };
+        const useStr = inUse.length ? `, ${inUse.length} 个正在交易中` : '';
+        const header = `[coin-cache] ${reason} ${symbol}: 共 ${this.fmt(coinType, grand)}（可用 ${avail.length} 个${useStr}）`;
+        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 +86,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, '链上对账', unchanged && quietIfUnchanged);
         return true;
     }
     acquire(wallet, coinType, amount, txTag, maxCoins = 8) {
@@ -92,6 +138,24 @@ class InProcessCoinCache {
         this.bumpEpoch(wallet, coinType);
         return { txTag, coinType, coins: picked };
     }
+    acquireAvailable(wallet, coinType, amount, txTag) {
+        if (this.inflight.has(txTag))
+            throw new Error(`[coin-cache] txTag 重复: ${txTag}`);
+        const l = this.list(wallet, coinType);
+        const picked = [];
+        let sum = 0n;
+        for (const c of l) {
+            if (sum >= amount)
+                break;
+            picked.push(c);
+            sum += BigInt(c.balance);
+        }
+        const ids = new Set(picked.map(c => c.objectId));
+        this.walletMap(wallet).set(coinType, l.filter(c => !ids.has(c.objectId)));
+        this.inflight.set(txTag, { wallet, coinType, coins: picked, gas: false });
+        this.bumpEpoch(wallet, coinType);
+        return picked;
+    }
     reserve(wallet, coinType, objectIds, txTag) {
         if (this.inflight.has(txTag))
             throw new Error(`[coin-cache] txTag 重复: ${txTag}`);
@@ -126,6 +190,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 +204,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, '交易后更新');
     }
     abort(txTag, consumed) {
         const res = this.inflight.get(txTag);
@@ -150,6 +218,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.11",
   "description": "Sui common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",