@clonegod/ttd-sui-common 2.0.10 → 2.0.12

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

@@ -66,6 +66,7 @@ export declare class CentralExecutor {
     reconcileCoins(wallet: string, coinType: string, quietIfUnchanged?: boolean): Promise<void>;
     rebalanceWalletFunds(): Promise<void>;
     private rebalanceOne;
+    private selectWalletWithBalance;
     private decimalsCache;
     private objectReader?;
     private getCoinDecimalsCached;

package/dist/trade/executor/central_executor.js

@@ -217,6 +217,17 @@ class CentralExecutor {
                 return;
         }
     }
+    async selectWalletWithBalance(inType, amount) {
+        let best = null;
+        for (const w of this.tradeWallets.keys()) {
+            const objs = this.cache.snapshot(w, inType).total;
+            const b = await this.core.getBalance({ owner: w, coinType: inType });
+            const ab = BigInt(b.balance.addressBalance ?? '0');
+            if (objs + ab >= amount && (!best || objs + ab > best.sum))
+                best = { wallet: w, addressBalance: ab, sum: objs + ab };
+        }
+        return best ? { wallet: best.wallet, addressBalance: best.addressBalance } : null;
+    }
     async getCoinDecimalsCached(coinType) {
         let d = this.decimalsCache.get(coinType);
         if (d == null) {
@@ -423,33 +434,47 @@ class CentralExecutor {
         req = await this.canonicalizeReq(req);
         const inType = this.inputCoinType(req);
         await this.getCoinDecimalsCached(inType).catch(() => { });
-        let wallet;
+        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 重试`);
+            (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) {
-                (0, dist_1.log_error)(`[executor] ${this.pairLabel(req)} 余额不足：需 ${this.fmtAmount(inType, req.amountIn)}，reconcile 后各钱包缓存仍 [${this.walletBalancesLabel(inType)}]`, e2);
-                throw 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 inputTag = this.nextTag('in');
-        const inputRes = this.cache.acquire(wallet, inType, req.amountIn, inputTag);
         const tAcquire = Date.now();
-        const acqTotal = inputRes.coins.reduce((s, c) => s + BigInt(c.balance), 0n);
-        (0, dist_1.log_info)(`[executor] coin 已占用 wallet=${wallet.slice(0, 8)}… ${this.pairLabel(req)} 取 ${inputRes.coins.length} 枚=${this.fmtAmount(inType, acqTotal)}（需 ${this.fmtAmount(inType, req.amountIn)}）选钱包+占币 ${tAcquire - t0}ms`);
+        const acqTotal = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+        const shortStr = shortfall > 0n ? ` + address-balance 补 ${this.fmtAmount(inType, shortfall)}` : '';
+        (0, dist_1.log_info)(`[executor] coin 已占用 wallet=${wallet.slice(0, 8)}… ${this.pairLabel(req)} 取 ${inputCoins.length} 枚=${this.fmtAmount(inType, acqTotal)}${shortStr}（需 ${this.fmtAmount(inType, req.amountIn)}）选钱包+占币 ${tAcquire - t0}ms`);
         try {
-            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
+            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputCoins, shortfall);
             const tBuild = Date.now();
             const { signature: senderSig } = await this.tradeWallets.get(wallet).signTransaction(txBytes);
             const digest = await tx.getDigest();
             const tSign = Date.now();
-            void this.broadcastAndCommit(txBytes, [senderSig], digest, wallet, req, inputRes.coins, inputTag);
+            void this.broadcastAndCommit(txBytes, [senderSig], digest, wallet, req, inputCoins, inputTag, 0, shortfall > 0n);
             (0, dist_1.log_info)(`[executor] swap 已签提交 digest=${digest} dex=${req.dexId} ${this.pairLabel(req)} in=${this.fmtAmount(inType, req.amountIn)} minOut=${this.fmtAmount(this.outputCoinType(req), req.minOut)} cost={build:${tBuild - tAcquire}ms, sign+digest:${tSign - tBuild}ms, total:${tSign - t0}ms}`);
             return { digest, submitted: true };
         }
@@ -459,7 +484,7 @@ class CentralExecutor {
             return { digest: '', submitted: false, error: e.message };
         }
     }
-    async broadcastAndCommit(txBytes, signatures, digest, wallet, req, inputCoins, inputTag, attempt = 0) {
+    async broadcastAndCommit(txBytes, signatures, digest, wallet, req, inputCoins, inputTag, attempt = 0, usedAddressBalance = false) {
         const inType = this.inputCoinType(req);
         const outType = this.outputCoinType(req);
         const tBroadcast = Date.now();
@@ -481,13 +506,13 @@ class CentralExecutor {
                 this.onBroadcastResult?.({ digest, success: false, error, receipt: this.toCheckerReceipt(tr, digest) });
                 return;
             }
-            await this.onSuccess(tr, wallet, req, inputCoins, inputTag);
+            await this.onSuccess(tr, wallet, req, inputCoins, inputTag, usedAddressBalance);
             (0, dist_1.log_info)(`[executor] swap quorum-executed 确认 digest=${digest} broadcast=${Date.now() - tBroadcast}ms`);
             this.onBroadcastResult?.({ digest, success: true, receipt: this.toCheckerReceipt(tr, digest) });
         }
         catch (e) {
             this.cache.abort(inputTag, true);
-            if (this.isRebuildableObjectError(e) && attempt < this.maxRebuildRetries) {
+            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);
@@ -602,17 +627,26 @@ class CentralExecutor {
             }
         }
     }
-    async buildSwapTx(req, wallet, inputCoins) {
+    async buildSwapTx(req, wallet, inputCoins, shortfall = 0n) {
         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 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))));
+        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 [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,
@@ -623,20 +657,26 @@ class CentralExecutor {
         tx.setExpiration(await this.getValidDuringExpiration());
         tx.setGasBudget(this.gasBudget);
         tx.setGasPrice(await this.getGasPrice());
-        const txBytes = await tx.build();
+        const txBytes = usedBalance ? await tx.build({ client: this.core.rawClient }) : await tx.build();
         return { txBytes, tx };
     }
-    async onSuccess(tr, wallet, req, inputCoins, inputTag) {
+    async onSuccess(tr, wallet, req, inputCoins, inputTag, usedAddressBalance = false) {
         const inType = this.inputCoinType(req);
         const outType = this.outputCoinType(req);
-        const inputTotal = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
-        const inputChanges = (0, effects_1.extractSwapInputChanges)(tr.effects, {
-            wallet, inCoinType: inType,
-            primaryId: inputCoins[0].objectId,
-            reservedInputIds: inputCoins.map(c => c.objectId),
-            inputTotal, amountIn: req.amountIn,
-        });
-        this.cache.commit(inputTag, inputChanges);
+        if (usedAddressBalance) {
+            this.cache.abort(inputTag, true);
+            await this.reconcileCoins(wallet, inType);
+        }
+        else {
+            const inputTotal = inputCoins.reduce((s, c) => s + BigInt(c.balance), 0n);
+            const inputChanges = (0, effects_1.extractSwapInputChanges)(tr.effects, {
+                wallet, inCoinType: inType,
+                primaryId: inputCoins[0].objectId,
+                reservedInputIds: inputCoins.map(c => c.objectId),
+                inputTotal, amountIn: req.amountIn,
+            });
+            this.cache.commit(inputTag, inputChanges);
+        }
         if (this.reconcileAfterTx) {
             void this.postTradeRebalance(wallet, inType, outType);
         }

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

@@ -18,6 +18,7 @@ export declare class InProcessCoinCache {
     seed(wallet: string, coinType: string, coins: CoinRef[]): void;
     reconcile(wallet: string, coinType: string, freshCoins: CoinRef[], epochAtStart?: number, quietIfUnchanged?: boolean): boolean;
     acquire(wallet: string, coinType: string, amount: bigint, txTag: string, maxCoins?: number): CoinReservation;
+    acquireAvailable(wallet: string, coinType: string, amount: bigint, txTag: string): CoinRef[];
     reserve(wallet: string, coinType: string, objectIds: string[], txTag: string): CoinRef[] | null;
     hasInflight(wallet: string, coinType: string): boolean;
     commit(txTag: string, changes: CoinObjectChange[]): void;

package/dist/trade/executor/coin_cache.js

@@ -21,22 +21,28 @@ class InProcessCoinCache {
     setAmountFormatter(fn) { this.amountFmt = fn; }
     fmt(coinType, raw) { return this.amountFmt ? this.amountFmt(coinType, raw) : `${raw.toString()}(raw)`; }
     logCoinBreakdown(wallet, coinType, reason, quiet = false) {
-        const l = this.list(wallet, coinType);
-        const total = l.reduce((s, c) => s + BigInt(c.balance), 0n);
+        const avail = this.list(wallet, coinType);
+        const inUse = [];
+        for (const r of this.inflight.values()) {
+            if (r.wallet === wallet && r.coinType === coinType)
+                inUse.push(...r.coins);
+        }
         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 mapObj = (cs) => cs.map(c => ({
+            objectId: c.objectId,
+            version: c.version,
+            balance: this.fmt(coinType, BigInt(c.balance)),
+        }));
         const detail = {
             reason, wallet, symbol, coinType,
-            count: l.length,
-            total: this.fmt(coinType, total),
-            total_raw: total.toString(),
-            objects: l.map(c => ({
-                objectId: c.objectId,
-                version: c.version,
-                balance: this.fmt(coinType, BigInt(c.balance)),
-                balance_raw: c.balance,
-            })),
+            total: this.fmt(coinType, grand),
+            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 header = `[coin-cache] ${reason} ${symbol} ${l.length}枚 total=${this.fmt(coinType, total)}`;
+        const useStr = inUse.length ? `, ${inUse.length} 个正在交易中` : '';
+        const header = `[coin-cache] ${reason} ${symbol}: 共 ${this.fmt(coinType, grand)}（可用 ${avail.length} 个${useStr}）`;
         if (quiet)
             (0, dist_1.log_debug)(header, detail);
         else
@@ -105,7 +111,7 @@ class InProcessCoinCache {
         const sig = (l) => l.map(c => `${c.objectId}@${c.version}:${c.balance}`).join(',');
         const unchanged = sig(kept) === sig(this.list(wallet, coinType));
         this.walletMap(wallet).set(coinType, kept);
-        this.logCoinBreakdown(wallet, coinType, `reconcile(${inflightIds.size}在途)`, unchanged && quietIfUnchanged);
+        this.logCoinBreakdown(wallet, coinType, '链上对账', unchanged && quietIfUnchanged);
         return true;
     }
     acquire(wallet, coinType, amount, txTag, maxCoins = 8) {
@@ -132,6 +138,24 @@ class InProcessCoinCache {
         this.bumpEpoch(wallet, coinType);
         return { txTag, coinType, coins: picked };
     }
+    acquireAvailable(wallet, coinType, amount, txTag) {
+        if (this.inflight.has(txTag))
+            throw new Error(`[coin-cache] txTag 重复: ${txTag}`);
+        const l = this.list(wallet, coinType);
+        const picked = [];
+        let sum = 0n;
+        for (const c of l) {
+            if (sum >= amount)
+                break;
+            picked.push(c);
+            sum += BigInt(c.balance);
+        }
+        const ids = new Set(picked.map(c => c.objectId));
+        this.walletMap(wallet).set(coinType, l.filter(c => !ids.has(c.objectId)));
+        this.inflight.set(txTag, { wallet, coinType, coins: picked, gas: false });
+        this.bumpEpoch(wallet, coinType);
+        return picked;
+    }
     reserve(wallet, coinType, objectIds, txTag) {
         if (this.inflight.has(txTag))
             throw new Error(`[coin-cache] txTag 重复: ${txTag}`);
@@ -183,7 +207,7 @@ class InProcessCoinCache {
             this.committedAt.set(this.commitKey(wallet, ch.coinType, ch.objectId), Date.now());
         }
         for (const ct of new Set(changes.map(c => c.coinType)))
-            this.logCoinBreakdown(res.wallet, ct, 'commit后');
+            this.logCoinBreakdown(res.wallet, ct, '交易后更新');
     }
     abort(txTag, consumed) {
         const res = this.inflight.get(txTag);

package/package.json

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