@clonegod/ttd-sui-common 2.0.8 → 2.0.10

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

@@ -35,6 +35,12 @@ export interface CentralExecutorOptions {
         };
     }) => void;
     tradeCoinTypes?: () => Promise<string[]>;
+    tradePools?: () => Promise<Array<{
+        dexId: DEX_ID;
+        poolId: string;
+        coinTypeA: string;
+        coinTypeB: string;
+    }>>;
 }
 type TxResponse = SuiClientTypes.Transaction<{
     effects: true;
@@ -51,14 +57,22 @@ export declare class CentralExecutor {
     private sharedRefCache;
     private seq;
     private readonly tradeCoinTypesProvider?;
+    private readonly tradePoolsProvider?;
+    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 decimalsCache;
     private objectReader?;
     private getCoinDecimalsCached;
+    private coinSymbol;
+    private pairLabel;
+    private fmtAmount;
+    private walletBalancesLabel;
     private maintainCoinObjects;
     private execMaintenance;
     private poolGenericsCache;
@@ -76,6 +90,8 @@ export declare class CentralExecutor {
     private registerShared;
     submitSwap(req: SwapExecRequest): Promise<SwapSubmitResult>;
     private broadcastAndCommit;
+    private isRebuildableObjectError;
+    private rebuildSwap;
     private toCheckerReceipt;
     private reconcileAfterFailure;
     simulateSwap(req: SwapExecRequest): Promise<TxResponse>;

package/dist/trade/executor/central_executor.js

@@ -38,6 +38,7 @@ class CentralExecutor {
         this.tradeWallets = new Map();
         this.sharedRefCache = new Map();
         this.seq = 0;
+        this.maxRebuildRetries = Number(process.env.SUI_SWAP_REBUILD_RETRIES || 2);
         this.decimalsCache = new Map();
         this.poolGenericsCache = new Map();
         this.chainIdentifier = '';
@@ -46,6 +47,8 @@ class CentralExecutor {
         this.reconcileAfterTx = opts.reconcileAfterTx ?? true;
         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);
@@ -59,6 +62,58 @@ class CentralExecutor {
             await this.reconcileCoins(w, constants_1.SUI_TOKEN_ADDRESS.LONG);
         }
         (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 {
+            await Promise.all([this.getGasPrice(), this.getValidDuringExpiration()]);
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[executor] 预热全局缓存(gas/epoch)失败（首笔将冷启动）: ${e.message}`);
+        }
+        if (!this.tradePoolsProvider)
+            return;
+        try {
+            const pools = await this.tradePoolsProvider();
+            let ok = 0;
+            await Promise.all(pools.map(async (p) => {
+                try {
+                    await this.canonicalizeReq({ dexId: p.dexId, poolId: p.poolId, coinTypeA: p.coinTypeA, coinTypeB: p.coinTypeB, a2b: true, amountIn: 0n, minOut: 0n, sqrtPriceLimit: 0n });
+                    await this.getSharedRefCached(p.poolId);
+                    await this.getSharedRefCached((0, swap_1.configSharedObjectId)(p.dexId));
+                    ok++;
+                }
+                catch (e) {
+                    (0, dist_1.log_warn)(`[executor] 预热池 ${p.poolId.slice(0, 10)}…(${p.dexId}) 失败（首笔冷启动，自愈）: ${e.message}`);
+                }
+            }));
+            (0, dist_1.log_info)(`[executor] 预热完成: ${ok}/${pools.length} 池 shared ref + 链上真序 + gas/epoch 全局缓存`);
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[executor] 读交易池清单失败，跳过池级预热: ${e.message}`);
+        }
     }
     async reconcileCoins(wallet, coinType, quietIfUnchanged = false) {
         try {
@@ -176,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);
@@ -202,17 +277,18 @@ class CentralExecutor {
         const others = coins.filter(c => c.objectId !== primaryRef.objectId);
         if (others.length)
             tx.mergeCoins(primary, others.map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
+        const per = pieces > 1 ? total / BigInt(pieces) : 0n;
         if (pieces > 1) {
-            const per = total / BigInt(pieces);
             const splits = tx.splitCoins(primary, Array.from({ length: pieces - 1 }, () => tx.pure.u64(per)));
             tx.transferObjects(Array.from({ length: pieces - 1 }, (_, i) => splits[i]), tx.pure.address(addr));
         }
         tx.setGasPayment([]);
         tx.setExpiration(await this.getValidDuringExpiration());
-        await this.execMaintenance(tx, addr, kp, opts.budget, `整理 ${short}：${valued.length} 值 + ${zeros.length} 壳 → ${pieces} 份均分（每份≈${(total / BigInt(pieces)).toString()}）`, undefined, coinType, tag);
+        await this.execMaintenance(tx, addr, kp, opts.budget, `整理 ${short}：${valued.length} 值 + ${zeros.length} 壳 → ${pieces} 份均分（每份≈${(total / BigInt(pieces)).toString()}）`, undefined, coinType, tag, { primaryId: primaryRef.objectId, perPiece: per, primaryRemainder: total - per * BigInt(pieces - 1), reservedIds: coins.map(c => c.objectId) });
         return true;
     }
-    async execMaintenance(tx, addr, kp, budget, label, buildClient, coinType = constants_1.SUI_TOKEN_ADDRESS.LONG, reserveTag) {
+    async execMaintenance(tx, addr, kp, budget, label, buildClient, coinType = constants_1.SUI_TOKEN_ADDRESS.LONG, reserveTag, commitPlan) {
+        let committed = false;
         try {
             tx.setGasBudget(budget);
             tx.setGasPrice(await this.getGasPrice());
@@ -222,11 +298,18 @@ class CentralExecutor {
             const tr = resp.Transaction;
             const { success, error } = (0, effects_1.coreTxStatus)(tr.effects);
             (0, dist_1.log_info)(`[executor] rebalance ${label} ${success ? 'OK' : 'FAILED'} wallet=${addr.slice(0, 10)}… digest=${tr.digest}${error ? ' err=' + error : ''}`);
+            if (success && commitPlan && reserveTag && tr.effects) {
+                const changes = (0, effects_1.extractMaintCoinChanges)(tr.effects, { wallet: addr, coinType, ...commitPlan });
+                this.cache.commit(reserveTag, changes);
+                committed = true;
+            }
         }
         finally {
-            if (reserveTag)
-                this.cache.abort(reserveTag, true);
-            await this.reconcileCoins(addr, coinType);
+            if (!committed) {
+                if (reserveTag)
+                    this.cache.abort(reserveTag, true);
+                await this.reconcileCoins(addr, coinType);
+            }
         }
     }
     async getPoolGenerics(poolId) {
@@ -339,27 +422,35 @@ 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();
             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} cost={build:${tBuild - tAcquire}ms, sign+digest:${tSign - tBuild}ms, total:${tSign - t0}ms}`);
+            void this.broadcastAndCommit(txBytes, [senderSig], digest, wallet, req, inputRes.coins, inputTag);
+            (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) {
@@ -368,7 +459,9 @@ class CentralExecutor {
             return { digest: '', submitted: false, error: e.message };
         }
     }
-    async broadcastAndCommit(txBytes, signatures, digest, wallet, inType, outType, inputCoins, inputTag) {
+    async broadcastAndCommit(txBytes, signatures, digest, wallet, req, inputCoins, inputTag, attempt = 0) {
+        const inType = this.inputCoinType(req);
+        const outType = this.outputCoinType(req);
         const tBroadcast = Date.now();
         try {
             const resp = await this.core.executeTransaction({ transaction: txBytes, signatures, include: { effects: true, objectTypes: true, balanceChanges: true } });
@@ -388,14 +481,47 @@ class CentralExecutor {
                 this.onBroadcastResult?.({ digest, success: false, error, receipt: this.toCheckerReceipt(tr, digest) });
                 return;
             }
-            await this.onSuccess(tr, wallet, inType, outType, inputCoins, inputTag);
+            await this.onSuccess(tr, wallet, req, inputCoins, inputTag);
             (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) {
+                (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);
+                if (retry) {
+                    void this.broadcastAndCommit(retry.txBytes, retry.signatures, retry.digest, wallet, req, retry.inputCoins, retry.inputTag, attempt + 1);
+                    return;
+                }
+                (0, dist_1.log_warn)(`[executor] swap 重建失败（输入不足等），转 reconcile 兜底 digest=${digest}`);
+            }
             this.reconcileAfterFailure(wallet, inType, outType);
-            (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest} broadcast=${Date.now() - tBroadcast}ms`, e);
+            (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest} broadcast=${Date.now() - tBroadcast}ms attempt=${attempt}`, e);
+        }
+    }
+    isRebuildableObjectError(e) {
+        const err = e;
+        const msg = (err?.message || String(e)).toLowerCase();
+        return msg.includes('unavailable for consumption')
+            || msg.includes('needs to be rebuilt')
+            || (err?.code === 'INVALID_ARGUMENT' && msg.includes('object'));
+    }
+    async rebuildSwap(req, wallet) {
+        try {
+            const inType = this.inputCoinType(req);
+            const inputTag = this.nextTag('in');
+            const inputRes = this.cache.acquire(wallet, inType, req.amountIn, inputTag);
+            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
+            const { signature } = await this.tradeWallets.get(wallet).signTransaction(txBytes);
+            const digest = await tx.getDigest();
+            (0, dist_1.log_info)(`[executor] swap 重建 digest=${digest} dex=${req.dexId} ${req.a2b ? 'a2b' : 'b2a'} in=${req.amountIn}`);
+            return { txBytes, signatures: [signature], digest, inputCoins: inputRes.coins, inputTag };
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[executor] swap 重建失败 dex=${req.dexId}: ${e.message}`);
+            return null;
         }
     }
     toCheckerReceipt(tr, digest) {
@@ -500,13 +626,17 @@ class CentralExecutor {
         const txBytes = await tx.build();
         return { txBytes, tx };
     }
-    async onSuccess(tr, wallet, inType, outType, inputCoins, inputTag) {
-        const objectTypes = await tr.objectTypes;
-        const coinTypeById = new Map();
-        for (const c of inputCoins)
-            coinTypeById.set(c.objectId, inType);
-        const tradeChanges = (0, effects_1.extractCoinChangesFromCore)(tr.effects, objectTypes, { owners: new Set([wallet]), coinTypeById });
-        this.cache.commit(inputTag, tradeChanges);
+    async onSuccess(tr, wallet, req, inputCoins, inputTag) {
+        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 (this.reconcileAfterTx) {
             void this.postTradeRebalance(wallet, inType, outType);
         }

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) {
@@ -53,16 +79,33 @@ class InProcessCoinCache {
             if (r.wallet === wallet && r.coinType === coinType)
                 r.coins.forEach(c => inflightIds.add(c.objectId));
         }
-        const kept = freshCoins.filter(c => !inflightIds.has(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) {
@@ -123,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) {
@@ -136,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);
@@ -147,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/dist/trade/executor/effects.d.ts

@@ -13,4 +13,22 @@ export interface ExtractCoinChangesOptions {
     coinTypeById?: Map<string, string>;
 }
 export declare function extractCoinChangesFromCore(effects: TransactionEffects, objectTypes: Record<string, string>, opts?: ExtractCoinChangesOptions): CoinObjectChange[];
+export interface MaintCoinChangesOptions {
+    wallet: string;
+    coinType: string;
+    primaryId: string;
+    perPiece: bigint;
+    primaryRemainder: bigint;
+    reservedIds: string[];
+}
+export declare function extractMaintCoinChanges(effects: TransactionEffects, o: MaintCoinChangesOptions): CoinObjectChange[];
+export interface SwapInputChangesOptions {
+    wallet: string;
+    inCoinType: string;
+    primaryId: string;
+    reservedInputIds: string[];
+    inputTotal: bigint;
+    amountIn: bigint;
+}
+export declare function extractSwapInputChanges(effects: TransactionEffects, o: SwapInputChangesOptions): CoinObjectChange[];
 export {};

package/dist/trade/executor/effects.js

@@ -4,6 +4,8 @@ exports.parseCoinType = parseCoinType;
 exports.coreTxStatus = coreTxStatus;
 exports.coreGasUsed = coreGasUsed;
 exports.extractCoinChangesFromCore = extractCoinChangesFromCore;
+exports.extractMaintCoinChanges = extractMaintCoinChanges;
+exports.extractSwapInputChanges = extractSwapInputChanges;
 function parseCoinType(type) {
     if (!type)
         return null;
@@ -52,6 +54,53 @@ function extractCoinChangesFromCore(effects, objectTypes, opts = {}) {
     }
     return out;
 }
+function extractMaintCoinChanges(effects, o) {
+    const out = [];
+    const reserved = new Set(o.reservedIds);
+    for (const ch of effects.changedObjects) {
+        const kind = changedKind(ch);
+        if (!kind)
+            continue;
+        if (kind === 'deleted') {
+            if (reserved.has(ch.objectId))
+                out.push({ kind: 'deleted', objectId: ch.objectId, coinType: o.coinType });
+            continue;
+        }
+        if (ownerAddress(ch.outputOwner) !== o.wallet)
+            continue;
+        if (ch.objectId === o.primaryId) {
+            out.push({ kind: 'mutated', objectId: ch.objectId, coinType: o.coinType,
+                version: ch.outputVersion ?? undefined, digest: ch.outputDigest ?? undefined, balance: o.primaryRemainder.toString() });
+        }
+        else if (kind === 'created') {
+            out.push({ kind: 'created', objectId: ch.objectId, coinType: o.coinType,
+                version: ch.outputVersion ?? undefined, digest: ch.outputDigest ?? undefined, balance: o.perPiece.toString() });
+        }
+    }
+    return out;
+}
+function extractSwapInputChanges(effects, o) {
+    const out = [];
+    const reserved = new Set(o.reservedInputIds);
+    const leftover = o.inputTotal - o.amountIn;
+    for (const ch of effects.changedObjects) {
+        const kind = changedKind(ch);
+        if (!kind)
+            continue;
+        if (kind === 'deleted') {
+            if (reserved.has(ch.objectId))
+                out.push({ kind: 'deleted', objectId: ch.objectId, coinType: o.inCoinType });
+            continue;
+        }
+        if (ch.objectId !== o.primaryId)
+            continue;
+        if (ownerAddress(ch.outputOwner) !== o.wallet)
+            continue;
+        out.push({ kind: 'mutated', objectId: ch.objectId, coinType: o.inCoinType,
+            version: ch.outputVersion ?? undefined, digest: ch.outputDigest ?? undefined, balance: leftover.toString() });
+    }
+    return out;
+}
 function changedKind(ch) {
     if (ch.idOperation === 'Created')
         return 'created';

package/package.json

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