@clonegod/ttd-sui-common 2.0.13 → 2.0.15

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

@@ -0,0 +1,21 @@
+import { DEX_ID } from '@clonegod/ttd-core/dist';
+import { ExecutorCore } from './core_channel';
+export type BalanceProbeMode = 'info' | 'offline' | 'sim' | 'sim-token' | 'concurrency' | 'offline-native' | 'sim-native' | 'swap';
+export interface BalanceProbeOptions {
+    mode: BalanceProbeMode;
+    walletGroupIds: string[];
+    walletAddress?: string;
+    coinType?: string;
+    amount: bigint;
+    gasBudget: bigint;
+    n: number;
+    live: boolean;
+    chainIdentifierFallback?: string;
+    dexId?: DEX_ID;
+    poolId?: string;
+    a2b?: boolean;
+    amountIn?: bigint;
+    depositFirst?: boolean;
+    depositOutput?: boolean;
+}
+export declare function runBalanceProbe(core: ExecutorCore, opts: BalanceProbeOptions): Promise<void>;

package/dist/trade/executor/balance_probe.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBalanceProbe = runBalanceProbe;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const ed25519_1 = require("@mysten/sui/keypairs/ed25519");
+const transactions_1 = require("@mysten/sui/transactions");
+const constants_1 = require("../../constants");
+const swap_1 = require("../swap");
+const core_channel_1 = require("./core_channel");
+const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
+async function validDuring(core, fallback = '35834a8a') {
+    let chain;
+    try {
+        chain = (await core.getChainIdentifier()).chainIdentifier;
+    }
+    catch {
+        chain = fallback;
+    }
+    let e;
+    const url = process.env.SUI_GRAPHQL_URL;
+    if (url) {
+        try {
+            e = await (0, core_channel_1.fetchCurrentEpochViaGraphql)(url);
+        }
+        catch {
+            const s = await core.getCurrentSystemState();
+            e = BigInt(s?.systemState?.epoch ?? s?.epoch);
+        }
+    }
+    else {
+        const s = await core.getCurrentSystemState();
+        e = BigInt(s?.systemState?.epoch ?? s?.epoch);
+    }
+    return { ValidDuring: {
+            minEpoch: String(e), maxEpoch: String(e + 1n),
+            minTimestamp: null, maxTimestamp: null, chain,
+            nonce: Math.floor(Math.random() * 0xFFFFFFFF),
+        } };
+}
+function buildRoundTrip(wallet, coinType, amount, exp, gasBudget, gasPrice) {
+    const tx = new transactions_1.Transaction();
+    tx.setSender(wallet);
+    const c = (0, transactions_1.coinWithBalance)({ type: coinType, balance: amount, useGasCoin: false });
+    tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [coinType], arguments: [c, tx.pure.address(wallet)] });
+    tx.setGasPayment([]);
+    tx.setExpiration(exp);
+    tx.setGasBudget(gasBudget);
+    tx.setGasPrice(gasPrice);
+    return tx;
+}
+function buildRoundTripNative(wallet, coinType, amount, exp, gasBudget, gasPrice) {
+    const tx = new transactions_1.Transaction();
+    tx.setSender(wallet);
+    const wd = tx.withdrawal({ amount, type: coinType });
+    const [coin] = tx.moveCall({ target: '0x2::coin::redeem_funds', typeArguments: [coinType], arguments: [wd] });
+    tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [coinType], arguments: [coin, tx.pure.address(wallet)] });
+    tx.setGasPayment([]);
+    tx.setExpiration(exp);
+    tx.setGasBudget(gasBudget);
+    tx.setGasPrice(gasPrice);
+    return tx;
+}
+function splitTopLevelGenerics(s) {
+    const out = [];
+    let depth = 0, cur = '';
+    for (const ch of s) {
+        if (ch === '<')
+            depth++;
+        else if (ch === '>')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            out.push(cur.trim());
+            cur = '';
+        }
+        else
+            cur += ch;
+    }
+    if (cur.trim())
+        out.push(cur.trim());
+    return out;
+}
+async function readPoolGenerics(core, poolId) {
+    const res = await core.getObjects({ objectIds: [poolId] });
+    const obj = res.objects[0];
+    if (obj instanceof Error)
+        throw new Error(`getObjects(${poolId}) 失败: ${obj.message}`);
+    const t = obj.type ?? obj.objectType;
+    const m = t?.match(/<(.+)>$/);
+    if (!m)
+        throw new Error(`pool ${poolId} 非双泛型对象，type=${t}`);
+    const parts = splitTopLevelGenerics(m[1]);
+    if (parts.length !== 2)
+        throw new Error(`pool ${poolId} 泛型数 ${parts.length}≠2`);
+    return { typeA: parts[0], typeB: parts[1] };
+}
+async function registerShared(core, tx, objectId, mutable) {
+    const res = await core.getObjects({ objectIds: [objectId] });
+    const obj = res.objects[0];
+    if (obj instanceof Error)
+        throw new Error(`getObjects(${objectId}) 失败: ${obj.message}`);
+    const owner = obj.owner;
+    if (owner?.$kind !== 'Shared')
+        throw new Error(`${objectId} 非共享对象（$kind=${owner?.$kind}）`);
+    tx.object(transactions_1.Inputs.SharedObjectRef({ objectId, initialSharedVersion: owner.Shared.initialSharedVersion, mutable }));
+}
+function pickWallet(opts) {
+    const infos = (0, dist_1.load_wallet_multi)(opts.walletGroupIds, false);
+    for (const info of infos) {
+        const kp = ed25519_1.Ed25519Keypair.fromSecretKey(info.private_key);
+        const address = kp.getPublicKey().toSuiAddress();
+        if (!opts.walletAddress || address.toLowerCase() === opts.walletAddress.toLowerCase())
+            return { address, kp };
+    }
+    throw new Error(`未找到钱包 ${opts.walletAddress || '(第一个)'}`);
+}
+async function runBalanceProbe(core, opts) {
+    const { mode, amount, gasBudget } = opts;
+    const rawClient = core.rawClient;
+    const { address: wallet, kp } = pickWallet(opts);
+    (0, dist_1.log_info)(`[probe] mode=${mode} wallet=${wallet} amount=${amount} budget=${gasBudget}`);
+    if (mode === 'info') {
+        const b = await core.getBalance({ owner: wallet, coinType: '0x2::sui::SUI' });
+        const ab = BigInt(b.balance.addressBalance ?? '0');
+        const total = BigInt(b.balance.balance ?? '0');
+        let n = 0;
+        let cursor = undefined;
+        do {
+            const p = await core.listCoins({ owner: wallet, coinType: SUI, cursor });
+            n += p.objects.length;
+            cursor = p.hasNextPage ? p.cursor : null;
+        } while (cursor);
+        (0, dist_1.log_info)(`[probe][info] SUI 总额=${total} 其中 address-balance=${ab} 对象部分=${total - ab}（${n} 个 Coin 对象）`);
+        return;
+    }
+    const exp = await validDuring(core, opts.chainIdentifierFallback);
+    const gasPrice = BigInt((await core.getReferenceGasPrice()).referenceGasPrice);
+    if (mode === 'offline') {
+        const tx = buildRoundTrip(wallet, SUI, amount, exp, gasBudget, gasPrice);
+        try {
+            const bytes = await tx.build();
+            (0, dist_1.log_info)(`[probe][offline] ✅ 离线 build 成功（${bytes.length} bytes）—— balance-withdraw 不需 client resolver，全 balance 不损失离线优势`);
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[probe][offline] ❌ 离线 build 失败：${e.message}`);
+            (0, dist_1.log_warn)(`[probe][offline] → coinWithBalance resolver 需在线；全 balance 方案需手工拼 withdraw 命令才能保留离线 build`);
+        }
+        return;
+    }
+    if (mode === 'sim' || mode === 'sim-token') {
+        const coinType = mode === 'sim-token' ? (opts.coinType || '') : SUI;
+        if (!coinType)
+            throw new Error('sim-token 模式需指定 coinType');
+        const tag = mode === 'sim-token'
+            ? `${coinType.split('::').pop()} 输入(gas 仍走 SUI balance)`
+            : 'SUI 输入 + gas 同笔共用 SUI balance【CRUX】';
+        const tx = buildRoundTrip(wallet, coinType, amount, exp, gasBudget, gasPrice);
+        const bytes = await tx.build({ client: rawClient });
+        const res = await core.simulateTransaction({ transaction: bytes, include: { effects: true, objectTypes: true, balanceChanges: true } });
+        if (!res?.Transaction) {
+            (0, dist_1.log_error)(`[probe][${mode}] ❌ 链拒绝（${tag}）：${JSON.stringify(res?.FailedTransaction ?? res).slice(0, 500)}`, new Error('rejected'));
+            (0, dist_1.log_warn)(`[probe][${mode}] → 印证假设：该组合违规，SUI 池需引入独立 gas 钱包（gas 钱包付 gas，交易钱包 balance 出 SUI 输入）`);
+            return;
+        }
+        const ok = res.Transaction.effects?.status?.success;
+        const err = res.Transaction.effects?.status?.error;
+        (0, dist_1.log_info)(`[probe][${mode}] ${ok ? '✅ 链接受' : '❌ 执行失败'}（${tag}）success=${ok}${err ? ' err=' + JSON.stringify(err) : ''} digest=${res.Transaction.digest}`);
+        if (ok && mode === 'sim')
+            (0, dist_1.log_info)(`[probe][sim] → SUI 单钱包可同笔 gas+swap 共用 address-balance，无需独立 gas 钱包`);
+        return;
+    }
+    if (mode === 'offline-native') {
+        const tx = buildRoundTripNative(wallet, SUI, amount, exp, gasBudget, gasPrice);
+        try {
+            const bytes = await tx.build();
+            (0, dist_1.log_info)(`[probe][offline-native] ✅ 离线 build 成功（${bytes.length} bytes）—— tx.withdrawal() 原生输入无需 client，全 balance 可保留离线 build`);
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[probe][offline-native] ❌ 仍需 client：${e.message}`);
+        }
+        return;
+    }
+    if (mode === 'sim-native') {
+        const tx = buildRoundTripNative(wallet, SUI, amount, exp, gasBudget, gasPrice);
+        let bytes;
+        let builtOffline = true;
+        try {
+            bytes = await tx.build();
+        }
+        catch {
+            builtOffline = false;
+            bytes = await tx.build({ client: rawClient });
+        }
+        const res = await core.simulateTransaction({ transaction: bytes, include: { effects: true, objectTypes: true, balanceChanges: true } });
+        if (!res?.Transaction) {
+            (0, dist_1.log_error)(`[probe][sim-native] ❌ 链拒绝：${JSON.stringify(res?.FailedTransaction ?? res).slice(0, 500)}`, new Error('rejected'));
+            return;
+        }
+        const ok = res.Transaction.effects?.status?.success;
+        const err = res.Transaction.effects?.status?.error;
+        (0, dist_1.log_info)(`[probe][sim-native] ${ok ? '✅ 链接受' : '❌ 执行失败'}（原生 withdrawal+coin::redeem_funds，离线build=${builtOffline}）success=${ok}${err ? ' err=' + JSON.stringify(err) : ''}`);
+        if (ok && builtOffline)
+            (0, dist_1.log_info)(`[probe][sim-native] → 全 balance + 离线 build 双成立：手工拼 withdraw 命令可取代 coinWithBalance`);
+        return;
+    }
+    if (mode === 'swap') {
+        if (!opts.dexId || !opts.poolId)
+            throw new Error('swap 模式需 dexId + poolId');
+        const a2b = opts.a2b ?? true;
+        const amountIn = opts.amountIn ?? amount;
+        const { typeA, typeB } = await readPoolGenerics(core, opts.poolId);
+        const inType = a2b ? typeA : typeB;
+        const outType = a2b ? typeB : typeA;
+        const sym = (t) => t.split('::').pop();
+        (0, dist_1.log_info)(`[probe][swap] dex=${opts.dexId} pool=${opts.poolId.slice(0, 12)}… ${sym(inType)}→${sym(outType)} in=${amountIn}`);
+        const b = await core.getBalance({ owner: wallet, coinType: inType });
+        const ab = BigInt(b.balance.addressBalance ?? '0');
+        if (ab < amountIn) {
+            if (!(opts.depositFirst && kp)) {
+                (0, dist_1.log_warn)(`[probe][swap] ${sym(inType)} address-balance=${ab} < 需 ${amountIn} —— 非 SUI 币种须先充值到 balance 才能测；加 SUI_PROBE_LIVE=true SUI_PROBE_DEPOSIT_FIRST=true 自动从对象币充值，或手动 coin::send_funds`);
+                return;
+            }
+            const need = amountIn - ab + 1n;
+            let cursor = undefined;
+            let src = null;
+            do {
+                const p = await core.listCoins({ owner: wallet, coinType: inType, cursor });
+                src = p.objects.find((c) => BigInt(c.balance) >= need) || src;
+                cursor = p.hasNextPage ? p.cursor : null;
+            } while (cursor && !src);
+            if (!src) {
+                (0, dist_1.log_warn)(`[probe][swap] 无足额 ${sym(inType)} 对象币可充值（需 ${need}）`);
+                return;
+            }
+            const dtx = new transactions_1.Transaction();
+            dtx.setSender(wallet);
+            const [dep] = dtx.splitCoins(dtx.object(transactions_1.Inputs.ObjectRef({ objectId: src.objectId, version: src.version, digest: src.digest })), [dtx.pure.u64(need)]);
+            dtx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [inType], arguments: [dep, dtx.pure.address(wallet)] });
+            dtx.setGasPayment([]);
+            dtx.setExpiration(exp);
+            dtx.setGasBudget(gasBudget);
+            dtx.setGasPrice(gasPrice);
+            const dbytes = await dtx.build({ client: rawClient });
+            const { signature } = await kp.signTransaction(dbytes);
+            const dres = await core.executeTransaction({ transaction: dbytes, signatures: [signature], include: { effects: true, objectTypes: true, balanceChanges: true } });
+            (0, dist_1.log_info)(`[probe][swap] 充值 ${need} ${sym(inType)} → balance：${dres.Transaction?.effects?.status?.success ? 'OK' : 'FAIL ' + JSON.stringify(dres.Transaction?.effects?.status?.error)} digest=${dres.Transaction?.digest}`);
+            if (!dres.Transaction?.effects?.status?.success)
+                return;
+        }
+        const tx = new transactions_1.Transaction();
+        tx.setSender(wallet);
+        await registerShared(core, tx, opts.poolId, true);
+        await registerShared(core, tx, (0, swap_1.configSharedObjectId)(opts.dexId), true);
+        tx.object(transactions_1.Inputs.SharedObjectRef({ objectId: swap_1.SUI_CLOCK_ID, initialSharedVersion: '1', mutable: false }));
+        const wd = tx.withdrawal({ amount: amountIn, type: inType });
+        const [inCoin] = tx.moveCall({ target: '0x2::coin::redeem_funds', typeArguments: [inType], arguments: [wd] });
+        const { outputCoin, leftoverCoins } = (0, swap_1.buildSwapMoveCall)(opts.dexId, tx, {
+            coinTypeA: typeA, coinTypeB: typeB, poolId: opts.poolId,
+            a2b, byAmountIn: true, amount: amountIn, amountLimit: 0n, sqrtPriceLimit: 0n,
+        }, inCoin);
+        if (opts.depositOutput) {
+            tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [outType], arguments: [outputCoin, tx.pure.address(wallet)] });
+            for (const lo of leftoverCoins)
+                tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [inType], arguments: [lo, tx.pure.address(wallet)] });
+        }
+        else {
+            tx.transferObjects([outputCoin, ...leftoverCoins], tx.pure.address(wallet));
+        }
+        tx.setGasPayment([]);
+        tx.setExpiration(exp);
+        tx.setGasBudget(gasBudget);
+        tx.setGasPrice(gasPrice);
+        let builtOffline = true;
+        let bytes;
+        try {
+            bytes = await tx.build();
+        }
+        catch {
+            builtOffline = false;
+            bytes = await tx.build({ client: rawClient });
+        }
+        const res = await core.simulateTransaction({ transaction: bytes, include: { effects: true, objectTypes: true, balanceChanges: true } });
+        if (!res?.Transaction) {
+            (0, dist_1.log_error)(`[probe][swap] ❌ 链拒绝（${opts.dexId} ${sym(inType)}→${sym(outType)}，balance 输入）：${JSON.stringify(res?.FailedTransaction ?? res).slice(0, 500)}`, new Error('rejected'));
+            return;
+        }
+        const ok = res.Transaction.effects?.status?.success;
+        const err = res.Transaction.effects?.status?.error;
+        const out = (res.Transaction.balanceChanges || []).find((c) => c.coinType?.includes(sym(outType)) && c.address === wallet);
+        (0, dist_1.log_info)(`[probe][swap] ${ok ? '✅ DEX 接受 balance 来源输入' : '❌ 执行失败'}（${opts.dexId} ${sym(inType)}→${sym(outType)}，离线build=${builtOffline}）success=${ok} out≈${out?.amount ?? '?'}${err ? ' err=' + JSON.stringify(err) : ''}`);
+        return;
+    }
+    if (mode === 'concurrency') {
+        if (!opts.live)
+            throw new Error('concurrency 模式会真发交易花 gas，须显式开 live');
+        if (!kp)
+            throw new Error('concurrency 需私钥（load_wallet_multi 未拿到）');
+        const n = opts.n;
+        (0, dist_1.log_warn)(`[probe][concurrency] ⚠️ 即将真发 ${n} 笔并发交易（各提 ${amount} MIST SUI→存回，gas 走同一 SUI balance），花真 gas`);
+        const tasks = Array.from({ length: n }, async (_, i) => {
+            const t0 = Date.now();
+            try {
+                const tx = buildRoundTrip(wallet, SUI, amount, await validDuring(core, opts.chainIdentifierFallback), gasBudget, gasPrice);
+                const bytes = await tx.build({ client: rawClient });
+                const { signature } = await kp.signTransaction(bytes);
+                const digest = await tx.getDigest();
+                const resp = await core.executeTransaction({ transaction: bytes, signatures: [signature], include: { effects: true, objectTypes: true, balanceChanges: true } });
+                const ok = resp.Transaction?.effects?.status?.success;
+                const err = resp.Transaction?.effects?.status?.error;
+                return { i, ok, digest, err, ms: Date.now() - t0 };
+            }
+            catch (e) {
+                return { i, ok: false, digest: '-', err: e.message, ms: Date.now() - t0 };
+            }
+        });
+        const results = await Promise.all(tasks);
+        const succ = results.filter(r => r.ok).length;
+        results.forEach(r => (0, dist_1.log_info)(`[probe][concurrency] #${r.i} ${r.ok ? 'OK' : 'FAIL'} ${r.ms}ms digest=${r.digest}${r.err ? ' err=' + JSON.stringify(r.err).slice(0, 200) : ''}`));
+        (0, dist_1.log_info)(`[probe][concurrency] 结果：${succ}/${n} 成功 —— 同一 SUI address-balance 同时支撑 ${succ} 笔并发提现+gas`);
+        if (succ < n)
+            (0, dist_1.log_warn)(`[probe][concurrency] 有失败：address-balance 同源并发提现存在上限/排序约束，需据失败原因判断是结算上限还是 epoch 级限制`);
+        return;
+    }
+    throw new Error(`未知 probe mode=${mode}`);
+}

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;
@@ -66,40 +64,41 @@ export declare class CentralExecutor {
     reconcileCoins(wallet: string, coinType: string, quietIfUnchanged?: boolean): Promise<void>;
     rebalanceWalletFunds(): Promise<void>;
     private rebalanceOne;
-    private selectWalletWithBalance;
+    private rebalanceBalanceMode;
+    private sweepObjectsToBalance;
     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 nextTag;
     private inputCoinType;
     private outputCoinType;
-    private chooseTradeWallet;
     private registerShared;
     submitSwap(req: SwapExecRequest): Promise<SwapSubmitResult>;
-    private broadcastAndCommit;
-    private isRebuildableObjectError;
-    private rebuildSwap;
+    private submitSwapBalance;
+    private broadcastBalanceAndCommit;
+    private isInsufficientBalanceError;
+    private rebuildWithObjects;
     private toCheckerReceipt;
-    private reconcileAfterFailure;
     simulateSwap(req: SwapExecRequest): Promise<TxResponse>;
-    private minSplitFor;
-    private postTradeRebalance;
-    private buildSwapTx;
-    private onSuccess;
+    private swapTxShell;
+    private finishSwapTx;
+    private buildSwapTxBalance;
     get coinCache(): InProcessCoinCache;
     get tradeWalletAddresses(): string[];
     get coreClient(): ExecutorCore;

package/dist/trade/executor/central_executor.js

@@ -8,6 +8,7 @@ const format_1 = require("../../utils/format");
 const ed25519_1 = require("@mysten/sui/keypairs/ed25519");
 const transactions_1 = require("@mysten/sui/transactions");
 const coin_cache_1 = require("./coin_cache");
+const core_channel_1 = require("./core_channel");
 const effects_1 = require("./effects");
 const swap_1 = require("../swap");
 const constants_1 = require("../../constants");
@@ -43,8 +44,7 @@ class CentralExecutor {
         this.poolGenericsCache = new Map();
         this.chainIdentifier = '';
         this.epochCache = null;
-        this.gasBudget = opts.gasBudget ?? BigInt(process.env.SUI_GAS_BUDGET || '50000000');
-        this.reconcileAfterTx = opts.reconcileAfterTx ?? true;
+        this.gasBudget = opts.gasBudget ?? (0, format_1.suiToMist)(process.env.SUI_GAS_BUDGET, '0.05');
         this.onBroadcastResult = opts.onBroadcastResult;
         this.tradeCoinTypesProvider = opts.tradeCoinTypes;
         this.tradePoolsProvider = opts.tradePools;
@@ -142,6 +142,7 @@ class CentralExecutor {
         }
     }
     async rebalanceWalletFunds() {
+        void this.getValidDuringExpiration().catch(() => { });
         for (const [addr, kp] of this.tradeWallets) {
             try {
                 await this.rebalanceOne(addr, kp);
@@ -152,86 +153,106 @@ class CentralExecutor {
         }
     }
     async rebalanceOne(addr, kp) {
+        return this.rebalanceBalanceMode(addr, kp);
+    }
+    async rebalanceBalanceMode(addr, kp) {
         const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
-        const balanceMin = BigInt(process.env.SUI_GAS_BALANCE_MIN || '500000000');
-        const balanceTarget = BigInt(process.env.SUI_GAS_BALANCE_TARGET || (balanceMin * 2n).toString());
-        const coinTarget = Number(process.env.SUI_INPUT_COIN_TARGET || 3);
-        const coinMax = Number(process.env.SUI_INPUT_COIN_MAX || 5);
-        const chunk = BigInt(process.env.SUI_REDEEM_MIN_CHUNK || '100000000');
-        const budget = BigInt(process.env.SUI_MAINTAIN_GAS_BUDGET || '20000000');
-        await this.reconcileCoins(addr, SUI, true);
-        if (this.cache.hasInflight(addr, SUI))
-            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)}… 地址余额 ${ab} < min ${balanceMin} 且无足额 SUI coin 充值 —— 请注资（balance 转账即可）`);
-                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, `deposit ${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));
             }
             catch (e) {
-                (0, dist_1.log_warn)(`[executor] 读交易币种清单失败，本 tick 只维护 SUI: ${e.message}`);
+                (0, dist_1.log_warn)(`[executor] 读交易币种清单失败，本 tick 只归集 SUI: ${e.message}`);
             }
         }
         const types = [SUI, ...new Set(tradeTypes.filter(t => t !== SUI))];
