@clonegod/ttd-sui-common 2.0.12 → 2.0.14

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

@@ -66,6 +66,9 @@ export declare class CentralExecutor {
     reconcileCoins(wallet: string, coinType: string, quietIfUnchanged?: boolean): Promise<void>;
     rebalanceWalletFunds(): Promise<void>;
     private rebalanceOne;
+    private rebalanceBalanceMode;
+    private rebalanceObjectMode;
+    private sweepObjectsToBalance;
     private selectWalletWithBalance;
     private decimalsCache;
     private objectReader?;
@@ -84,12 +87,18 @@ export declare class CentralExecutor {
     private epochCache;
     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;
@@ -98,7 +107,10 @@ export declare class CentralExecutor {
     simulateSwap(req: SwapExecRequest): Promise<TxResponse>;
     private minSplitFor;
     private postTradeRebalance;
-    private buildSwapTx;
+    private swapTxShell;
+    private finishSwapTx;
+    private buildSwapTxObject;
+    private buildSwapTxBalance;
     private onSuccess;
     get coinCache(): InProcessCoinCache;
     get tradeWalletAddresses(): string[];

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,12 +44,13 @@ class CentralExecutor {
         this.poolGenericsCache = new Map();
         this.chainIdentifier = '';
         this.epochCache = null;
-        this.gasBudget = opts.gasBudget ?? BigInt(process.env.SUI_GAS_BUDGET || '50000000');
+        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;
         this.cache.setAmountFormatter((ct, raw) => this.fmtAmount(ct, raw));
+        this.decimalsCache.set(constants_1.SUI_TOKEN_ADDRESS.LONG, 9);
     }
     async init() {
         const tradeIds = (process.env.SUI_WALLET_GROUP_IDS || '').split(',').map(s => s.trim()).filter(Boolean);
@@ -117,6 +119,9 @@ class CentralExecutor {
     }
     async reconcileCoins(wallet, coinType, quietIfUnchanged = false) {
         try {
+            const abP = this.core.getBalance({ owner: wallet, coinType })
+                .then(b => this.cache.setAddressBalance(wallet, coinType, BigInt(b.balance.addressBalance ?? '0')))
+                .catch(() => { });
             for (let attempt = 0; attempt < 2; attempt++) {
                 const epoch = this.cache.mutationEpoch(wallet, coinType);
                 const refs = [];
@@ -128,6 +133,7 @@ class CentralExecutor {
                     }
                     cursor = page.hasNextPage ? page.cursor : null;
                 } while (cursor);
+                await abP;
                 if (this.cache.reconcile(wallet, coinType, refs, epoch, quietIfUnchanged))
                     return;
             }
@@ -147,13 +153,40 @@ class CentralExecutor {
         }
     }
     async rebalanceOne(addr, kp) {
+        if (this.fundModeFor() === 'balance')
+            return this.rebalanceBalanceMode(addr, kp);
+        return this.rebalanceObjectMode(addr, kp);
+    }
+    async rebalanceBalanceMode(addr, kp) {
+        const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
+        const budget = this.gasBudget;
+        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}`);
+            }
+        }
+        for (const t of [SUI, ...new Set(tradeTypes.filter(t => t !== SUI))]) {
+            await this.reconcileCoins(addr, t, true);
+            if (this.cache.hasInflight(addr, t))
+                continue;
+            if (this.cache.snapshot(addr, t).coins.length === 0)
+                continue;
+            if (await this.sweepObjectsToBalance(addr, kp, t, budget))
+                return;
+        }
+    }
+    async rebalanceObjectMode(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 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);
-        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;
@@ -165,7 +198,7 @@ class CentralExecutor {
             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 转账即可）`);
+                (0, dist_1.log_warn)(`[executor] ${addr.slice(0, 10)}… SUI address-balance ${ab} < gasMin ${balanceMin} 且无足额 SUI 对象充值 —— 请注资`);
                 return;
             }
             const tx = new transactions_1.Transaction();
@@ -173,7 +206,7 @@ class CentralExecutor {
             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`);
+            await this.execMaintenance(tx, addr, kp, budget, `gas 储备充值 ${need} → balance`);
             return;
         }
         if (ab > balanceTarget + chunk) {
@@ -198,8 +231,7 @@ class CentralExecutor {
                 (0, dist_1.log_warn)(`[executor] 读交易币种清单失败，本 tick 只维护 SUI: ${e.message}`);
             }
         }
-        const types = [SUI, ...new Set(tradeTypes.filter(t => t !== SUI))];
-        for (const t of types) {
+        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))
@@ -212,11 +244,47 @@ class CentralExecutor {
                 (0, dist_1.log_warn)(`[executor] 读 ${t} decimals 失败，本 tick 跳过该币种维护: ${e.message}`);
                 continue;
             }
-            const acted = await this.maintainCoinObjects(addr, kp, t, { coinTarget, coinMax, budget, minSplit: minSplitT });
-            if (acted)
+            if (await this.maintainCoinObjects(addr, kp, t, { coinTarget, coinMax, budget, minSplit: minSplitT }))
                 return;
         }
     }
+    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;
+            }
+            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()) {
@@ -386,11 +454,7 @@ class CentralExecutor {
         }
         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 };
+            this.epochCache = { epoch: await this.fetchEpoch(), ts: now };
         }
         return { ValidDuring: {
                 minEpoch: String(this.epochCache.epoch),
@@ -403,6 +467,25 @@ class CentralExecutor {
     async getGasPrice() {
         return BigInt((await this.core.getReferenceGasPrice()).referenceGasPrice);
     }
+    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}`);
+            }
+        }
+        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);
+    }
+    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; }
@@ -434,6 +517,8 @@ 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 = '';
@@ -469,7 +554,7 @@ class CentralExecutor {
         const shortStr = shortfall > 0n ? ` + address-balance 补 ${this.fmtAmount(inType, shortfall)}` : '';
         (0, dist_1.log_info)(`[executor] coin 已占用 wallet=${wallet.slice(0, 8)}… ${this.pairLabel(req)} 取 ${inputCoins.length} 枚=${this.fmtAmount(inType, acqTotal)}${shortStr}（需 ${this.fmtAmount(inType, req.amountIn)}）选钱包+占币 ${tAcquire - t0}ms`);
         try {
-            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputCoins, shortfall);
+            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();
@@ -484,6 +569,100 @@ class CentralExecutor {
             return { digest: '', submitted: false, error: e.message };
         }
     }
