@clonegod/ttd-sui-common 2.0.14 → 2.0.15

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

@@ -25,7 +25,6 @@ export interface SwapSubmitResult {
 }
 export interface CentralExecutorOptions {
     gasBudget?: bigint;
-    reconcileAfterTx?: boolean;
     onBroadcastResult?: (r: {
         digest: string;
         success: boolean;
@@ -51,7 +50,6 @@ export declare class CentralExecutor {
     private readonly core;
     private readonly cache;
     private readonly gasBudget;
-    private readonly reconcileAfterTx;
     private readonly onBroadcastResult?;
     private tradeWallets;
     private sharedRefCache;
@@ -67,51 +65,40 @@ export declare class CentralExecutor {
     rebalanceWalletFunds(): Promise<void>;
     private rebalanceOne;
     private rebalanceBalanceMode;
-    private rebalanceObjectMode;
     private sweepObjectsToBalance;
-    private selectWalletWithBalance;
     private decimalsCache;
     private objectReader?;
     private getCoinDecimalsCached;
     private coinSymbol;
     private pairLabel;
     private fmtAmount;
-    private walletBalancesLabel;
-    private maintainCoinObjects;
-    private execMaintenance;
     private poolGenericsCache;
     private getPoolGenerics;
     private canonicalizeReq;
     private getSharedRefCached;
     private chainIdentifier;
+    private chainIdInflight?;
     private epochCache;
+    private epochInflight?;
+    private cachedChainId;
+    private cachedEpoch;
     private getValidDuringExpiration;
     private getGasPrice;
     private fetchEpoch;
-    private fundModeFor;
     private nextTag;
     private inputCoinType;
     private outputCoinType;
-    private chooseTradeWallet;
     private registerShared;
     submitSwap(req: SwapExecRequest): Promise<SwapSubmitResult>;
     private submitSwapBalance;
     private broadcastBalanceAndCommit;
     private isInsufficientBalanceError;
     private rebuildWithObjects;
-    private broadcastAndCommit;
-    private isRebuildableObjectError;
-    private rebuildSwap;
     private toCheckerReceipt;
-    private reconcileAfterFailure;
     simulateSwap(req: SwapExecRequest): Promise<TxResponse>;
-    private minSplitFor;
-    private postTradeRebalance;
     private swapTxShell;
     private finishSwapTx;
-    private buildSwapTxObject;
     private buildSwapTxBalance;
-    private onSuccess;
     get coinCache(): InProcessCoinCache;
     get tradeWalletAddresses(): string[];
     get coreClient(): ExecutorCore;

package/dist/trade/executor/central_executor.js

@@ -45,7 +45,6 @@ class CentralExecutor {
         this.chainIdentifier = '';
         this.epochCache = null;
         this.gasBudget = opts.gasBudget ?? (0, format_1.suiToMist)(process.env.SUI_GAS_BUDGET, '0.05');
-        this.reconcileAfterTx = opts.reconcileAfterTx ?? true;
         this.onBroadcastResult = opts.onBroadcastResult;
         this.tradeCoinTypesProvider = opts.tradeCoinTypes;
         this.tradePoolsProvider = opts.tradePools;
@@ -143,6 +142,7 @@ class CentralExecutor {
         }
     }
     async rebalanceWalletFunds() {
+        void this.getValidDuringExpiration().catch(() => { });
         for (const [addr, kp] of this.tradeWallets) {
             try {
                 await this.rebalanceOne(addr, kp);
@@ -153,13 +153,10 @@ class CentralExecutor {
         }
     }
     async rebalanceOne(addr, kp) {
-        if (this.fundModeFor() === 'balance')
-            return this.rebalanceBalanceMode(addr, kp);
-        return this.rebalanceObjectMode(addr, kp);
+        return this.rebalanceBalanceMode(addr, kp);
     }
     async rebalanceBalanceMode(addr, kp) {
         const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
-        const budget = this.gasBudget;
         let tradeTypes = [];
         if (this.tradeCoinTypesProvider) {
             try {
@@ -169,132 +166,93 @@ class CentralExecutor {
                 (0, dist_1.log_warn)(`[executor] 读交易币种清单失败，本 tick 只归集 SUI: ${e.message}`);
             }
         }
-        for (const t of [SUI, ...new Set(tradeTypes.filter(t => t !== SUI))]) {
+        const types = [SUI, ...new Set(tradeTypes.filter(t => t !== SUI))];
+        const withObjects = [];
+        for (const t of types) {
+            try {
+                const b = await this.core.getBalance({ owner: addr, coinType: t });
+                if (BigInt(b.balance.balance ?? '0') > BigInt(b.balance.addressBalance ?? '0'))
+                    withObjects.push(t);
+            }
+            catch (e) {
+                withObjects.push(t);
+            }
+        }
+        if (withObjects.length === 0)
+            return;
+        for (const t of withObjects)
             await this.reconcileCoins(addr, t, true);
+        await this.sweepObjectsToBalance(addr, kp, withObjects, this.gasBudget);
+    }
+    async sweepObjectsToBalance(addr, kp, coinTypes, budget) {
+        const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
+        const plan = [];
+        for (const t of [...new Set(coinTypes)]) {
             if (this.cache.hasInflight(addr, t))
                 continue;
-            if (this.cache.snapshot(addr, t).coins.length === 0)
+            const coins = this.cache.snapshot(addr, t).coins;
+            if (coins.length === 0)
                 continue;
-            if (await this.sweepObjectsToBalance(addr, kp, t, budget))
-                return;
+            const tag = this.nextTag('sweep');
+            if (!this.cache.reserve(addr, t, coins.map(c => c.objectId), tag))
+                continue;
+            plan.push({ coinType: t, coins, tag });
         }
-    }
-    async rebalanceObjectMode(addr, kp) {
-        const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
-        const balanceMin = (0, format_1.suiToMist)(process.env.SUI_GAS_BALANCE_MIN, '0.5');
-        const balanceTarget = (0, format_1.suiToMist)(process.env.SUI_GAS_BALANCE_TARGET, '1');
-        const chunk = (0, format_1.suiToMist)(process.env.SUI_REDEEM_MIN_CHUNK, '0.1');
-        const budget = this.gasBudget;
-        const coinTarget = Number(process.env.SUI_INPUT_COIN_TARGET || 3);
-        const coinMax = Number(process.env.SUI_INPUT_COIN_MAX || 5);
-        await this.reconcileCoins(addr, SUI, true);
-        if (this.cache.hasInflight(addr, SUI))
+        if (plan.length === 0)
             return;
-        const b = await this.core.getBalance({ owner: addr, coinType: '0x2::sui::SUI' });
-        const ab = BigInt(b.balance.addressBalance ?? '0');
-        const coins = this.cache.snapshot(addr, SUI).coins.slice()
-            .sort((x, y) => (BigInt(y.balance) > BigInt(x.balance) ? 1 : BigInt(y.balance) < BigInt(x.balance) ? -1 : 0));
-        if (ab < balanceMin) {
-            const need = balanceTarget - ab;
-            const src = coins.find(c => BigInt(c.balance) >= need + budget);
-            if (!src) {
-                (0, dist_1.log_warn)(`[executor] ${addr.slice(0, 10)}… SUI address-balance ${ab} < gasMin ${balanceMin} 且无足额 SUI 对象充值 —— 请注资`);
+        try {
+            let suiAb = 0n;
+            try {
+                const sb = await this.core.getBalance({ owner: addr, coinType: '0x2::sui::SUI' });
+                suiAb = BigInt(sb.balance.addressBalance ?? '0');
+            }
+            catch { }
+            const balanceGas = suiAb >= budget;
+            const suiPlan = plan.find(p => p.coinType === SUI);
+            if (!balanceGas && !suiPlan) {
+                (0, dist_1.log_warn)(`[executor] sweep 跳过：SUI balance ${suiAb} < gas ${budget} 且无 SUI 对象付 gas（请注资）`);
                 return;
             }
             const tx = new transactions_1.Transaction();
             tx.setSender(addr);
-            const [dep] = tx.splitCoins(tx.gas, [tx.pure.u64(need)]);
-            tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: ['0x2::sui::SUI'], arguments: [dep, tx.pure.address(addr)] });
-            tx.setGasPayment([{ objectId: src.objectId, version: src.version, digest: src.digest }]);
-            await this.execMaintenance(tx, addr, kp, budget, `gas 储备充值 ${need} → balance`);
-            return;
-        }
-        if (ab > balanceTarget + chunk) {
-            const excess = ab - balanceTarget;
-            const rawClient = this.core.rawClient;
-            if (!rawClient)
-                return;
-            const tx = new transactions_1.Transaction();
-            tx.setSender(addr);
-            tx.transferObjects([(0, transactions_1.coinWithBalance)({ type: '0x2::sui::SUI', balance: excess, useGasCoin: false })], tx.pure.address(addr));
-            tx.setGasPayment([]);
-            tx.setExpiration(await this.getValidDuringExpiration());
-            await this.execMaintenance(tx, addr, kp, budget, `redeem 超额 ${excess} → coin`, rawClient);
-            return;
-        }
-        let tradeTypes = [];
-        if (this.tradeCoinTypesProvider) {
-            try {
-                tradeTypes = (await this.tradeCoinTypesProvider()).map(t => (0, format_1.normalizeSuiTokenAddress)(t));
+            if (balanceGas) {
+                tx.setGasPayment([]);
+                tx.setExpiration(await this.getValidDuringExpiration());
+            }
+            else {
+                tx.setGasPayment(suiPlan.coins.map(c => ({ objectId: c.objectId, version: c.version, digest: c.digest })));
+                const suiTotal = suiPlan.coins.reduce((s, c) => s + BigInt(c.balance), 0n);
+                if (suiTotal > budget) {
+                    const [dep] = tx.splitCoins(tx.gas, [tx.pure.u64(suiTotal - budget)]);
+                    tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [SUI], arguments: [dep, tx.pure.address(addr)] });
+                }
             }
-            catch (e) {
-                (0, dist_1.log_warn)(`[executor] 读交易币种清单失败，本 tick 只维护 SUI: ${e.message}`);
+            for (const p of plan) {
+                if (!balanceGas && p.coinType === SUI)
+                    continue;
+                const primary = tx.object(transactions_1.Inputs.ObjectRef(p.coins[0]));
+                if (p.coins.length > 1)
+                    tx.mergeCoins(primary, p.coins.slice(1).map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
+                tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [p.coinType], arguments: [primary, tx.pure.address(addr)] });
             }
+            tx.setGasBudget(budget);
+            tx.setGasPrice(await this.getGasPrice());
+            const bytes = await tx.build();
+            const { signature } = await kp.signTransaction(bytes);
+            const resp = await this.core.executeTransaction({ transaction: bytes, signatures: [signature], include: { effects: true, objectTypes: true, balanceChanges: true } });
+            const st = resp.Transaction?.effects ? (0, effects_1.coreTxStatus)(resp.Transaction.effects) : { success: false, error: 'no effects' };
+            const syms = plan.map(p => `${p.coins.length}×${p.coinType.split('::').pop()}`).join(', ');
+            (0, dist_1.log_info)(`[executor] sweep 归集 → balance ${st.success ? 'OK' : 'FAIL'} [${syms}] digest=${resp.Transaction?.digest}${st.error ? ' err=' + st.error : ''}`);
         }
-        for (const t of [SUI, ...new Set(tradeTypes.filter(t => t !== SUI))]) {
-            if (t !== SUI)
-                await this.reconcileCoins(addr, t, true);
-            if (this.cache.hasInflight(addr, t))
-                continue;
-            let minSplitT;
-            try {
-                minSplitT = await this.minSplitFor(t);
-            }
-            catch (e) {
-                (0, dist_1.log_warn)(`[executor] 读 ${t} decimals 失败，本 tick 跳过该币种维护: ${e.message}`);
-                continue;
-            }
-            if (await this.maintainCoinObjects(addr, kp, t, { coinTarget, coinMax, budget, minSplit: minSplitT }))
-                return;
+        catch (e) {
+            (0, dist_1.log_error)(`[executor] sweep 归集失败`, e);
         }
-    }
-    async sweepObjectsToBalance(addr, kp, coinType, budget) {
-        const coins = this.cache.snapshot(addr, coinType).coins;
-        if (coins.length === 0)
-            return false;
-        const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
-        const tag = this.nextTag('sweep');
-        if (!this.cache.reserve(addr, coinType, coins.map(c => c.objectId), tag))
-            return false;
-        const tx = new transactions_1.Transaction();
-        tx.setSender(addr);
-        let suiAb = 0n;
-        try {
-            const sb = await this.core.getBalance({ owner: addr, coinType: '0x2::sui::SUI' });
-            suiAb = BigInt(sb.balance.addressBalance ?? '0');
-        }
-        catch { }
-        if (coinType === SUI && suiAb < budget) {
-            const total = coins.reduce((s, c) => s + BigInt(c.balance), 0n);
-            if (total <= budget) {
-                this.cache.abort(tag, false);
-                return false;
+        finally {
+            for (const p of plan) {
+                this.cache.abort(p.tag, true);
+                await this.reconcileCoins(addr, p.coinType);
             }
-            tx.setGasPayment(coins.map(c => ({ objectId: c.objectId, version: c.version, digest: c.digest })));
-            const [dep] = tx.splitCoins(tx.gas, [tx.pure.u64(total - budget)]);
-            tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [SUI], arguments: [dep, tx.pure.address(addr)] });
-        }
-        else {
-            const primary = tx.object(transactions_1.Inputs.ObjectRef(coins[0]));
-            if (coins.length > 1)
-                tx.mergeCoins(primary, coins.slice(1).map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
-            tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [coinType], arguments: [primary, tx.pure.address(addr)] });
-            tx.setGasPayment([]);
-            tx.setExpiration(await this.getValidDuringExpiration());
-        }
-        await this.execMaintenance(tx, addr, kp, budget, `归集 ${coins.length} 个 ${coinType.split('::').pop()} 对象 → balance`, undefined, coinType, tag);
-        return true;
-    }
-    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);
@@ -324,73 +282,6 @@ class CentralExecutor {
         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);
-        const coins = this.cache.snapshot(addr, coinType).coins;
-        const valued = coins.filter(c => BigInt(c.balance) > 0n);
-        const zeros = coins.filter(c => BigInt(c.balance) === 0n);
-        if (coins.length === 0)
-            return false;
-        const total = valued.reduce((s, c) => s + BigInt(c.balance), 0n);
-        const maxPieces = opts.minSplit > 0n ? total / opts.minSplit : 0n;
-        const pieces = Math.max(1, Number(maxPieces > BigInt(opts.coinTarget) ? BigInt(opts.coinTarget) : maxPieces));
-        const needSplit = valued.length > 0 && valued.length < opts.coinTarget && pieces > valued.length;
-        const needZeroPurge = zeros.length >= zeroMergeMin;
-        const needDefrag = coins.length > opts.coinMax;
-        if (!needSplit && !needZeroPurge && !needDefrag)
-            return false;
-        const tag = this.nextTag('maint');
-        if (!this.cache.reserve(addr, coinType, coins.map(c => c.objectId), tag))
-            return false;
-        const primaryRef = valued[0] ?? coins[0];
-        const tx = new transactions_1.Transaction();
-        tx.setSender(addr);
-        const primary = tx.object(transactions_1.Inputs.ObjectRef(primaryRef));
-        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 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, { 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, commitPlan) {
-        let committed = false;
-        try {
-            tx.setGasBudget(budget);
-            tx.setGasPrice(await this.getGasPrice());
-            const bytes = buildClient ? await tx.build({ client: buildClient }) : await tx.build();
-            const { signature } = await kp.signTransaction(bytes);
-            const resp = await this.core.executeTransaction({ transaction: bytes, signatures: [signature], include: { effects: true, objectTypes: true, balanceChanges: true } });
-            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 (!committed) {
-                if (reserveTag)
-                    this.cache.abort(reserveTag, true);
-                await this.reconcileCoins(addr, coinType);
-            }
-        }
-    }
     async getPoolGenerics(poolId) {
         const hit = this.poolGenericsCache.get(poolId);
         if (hit !== undefined)
@@ -442,25 +333,39 @@ class CentralExecutor {
         }
         return isv;
     }
-    async getValidDuringExpiration() {
-        if (!this.chainIdentifier) {
-            try {
-                this.chainIdentifier = (await this.core.getChainIdentifier()).chainIdentifier;
-            }
-            catch (e) {
-                this.chainIdentifier = process.env.SUI_CHAIN_IDENTIFIER || '35834a8a';
-                (0, dist_1.log_warn)(`[executor] getChainIdentifier 失败（${e.message}），使用兜底 chain id ${this.chainIdentifier}`);
-            }
-        }
+    async cachedChainId() {
+        if (this.chainIdentifier)
+            return this.chainIdentifier;
+        if (!this.chainIdInflight) {
+            this.chainIdInflight = this.core.getChainIdentifier().then(r => r.chainIdentifier)
+                .catch(e => {
+                const fb = process.env.SUI_CHAIN_IDENTIFIER || '35834a8a';
+                (0, dist_1.log_warn)(`[executor] getChainIdentifier 失败（${e.message}），使用兜底 chain id ${fb}`);
+                return fb;
+            })
+                .then(id => { this.chainIdentifier = id; return id; })
+                .finally(() => { this.chainIdInflight = undefined; });
+        }
+        return this.chainIdInflight;
+    }
+    async cachedEpoch() {
         const now = Date.now();
-        if (!this.epochCache || now - this.epochCache.ts > 300_000) {
-            this.epochCache = { epoch: await this.fetchEpoch(), ts: now };
+        if (this.epochCache && now - this.epochCache.ts <= 3_600_000)
+            return this.epochCache.epoch;
+        if (!this.epochInflight) {
+            this.epochInflight = this.fetchEpoch()
+                .then(e => { this.epochCache = { epoch: e, ts: Date.now() }; return e; })
+                .finally(() => { this.epochInflight = undefined; });
         }
+        return this.epochInflight;
+    }
+    async getValidDuringExpiration() {
+        const [chain, epoch] = await Promise.all([this.cachedChainId(), this.cachedEpoch()]);
         return { ValidDuring: {
-                minEpoch: String(this.epochCache.epoch),
-                maxEpoch: String(this.epochCache.epoch + 1n),
+                minEpoch: String(epoch),
+                maxEpoch: String(epoch + 1n),
                 minTimestamp: null, maxTimestamp: null,
-                chain: this.chainIdentifier,
+                chain,
                 nonce: Math.floor(Math.random() * 0xFFFFFFFF),
             } };
     }
@@ -483,31 +388,9 @@ class CentralExecutor {
             throw new Error('[executor] getCurrentSystemState 未返回 epoch（ValidDuring 必需）');
         return BigInt(e);
     }
-    fundModeFor(_coinType) {
-        return (process.env.SUI_FUND_MODE || 'balance').toLowerCase() === 'object' ? 'object' : 'balance';
-    }
     nextTag(prefix) { return `${prefix}:${Date.now()}:${++this.seq}`; }
     inputCoinType(req) { return req.a2b ? req.coinTypeA : req.coinTypeB; }
     outputCoinType(req) { return req.a2b ? req.coinTypeB : req.coinTypeA; }
-    chooseTradeWallet(req, coinType, amount) {
-        if (req.walletAddress) {
-            if (!this.tradeWallets.has(req.walletAddress))
-                throw new Error(`未知交易钱包: ${req.walletAddress}`);
-            return req.walletAddress;
-        }
-        let best = '';
-        let bestTotal = -1n;
-        for (const w of this.tradeWallets.keys()) {
-            const { total } = this.cache.snapshot(w, coinType);
-            if (total >= amount && total > bestTotal) {
-                best = w;
-                bestTotal = total;
-            }
-        }
-        if (!best)
-            throw new Error(`无交易钱包持有 ≥ ${amount} 的 ${coinType}`);
-        return best;
-    }
     async registerShared(tx, objectId, mutable) {
         const initialSharedVersion = await this.getSharedRefCached(objectId);
         tx.object(transactions_1.Inputs.SharedObjectRef({ objectId, initialSharedVersion, mutable }));
@@ -517,57 +400,7 @@ class CentralExecutor {
         req = await this.canonicalizeReq(req);
         const inType = this.inputCoinType(req);
         await this.getCoinDecimalsCached(inType).catch(() => { });
-        if (this.fundModeFor(inType) === 'balance')
-            return this.submitSwapBalance(req, t0);
-        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] ${this.pairLabel(req)} 对象不足：需 ${this.fmtAmount(inType, req.amountIn)}，当前缓存 [${this.walletBalancesLabel(inType)}] → reconcile 重试`);
-            await Promise.all([...this.tradeWallets.keys()].map(w => this.reconcileCoins(w, inType)));
-            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 tAcquire = Date.now();
-        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.buildSwapTxObject(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, 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) {
-            this.cache.abort(inputTag, false);
-            (0, dist_1.log_error)(`[executor] submitSwap 失败 dex=${req.dexId}`, e);
-            return { digest: '', submitted: false, error: e.message };
-        }
+        return this.submitSwapBalance(req, t0);
     }
     async submitSwapBalance(req, t0) {
         const inType = this.inputCoinType(req);
@@ -613,12 +446,12 @@ class CentralExecutor {
                 this.onBroadcastResult?.({ digest, success: false, error, receipt: this.toCheckerReceipt(tr, digest) });
                 return;
             }
-            if (inputTag)
-                this.cache.abort(inputTag, true);
             (0, dist_1.log_info)(`[executor] swap quorum-executed 确认(balance) digest=${digest} broadcast=${Date.now() - tBroadcast}ms`);
             this.onBroadcastResult?.({ digest, success: true, receipt: this.toCheckerReceipt(tr, digest) });
-            if (this.reconcileAfterTx)
-                void this.postTradeRebalance(wallet, inType, outType);
+            if (inputTag) {
+                this.cache.abort(inputTag, true);
+                void this.reconcileCoins(wallet, inType);
+            }
         }
         catch (e) {
             if (!inputTag && this.isInsufficientBalanceError(e) && attempt < this.maxRebuildRetries) {
@@ -663,71 +496,6 @@ class CentralExecutor {
             return null;
         }
     }
-    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();
-        try {
-            const resp = await this.core.executeTransaction({ transaction: txBytes, signatures, include: { effects: true, objectTypes: true, balanceChanges: true } });
-            const tr = resp.Transaction;
-            if (!tr?.effects) {
-                this.cache.abort(inputTag, true);
-                this.reconcileAfterFailure(wallet, inType, outType);
-                (0, dist_1.log_error)(`[executor] 响应缺 effects，无法更新 cache digest=${digest}`, new Error('missing effects'));
-                this.onBroadcastResult?.({ digest, success: false, error: 'missing effects' });
-                return;
-            }
-            const { success, error } = (0, effects_1.coreTxStatus)(tr.effects);
-            if (!success) {
-                this.cache.abort(inputTag, true);
-                this.reconcileAfterFailure(wallet, inType, outType);
-                (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, 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 (!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);
-                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 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.buildSwapTxObject(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) {
         const eff = tr.effects;
         const status = eff?.status?.success
@@ -752,73 +520,16 @@ class CentralExecutor {
             },
         };
     }
-    reconcileAfterFailure(wallet, inType, outType) {
-        for (const t of new Set([inType, outType, constants_1.SUI_TOKEN_ADDRESS.LONG]))
-            void this.reconcileCoins(wallet, t);
-    }
     async simulateSwap(req) {
         req = await this.canonicalizeReq(req);
-        const inType = this.inputCoinType(req);
-        const balanceMode = this.fundModeFor() === 'balance';
-        const wallet = req.walletAddress ?? (balanceMode ? this.tradeWalletAddresses[0] : this.chooseTradeWallet(req, inType, req.amountIn));
-        let txBytes;
-        if (balanceMode) {
-            ({ txBytes } = await this.buildSwapTxBalance(req, wallet));
-        }
-        else {
-            const { coins } = this.cache.snapshot(wallet, inType);
-            if (!coins.length)
-                throw new Error(`[executor] simulate 无 ${inType} 输入币（先 reconcileCoins）`);
-            const picked = [];
-            let sum = 0n;
-            for (const c of coins) {
-                picked.push(c);
-                sum += BigInt(c.balance);
-                if (sum >= req.amountIn)
-                    break;
-            }
-            if (sum < req.amountIn)
-                throw new Error(`[executor] simulate 输入不足 ${sum} < ${req.amountIn}`);
-            ({ txBytes } = await this.buildSwapTxObject(req, wallet, picked));
-        }
+        const wallet = req.walletAddress ?? this.tradeWalletAddresses[0];
+        const { txBytes } = await this.buildSwapTxBalance(req, wallet);
         const res = await this.core.simulateTransaction({ transaction: txBytes, include: { effects: true, objectTypes: true, balanceChanges: true } });
         if (!res?.Transaction) {
             throw new Error(`[executor] simulate FailedTransaction: ${JSON.stringify(res?.FailedTransaction ?? res).slice(0, 400)}`);
         }
         return res.Transaction;
     }
-    async minSplitFor(coinType) {
-        if (coinType === constants_1.SUI_TOKEN_ADDRESS.LONG) {
-            return (0, format_1.suiToMist)(process.env.SUI_INPUT_COIN_MIN_SPLIT, '0.1');
-        }
-        const d = await this.getCoinDecimalsCached(coinType);
-        return 10n ** BigInt(d) / 10n;
-    }
-    async postTradeRebalance(wallet, inType, outType) {
-        const kp = this.tradeWallets.get(wallet);
-        if (!kp)
-            return;
-        const coinTarget = Number(process.env.SUI_INPUT_COIN_TARGET || 3);
-        const coinMax = Number(process.env.SUI_INPUT_COIN_MAX || 5);
-        const budget = this.gasBudget;
-        for (const t of new Set([inType, outType, constants_1.SUI_TOKEN_ADDRESS.LONG])) {
-            try {
-                await this.reconcileCoins(wallet, t);
-                if (this.cache.hasInflight(wallet, t))
-                    continue;
-                if (this.fundModeFor(t) === 'balance') {
-                    if (this.cache.snapshot(wallet, t).coins.length > 0)
-                        await this.sweepObjectsToBalance(wallet, kp, t, budget);
-                }
-                else {
-                    await this.maintainCoinObjects(wallet, kp, t, { coinTarget, coinMax, budget, minSplit: await this.minSplitFor(t) });
-                }
-            }
-            catch (e) {
-                (0, dist_1.log_warn)(`[executor] postTradeRebalance ${t} 失败（交定时 tick 兜底）: ${e.message}`);
-            }
-        }
-    }
     async swapTxShell(req, wallet) {
         const tx = new transactions_1.Transaction();
         tx.setSender(wallet);
@@ -835,33 +546,6 @@ class CentralExecutor {
         const txBytes = online ? await tx.build({ client: this.core.rawClient }) : await tx.build();
         return { txBytes, tx };
     }
-    async buildSwapTxObject(req, wallet, inputCoins, shortfall = 0n) {
-        const tx = await this.swapTxShell(req, wallet);
-        const inType = this.inputCoinType(req);
-        let inCoin;
-        let usedResolver = false;
-        if (inputCoins.length === 0) {
-            inCoin = (0, transactions_1.coinWithBalance)({ type: inType, balance: req.amountIn });
-            usedResolver = true;
-        }
-        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 })]);
-                usedResolver = true;
-            }
-            ;
-            [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, amountLimit: req.minOut, sqrtPriceLimit: req.sqrtPriceLimit,
-        }, inCoin);
-        tx.transferObjects([outputCoin, ...leftoverCoins], tx.pure.address(wallet));
-        return this.finishSwapTx(tx, usedResolver);
-    }
     async buildSwapTxBalance(req, wallet, objectCoins = [], shortfall = 0n) {
         const tx = await this.swapTxShell(req, wallet);
         const inType = this.inputCoinType(req);
@@ -893,27 +577,6 @@ class CentralExecutor {
             tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [inType], arguments: [lo, tx.pure.address(wallet)] });
         return this.finishSwapTx(tx, false);
     }
-    async onSuccess(tr, wallet, req, inputCoins, inputTag, usedAddressBalance = false) {
-        const inType = this.inputCoinType(req);
-        const outType = this.outputCoinType(req);
-        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);
-        }
-    }
     get coinCache() { return this.cache; }
     get tradeWalletAddresses() { return [...this.tradeWallets.keys()]; }
     get coreClient() { return this.core; }

package/dist/trade/executor/coin_maintainer.js

@@ -8,7 +8,7 @@ class CoinMaintainer {
         this.executor = executor;
         this.timer = null;
         this.running = false;
-        this.intervalMs = opts.intervalMs ?? (0, format_1.parseDurationMs)(process.env.SUI_COIN_MAINTAIN_INTERVAL_MS, 60000);
+        this.intervalMs = opts.intervalMs ?? (0, format_1.parseDurationMs)(process.env.SUI_COIN_MAINTAIN_INTERVAL_MS, 300000);
     }
     start() {
         if (this.timer)

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

@@ -1,5 +1,5 @@
 import { CoreClient, SuiClientTypes } from '@mysten/sui/client';
-export declare function fetchCurrentEpochViaGraphql(url: string): Promise<bigint>;
+export declare function fetchCurrentEpochViaGraphql(url: string, retries?: number): Promise<bigint>;
 export interface GrpcCoreOptions {
     endpoint?: string;
     token?: string;

package/dist/trade/executor/core_channel.js

@@ -26,13 +26,29 @@ const GRPC_CLIENT_OPTIONS = {
     'grpc-node.max_session_memory': 64,
     'grpc.default_compression_algorithm': 2,
 };
-async function fetchCurrentEpochViaGraphql(url) {
-    const client = new graphql_1.SuiGraphQLClient({ url, network: 'mainnet' });
-    const res = await client.query({ query: 'query { epoch { epochId } }', variables: {} });
-    const e = res?.data?.epoch?.epochId;
-    if (e == null)
-        throw new Error(`GraphQL epoch 查询无结果: ${JSON.stringify(res?.errors ?? res).slice(0, 200)}`);
-    return BigInt(e);
+const _gqlEpochClients = new Map();
+async function fetchCurrentEpochViaGraphql(url, retries = 2) {
+    let client = _gqlEpochClients.get(url);
+    if (!client) {
+        client = new graphql_1.SuiGraphQLClient({ url, network: 'mainnet' });
+        _gqlEpochClients.set(url, client);
+    }
+    let lastErr;
+    for (let i = 0; i <= retries; i++) {
+        try {
+            const res = await client.query({ query: 'query { epoch { epochId } }', variables: {} });
+            const e = res?.data?.epoch?.epochId;
+            if (e == null)
+                throw new Error(`GraphQL epoch 查询无结果: ${JSON.stringify(res?.errors ?? res).slice(0, 200)}`);
+            return BigInt(e);
+        }
+        catch (e) {
+            lastErr = e;
+            if (i < retries)
+                await (0, dist_1.sleep)(150 * (i + 1));
+        }
+    }
+    throw lastErr;
 }
 function buildGrpcCore(opts = {}) {
     const endpoint = opts.endpoint ?? (0, dist_1.getCoreEnv)().grpc_endpoint;

package/package.json

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