+        const withObjects = [];
         for (const t of types) {
-            if (t !== SUI)
-                await this.reconcileCoins(addr, t, true);
-            if (this.cache.hasInflight(addr, t))
-                continue;
-            let minSplitT;
             try {
-                minSplitT = await this.minSplitFor(t);
+                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) {
-                (0, dist_1.log_warn)(`[executor] 读 ${t} decimals 失败，本 tick 跳过该币种维护: ${e.message}`);
+                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;
+            const coins = this.cache.snapshot(addr, t).coins;
+            if (coins.length === 0)
+                continue;
+            const tag = this.nextTag('sweep');
+            if (!this.cache.reserve(addr, t, coins.map(c => c.objectId), tag))
+                continue;
+            plan.push({ coinType: t, coins, tag });
+        }
+        if (plan.length === 0)
+            return;
+        try {
+            let suiAb = 0n;
+            try {
+                const sb = await this.core.getBalance({ owner: addr, coinType: '0x2::sui::SUI' });
+                suiAb = BigInt(sb.balance.addressBalance ?? '0');
             }
-            const acted = await this.maintainCoinObjects(addr, kp, t, { coinTarget, coinMax, budget, minSplit: minSplitT });
-            if (acted)
+            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);
+            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)] });
+                }
+            }
+            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 : ''}`);
         }
-    }
-    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 };
+        catch (e) {
+            (0, dist_1.log_error)(`[executor] sweep 归集失败`, e);
+        }
+        finally {
+            for (const p of plan) {
+                this.cache.abort(p.tag, true);
+                await this.reconcileCoins(addr, p.coinType);
+            }
         }
-        return best ? { wallet: best.wallet, addressBalance: best.addressBalance } : null;
     }
     async getCoinDecimalsCached(coinType) {
         let d = this.decimalsCache.get(coinType);
@@ -261,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)
@@ -379,57 +333,64 @@ 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) {
-            const s = await this.core.getCurrentSystemState();
-            const e = s?.systemState?.epoch ?? s?.epoch;
-            if (e == null)
-                throw new Error('[executor] getCurrentSystemState 未返回 epoch（ValidDuring 必需）');
-            this.epochCache = { epoch: BigInt(e), 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),
             } };
     }
     async getGasPrice() {
         return BigInt((await this.core.getReferenceGasPrice()).referenceGasPrice);
     }
-    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;
+    async fetchEpoch() {
+        const url = process.env.SUI_GRAPHQL_URL;
+        if (url) {
+            try {
+                return await (0, core_channel_1.fetchCurrentEpochViaGraphql)(url);
+            }
+            catch (e) {
+                (0, dist_1.log_warn)(`[executor] GraphQL epoch 查询失败，回退 gRPC getCurrentSystemState: ${e.message}`);
             }
         }
-        if (!best)
-            throw new Error(`无交易钱包持有 ≥ ${amount} 的 ${coinType}`);
-        return best;
+        const s = await this.core.getCurrentSystemState();
+        const e = s?.systemState?.epoch ?? s?.epoch;
+        if (e == null)
+            throw new Error('[executor] getCurrentSystemState 未返回 epoch（ValidDuring 必需）');
+        return BigInt(e);
     }
+    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; }
     async registerShared(tx, objectId, mutable) {
         const initialSharedVersion = await this.getSharedRefCached(objectId);
         tx.object(transactions_1.Inputs.SharedObjectRef({ objectId, initialSharedVersion, mutable }));
@@ -439,118 +400,99 @@ class CentralExecutor {
         req = await this.canonicalizeReq(req);
         const inType = this.inputCoinType(req);
         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] ${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`);
