@clonegod/ttd-sui-common 2.0.8 → 2.0.9

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,8 +57,11 @@ 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 warmup;
     reconcileCoins(wallet: string, coinType: string, quietIfUnchanged?: boolean): Promise<void>;
     rebalanceWalletFunds(): Promise<void>;
     private rebalanceOne;
@@ -76,6 +85,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,7 @@ class CentralExecutor {
         this.reconcileAfterTx = opts.reconcileAfterTx ?? true;
         this.onBroadcastResult = opts.onBroadcastResult;
         this.tradeCoinTypesProvider = opts.tradeCoinTypes;
+        this.tradePoolsProvider = opts.tradePools;
     }
     async init() {
         const tradeIds = (process.env.SUI_WALLET_GROUP_IDS || '').split(',').map(s => s.trim()).filter(Boolean);
@@ -59,6 +61,36 @@ 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();
+    }
+    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 {
@@ -202,17 +234,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 +255,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) {
@@ -358,7 +398,7 @@ class CentralExecutor {
             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);
+            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}`);
             return { digest, submitted: true };
         }
@@ -368,7 +408,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 +430,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 +575,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.js

@@ -53,7 +53,10 @@ 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 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; });
         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));

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.9",
   "description": "Sui common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",