+    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.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.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) {
+            (0, dist_1.log_error)(`[executor] submitSwapBalance 失败 dex=${req.dexId}`, e);
+            return { digest: '', submitted: false, error: e.message };
+        }
+    }
+    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) {
+                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) {
+                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;
+            }
+            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);
+        }
+        catch (e) {
+            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.broadcastBalanceAndCommit(retry.txBytes, retry.signatures, retry.digest, wallet, req, attempt + 1, retry.inputTag);
+                    return;
+                }
+                (0, dist_1.log_warn)(`[executor] 对象 fallback 也不足，交结果追踪 digest=${digest}`);
+            }
+            releaseInput();
+            (0, dist_1.log_error)(`[executor] broadcast(balance) 失败 digest=${digest} broadcast=${Date.now() - tBroadcast}ms attempt=${attempt}`, e);
+        }
+    }
+    isInsufficientBalanceError(e) {
+        const msg = (e?.message || String(e)).toLowerCase();
+        return msg.includes('insufficient') || msg.includes('withdraw') || (msg.includes('balance') && msg.includes('enough'));
+    }
+    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 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 对象 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] 对象 fallback 重建失败 dex=${req.dexId}: ${e.message}`);
+            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);
@@ -538,7 +717,7 @@ class CentralExecutor {
             const inType = this.inputCoinType(req);
             const inputTag = this.nextTag('in');
             const inputRes = this.cache.acquire(wallet, inType, req.amountIn, inputTag);
-            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
+            const { 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}`);
@@ -580,21 +759,28 @@ class CentralExecutor {
     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 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 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)}`);
@@ -603,7 +789,7 @@ class CentralExecutor {
     }
     async minSplitFor(coinType) {
         if (coinType === constants_1.SUI_TOKEN_ADDRESS.LONG) {
-            return BigInt(process.env.SUI_INPUT_COIN_MIN_SPLIT || '100000000');
+            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;
@@ -614,51 +800,98 @@ class CentralExecutor {
             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');
+        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;
-                await this.maintainCoinObjects(wallet, kp, t, { coinTarget, coinMax, budget, minSplit: await this.minSplitFor(t) });
+                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} 失败（交 30s tick 兜底）: ${e.message}`);
+                (0, dist_1.log_warn)(`[executor] postTradeRebalance ${t} 失败（交定时 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 }));
+        return tx;
+    }
+    async finishSwapTx(tx, online) {
+        tx.setGasPayment([]);
+        tx.setExpiration(await this.getValidDuringExpiration());
+        tx.setGasBudget(this.gasBudget);
+        tx.setGasPrice(await this.getGasPrice());
+        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);
-        const usedBalance = shortfall > 0n || inputCoins.length === 0;
         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)
+            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,
+            a2b: req.a2b, byAmountIn: true, amount: req.amountIn, amountLimit: req.minOut, sqrtPriceLimit: req.sqrtPriceLimit,
         }, inCoin);
         tx.transferObjects([outputCoin, ...leftoverCoins], tx.pure.address(wallet));
-        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();
-        return { txBytes, tx };
+        return this.finishSwapTx(tx, usedResolver);
+    }
+    async buildSwapTxBalance(req, wallet, objectCoins = [], shortfall = 0n) {
+        const tx = await this.swapTxShell(req, wallet);
+        const inType = this.inputCoinType(req);
+        const outType = this.outputCoinType(req);
+        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 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);
     }
     async onSuccess(tr, wallet, req, inputCoins, inputTag, usedAddressBalance = false) {
         const inType = this.inputCoinType(req);

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

@@ -11,6 +11,8 @@ export declare class InProcessCoinCache {
     private amountFmt?;
     setAmountFormatter(fn: (coinType: string, raw: bigint) => string): void;
     private fmt;
+    private addressBalances;
+    setAddressBalance(wallet: string, coinType: string, ab: bigint): void;
     logCoinBreakdown(wallet: string, coinType: string, reason: string, quiet?: boolean): void;
     private walletMap;
     private list;

package/dist/trade/executor/coin_cache.js

@@ -8,6 +8,7 @@ class InProcessCoinCache {
         this.inflight = new Map();
         this.committedAt = new Map();
         this.epochs = new Map();
+        this.addressBalances = new Map();
     }
     commitKey(wallet, coinType, objectId) { return `${wallet}|${coinType}|${objectId}`; }
     epochKey(wallet, coinType) { return `${wallet}|${coinType}`; }
@@ -20,6 +21,7 @@ class InProcessCoinCache {
     }
     setAmountFormatter(fn) { this.amountFmt = fn; }
     fmt(coinType, raw) { return this.amountFmt ? this.amountFmt(coinType, raw) : `${raw.toString()}(raw)`; }
+    setAddressBalance(wallet, coinType, ab) { this.addressBalances.set(`${wallet}|${coinType}`, ab); }
     logCoinBreakdown(wallet, coinType, reason, quiet = false) {
         const avail = this.list(wallet, coinType);
         const inUse = [];
@@ -29,7 +31,9 @@ class InProcessCoinCache {
         }
         const symbol = coinType.split('::').pop();
         const sum = (cs) => cs.reduce((s, c) => s + BigInt(c.balance), 0n);
-        const availT = sum(avail), useT = sum(inUse), grand = availT + useT;
+        const availT = sum(avail), useT = sum(inUse), objT = availT + useT;
+        const ab = this.addressBalances.get(`${wallet}|${coinType}`) ?? 0n;
+        const grand = objT + ab;
         const mapObj = (cs) => cs.map(c => ({
             objectId: c.objectId,
             version: c.version,
@@ -38,11 +42,13 @@ class InProcessCoinCache {
         const detail = {
             reason, wallet, symbol, coinType,
             total: this.fmt(coinType, grand),
+            address_balance: this.fmt(coinType, ab),
+            objects_total: this.fmt(coinType, objT),
             available_count: avail.length, available_total: this.fmt(coinType, availT), available: mapObj(avail),
             in_use_count: inUse.length, in_use_total: this.fmt(coinType, useT), in_use: mapObj(inUse),
         };
-        const useStr = inUse.length ? `, ${inUse.length} 个正在交易中` : '';
-        const header = `[coin-cache] ${reason} ${symbol}: 共 ${this.fmt(coinType, grand)}（可用 ${avail.length} 个${useStr}）`;
+        const useStr = inUse.length ? ` +${inUse.length}个交易中` : '';
+        const header = `[coin-cache] ${reason} ${symbol}: 共 ${this.fmt(coinType, grand)} = 对象 ${this.fmt(coinType, objT)}(${avail.length}个${useStr}) + address-balance ${this.fmt(coinType, ab)}`;
         if (quiet)
             (0, dist_1.log_debug)(header, detail);
         else

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, 60000);
     }
     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): 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,14 @@ 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);
+}
 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.12",
+  "version": "2.0.14",
   "description": "Sui common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",