+        return this.submitSwapBalance(req, t0);
+    }
+    async submitSwapBalance(req, t0) {
+        const inType = this.inputCoinType(req);
+        const wallet = req.walletAddress ?? this.tradeWalletAddresses[0];
+        if (!wallet || !this.tradeWallets.has(wallet))
+            return { digest: '', submitted: false, error: `未知/无交易钱包: ${wallet}` };
         try {
-            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputCoins, shortfall);
+            const { txBytes, tx } = await this.buildSwapTxBalance(req, wallet);
             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}`);
+            void this.broadcastBalanceAndCommit(txBytes, [senderSig], digest, wallet, req, 0);
+            (0, dist_1.log_info)(`[executor] swap 已签提交(balance) 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 - t0}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);
+            (0, dist_1.log_error)(`[executor] submitSwapBalance 失败 dex=${req.dexId}`, e);
             return { digest: '', submitted: false, error: e.message };
         }
     }
-    async broadcastAndCommit(txBytes, signatures, digest, wallet, req, inputCoins, inputTag, attempt = 0, usedAddressBalance = false) {
+    async broadcastBalanceAndCommit(txBytes, signatures, digest, wallet, req, attempt = 0, inputTag) {
         const inType = this.inputCoinType(req);
         const outType = this.outputCoinType(req);
+        const releaseInput = () => { if (inputTag) {
+            this.cache.abort(inputTag, true);
+            void this.reconcileCoins(wallet, inType);
+        } };
         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'));
+                releaseInput();
+                (0, dist_1.log_error)(`[executor] 响应缺 effects 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`);
+                releaseInput();
+                (0, dist_1.log_warn)(`[executor] swap 链上失败(balance) 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`);
+            (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 (inputTag) {
+                this.cache.abort(inputTag, true);
+                void this.reconcileCoins(wallet, inType);
+            }
         }
         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 (!inputTag && this.isInsufficientBalanceError(e) && attempt < this.maxRebuildRetries) {
+                (0, dist_1.log_warn)(`[executor] ${this.pairLabel(req)} address-balance 不足，改用对象 fallback 重建（第 ${attempt + 1}/${this.maxRebuildRetries} 次）digest=${digest}: ${e.message}`);
+                const retry = await this.rebuildWithObjects(req, wallet);
                 if (retry) {
-                    void this.broadcastAndCommit(retry.txBytes, retry.signatures, retry.digest, wallet, req, retry.inputCoins, retry.inputTag, attempt + 1);
+                    void this.broadcastBalanceAndCommit(retry.txBytes, retry.signatures, retry.digest, wallet, req, attempt + 1, retry.inputTag);
                     return;
                 }
-                (0, dist_1.log_warn)(`[executor] swap 重建失败（输入不足等），转 reconcile 兜底 digest=${digest}`);
+                (0, dist_1.log_warn)(`[executor] 对象 fallback 也不足，交结果追踪 digest=${digest}`);
             }
-            this.reconcileAfterFailure(wallet, inType, outType);
-            (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest} broadcast=${Date.now() - tBroadcast}ms attempt=${attempt}`, e);
+            releaseInput();
+            (0, dist_1.log_error)(`[executor] broadcast(balance) 失败 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'));
+    isInsufficientBalanceError(e) {
+        const msg = (e?.message || String(e)).toLowerCase();
+        return msg.includes('insufficient') || msg.includes('withdraw') || (msg.includes('balance') && msg.includes('enough'));
     }
-    async rebuildSwap(req, wallet) {
+    async rebuildWithObjects(req, wallet) {
         try {
             const inType = this.inputCoinType(req);
+            await this.reconcileCoins(wallet, inType);
+            const b = await this.core.getBalance({ owner: wallet, coinType: inType });
+            const total = BigInt(b.balance.balance ?? '0');
+            if (total < req.amountIn) {
+                (0, dist_1.log_warn)(`[executor] ${inType.split('::').pop()} 总额 ${total} < 需 ${req.amountIn} → 真不足`);
+                return null;
+            }
             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 inputCoins = this.cache.acquireAvailable(wallet, inType, req.amountIn, inputTag);
+            const objSum = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+            const shortfall = req.amountIn > objSum ? req.amountIn - objSum : 0n;
+            const { txBytes, tx } = await this.buildSwapTxBalance(req, wallet, inputCoins, shortfall);
             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 };
+            (0, dist_1.log_info)(`[executor] swap 对象 fallback 重建(balance 管线) digest=${digest} dex=${req.dexId} ${req.a2b ? 'a2b' : 'b2a'} in=${req.amountIn} 对象=${inputCoins.length}枚 补=${shortfall}`);
+            return { txBytes, signatures: [signature], digest, inputTag };
         }
         catch (e) {
-            (0, dist_1.log_warn)(`[executor] swap 重建失败 dex=${req.dexId}: ${e.message}`);
+            (0, dist_1.log_warn)(`[executor] 对象 fallback 重建失败 dex=${req.dexId}: ${e.message}`);
             return null;
         }
     }
@@ -578,113 +520,62 @@ 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 wallet = req.walletAddress ?? this.chooseTradeWallet(req, inType, req.amountIn);
-        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}`);
-        const { txBytes } = await this.buildSwapTx(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 BigInt(process.env.SUI_INPUT_COIN_MIN_SPLIT || '100000000');
-        }
-        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 = BigInt(process.env.SUI_MAINTAIN_GAS_BUDGET || '20000000');
-        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;
-                await this.maintainCoinObjects(wallet, kp, t, { coinTarget, coinMax, budget, minSplit: await this.minSplitFor(t) });
-            }
-            catch (e) {
-                (0, dist_1.log_warn)(`[executor] postTradeRebalance ${t} 失败（交 30s tick 兜底）: ${e.message}`);
-            }
-        }
-    }
-    async buildSwapTx(req, wallet, inputCoins, shortfall = 0n) {
+    async swapTxShell(req, wallet) {
         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 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 { 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 tx;
+    }
+    async finishSwapTx(tx, online) {
         tx.setGasPayment([]);
         tx.setExpiration(await this.getValidDuringExpiration());
         tx.setGasBudget(this.gasBudget);
         tx.setGasPrice(await this.getGasPrice());
-        const txBytes = usedBalance ? await tx.build({ client: this.core.rawClient }) : await tx.build();
+        const txBytes = online ? await tx.build({ client: this.core.rawClient }) : await tx.build();
         return { txBytes, tx };
     }
-    async onSuccess(tr, wallet, req, inputCoins, inputTag, usedAddressBalance = false) {
+    async buildSwapTxBalance(req, wallet, objectCoins = [], shortfall = 0n) {
+        const tx = await this.swapTxShell(req, wallet);
         const inType = this.inputCoinType(req);
         const outType = this.outputCoinType(req);
-        if (usedAddressBalance) {
-            this.cache.abort(inputTag, true);
-            await this.reconcileCoins(wallet, inType);
+        const redeem = (amount) => {
+            const wd = tx.withdrawal({ amount, type: inType });
+            return tx.moveCall({ target: '0x2::coin::redeem_funds', typeArguments: [inType], arguments: [wd] })[0];
+        };
+        let inCoin;
+        if (objectCoins.length === 0) {
+            inCoin = redeem(req.amountIn);
         }
         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);
+            const objSum = objectCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+            const primary = tx.object(transactions_1.Inputs.ObjectRef(objectCoins[0]));
+            if (objectCoins.length > 1)
+                tx.mergeCoins(primary, objectCoins.slice(1).map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
+            if (objSum < req.amountIn)
+                tx.mergeCoins(primary, [redeem(req.amountIn - objSum)]);
+            [inCoin] = tx.splitCoins(primary, [tx.pure.u64(req.amountIn)]);
+            tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [inType], arguments: [primary, tx.pure.address(wallet)] });
         }
+        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.moveCall({ target: '0x2::coin::send_funds', typeArguments: [outType], arguments: [outputCoin, tx.pure.address(wallet)] });
+        for (const lo of leftoverCoins)
+            tx.moveCall({ target: '0x2::coin::send_funds', typeArguments: [inType], arguments: [lo, tx.pure.address(wallet)] });
+        return this.finishSwapTx(tx, false);
     }
     get coinCache() { return this.cache; }
     get tradeWalletAddresses() { return [...this.tradeWallets.keys()]; }

package/dist/trade/executor/coin_maintainer.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoinMaintainer = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
+const format_1 = require("../../utils/format");
 class CoinMaintainer {
     constructor(executor, opts = {}) {
         this.executor = executor;
         this.timer = null;
         this.running = false;
-        this.intervalMs = opts.intervalMs ?? Number(process.env.SUI_COIN_MAINTAIN_INTERVAL_MS || 30000);
+        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,4 +1,5 @@
 import { CoreClient, SuiClientTypes } from '@mysten/sui/client';
+export declare function fetchCurrentEpochViaGraphql(url: string, retries?: number): Promise<bigint>;
 export interface GrpcCoreOptions {
     endpoint?: string;
     token?: string;

package/dist/trade/executor/core_channel.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResilientCore = void 0;
+exports.fetchCurrentEpochViaGraphql = fetchCurrentEpochViaGraphql;
 exports.buildGrpcCore = buildGrpcCore;
 exports.buildGraphqlCore = buildGraphqlCore;
 exports.buildDefaultCore = buildDefaultCore;
@@ -25,6 +26,30 @@ const GRPC_CLIENT_OPTIONS = {
     'grpc-node.max_session_memory': 64,
     'grpc.default_compression_algorithm': 2,
 };
+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;
     const token = opts.token ?? (0, dist_1.getCoreEnv)().grpc_token;

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

@@ -5,3 +5,4 @@ export * from './central_executor';
 export * from './coin_maintainer';
 export * from './executor_protocol';
 export * from './executor_ws_client';
+export * from './balance_probe';

package/dist/trade/executor/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./central_executor"), exports);
 __exportStar(require("./coin_maintainer"), exports);
 __exportStar(require("./executor_protocol"), exports);
 __exportStar(require("./executor_ws_client"), exports);
+__exportStar(require("./balance_probe"), exports);

package/dist/utils/format.d.ts

@@ -1 +1,3 @@
 export declare const normalizeSuiTokenAddress: (address: string, useLongAddress?: boolean) => string;
+export declare function suiToMist(sui: string | undefined, fallbackSui: string): bigint;
+export declare function parseDurationMs(s: string | undefined, fallbackMs: number): number;

package/dist/utils/format.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeSuiTokenAddress = void 0;
+exports.suiToMist = suiToMist;
+exports.parseDurationMs = parseDurationMs;
 const constants_1 = require("../constants");
 const normalizeSuiTokenAddress = (address, useLongAddress = true) => {
     if (useLongAddress) {
@@ -16,3 +18,21 @@ const normalizeSuiTokenAddress = (address, useLongAddress = true) => {
     return address;
 };
 exports.normalizeSuiTokenAddress = normalizeSuiTokenAddress;
+function suiToMist(sui, fallbackSui) {
+    const s = (sui ?? '').trim() || fallbackSui;
+    const neg = s.startsWith('-');
+    const [intPart, fracPart = ''] = (neg ? s.slice(1) : s).split('.');
+    const frac = (fracPart + '000000000').slice(0, 9);
+    const mist = BigInt(intPart || '0') * 1000000000n + BigInt(frac || '0');
+    return neg ? -mist : mist;
+}
+function parseDurationMs(s, fallbackMs) {
+    const v = (s ?? '').trim();
+    if (!v)
+        return fallbackMs;
+    const m = v.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+    if (!m)
+        return Number(v) || fallbackMs;
+    const unit = { ms: 1, s: 1000, m: 60000, h: 3600000 };
+    return Math.round(Number(m[1]) * (unit[m[2] || 'ms']));
+}

package/package.json

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