@clonegod/ttd-sui-common 2.0.5 → 2.0.7

package/dist/grpc/grpc-connection.js

@@ -64,9 +64,11 @@ class GrpcConnection {
         'grpc.max_reconnect_backoff_ms': 30000,
         'grpc.enable_retries': 1,
         'grpc.retry_buffer_size': 256 * 1024,
+        'grpc-node.flow_control_window': 8 * 1024 * 1024,
+        'grpc-node.max_session_memory': 64,
+        'grpc.default_compression_algorithm': 2,
         'grpc.http2.max_frame_size': 16384,
         'grpc.http2.max_header_list_size': 16384,
-        'grpc.http2.initial_window_size': 65535,
     }; }
     getChannel() {
         if (!this.channel) {

package/dist/grpc/grpc_provider_registry.d.ts

@@ -9,6 +9,6 @@ interface RedisLike {
     hgetall(key: string): Promise<Record<string, string> | null>;
     subscribe(channel: string, listener: (message: string) => void): Promise<void> | void;
 }
-export declare function resolveGrpcProvider(redis: RedisLike, chainId: string): Promise<GrpcProviderConfig>;
-export declare function watchGrpcProviderChange(redis: RedisLike, chainId: string, active: GrpcProviderConfig, onChange: (next: GrpcProviderConfig | null) => void): void;
+export declare function resolveGrpcProvider(redis: RedisLike, chainId: string, preferId?: string): Promise<GrpcProviderConfig>;
+export declare function watchGrpcProviderChange(redis: RedisLike, chainId: string, active: GrpcProviderConfig, onChange: (next: GrpcProviderConfig | null) => void, preferId?: string): void;
 export {};

package/dist/grpc/grpc_provider_registry.js

@@ -11,7 +11,7 @@ function getRpcProvidersKey(chainId) {
 function getRpcConfigChangeChannel(chainId) {
     return `${chainId.toLowerCase()}:rpc:config:change`;
 }
-async function resolveGrpcProvider(redis, chainId) {
+async function resolveGrpcProvider(redis, chainId, preferId) {
     const key = getRpcProvidersKey(chainId);
     const map = (await redis.hgetall(key)) || {};
     const candidates = [];
@@ -28,6 +28,16 @@ async function resolveGrpcProvider(redis, chainId) {
     if (candidates.length === 0) {
         throw new Error(`[grpc-registry] ${key} 无 enabled 的 grpc provider —— 请在 trade-analyze Config/RPC 页新增 type=grpc 的 Provider（grpc_endpoint 填 host:port，auth_token 填 x-token）`);
     }
+    if (preferId) {
+        const preferred = candidates.find(c => c.id === preferId);
+        if (!preferred) {
+            throw new Error(`[grpc-registry] 指定的 grpc provider '${preferId}' 不存在或未 enabled（${key} 可用: ${candidates.map(c => c.id).join(',')}）`);
+        }
+        if (!preferred.auth_token)
+            (0, dist_1.log_warn)(`[grpc-registry] provider ${preferred.id} auth_token 为空，按无鉴权端点连接`);
+        (0, dist_1.log_info)(`[grpc-registry] 使用指定 provider: ${preferred.id}`);
+        return { id: preferred.id, endpoint: preferred.grpc_endpoint, token: preferred.auth_token || '' };
+    }
     candidates.sort((a, b) => (b.default_for_quote === true ? 1 : 0) - (a.default_for_quote === true ? 1 : 0)
         || a.id.localeCompare(b.id));
     const picked = candidates[0];
@@ -39,13 +49,13 @@ async function resolveGrpcProvider(redis, chainId) {
     }
     return { id: picked.id, endpoint: picked.grpc_endpoint, token: picked.auth_token || '' };
 }
-function watchGrpcProviderChange(redis, chainId, active, onChange) {
+function watchGrpcProviderChange(redis, chainId, active, onChange, preferId) {
     const channel = getRpcConfigChangeChannel(chainId);
     redis.subscribe(channel, (message) => {
         void (async () => {
             let next;
             try {
-                next = await resolveGrpcProvider(redis, chainId);
+                next = await resolveGrpcProvider(redis, chainId, preferId);
             }
             catch {
                 next = null;

package/dist/quote/abstract_dex_quote.js

@@ -173,6 +173,9 @@ class AbstractDexQuote {
                 streamTime: result.streamTimestamp, quoteStartTime: result.quoteStartTime, blockNumber: result.blockNumber,
                 quotes: [result.askQuote, result.bidQuote], txid: result.txid, source: result.source, depth: result.depth,
             });
+            if (isV2) {
+                (0, dist_1.log_info)(`[QUOTE OK v2] ${result.poolInfo.pool_name} ask=${result.askQuote.price} bid=${result.bidQuote.price} blk=${result.blockNumber} tx=${result.txIndex} ${result.txid}`);
+            }
         }
         result.trace?.set('published', shouldPush);
         result.trace?.mark('publish');

package/dist/quote/depth/clmm_depth_calculator.d.ts

@@ -0,0 +1,28 @@
+export interface DepthTick {
+    index: number;
+    liquidityNet: bigint;
+    sqrtPriceX64: bigint;
+}
+export interface ClmmDepthInput {
+    sqrtPriceX64: bigint;
+    currentTick: number;
+    liquidity: bigint;
+    ticks: DepthTick[];
+    zeroForOne: boolean;
+    targetBps: number;
+    inputDecimals: number;
+    outputDecimals: number;
+}
+export interface DepthResult {
+    amountInWei: bigint;
+    amountIn: number;
+    amountOutWei: bigint;
+    amountOut: number;
+    currentTick: number;
+    targetTick: number;
+    targetSqrtPriceX64: bigint;
+}
+export declare function calculateClmmDepth(input: ClmmDepthInput): DepthResult;
+export declare function priceFromSqrtX64(sqrtPriceX64: bigint, baseDecimals: number, quoteDecimals: number, baseIsToken0: boolean): number;
+export declare function computeTargetSqrtX64(currentSqrtPriceX64: bigint, bps: number, zeroForOne: boolean): bigint;
+export declare function bigIntSqrt(n: bigint): bigint;

package/dist/quote/depth/clmm_depth_calculator.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateClmmDepth = calculateClmmDepth;
+exports.priceFromSqrtX64 = priceFromSqrtX64;
+exports.computeTargetSqrtX64 = computeTargetSqrtX64;
+exports.bigIntSqrt = bigIntSqrt;
+const Q64 = 1n << 64n;
+function calculateClmmDepth(input) {
+    const { currentTick, zeroForOne, targetBps, inputDecimals, outputDecimals } = input;
+    const currentSqrtPriceX64 = input.sqrtPriceX64;
+    let liquidity = input.liquidity;
+    if (liquidity <= 0n) {
+        return { amountInWei: 0n, amountIn: 0, amountOutWei: 0n, amountOut: 0, currentTick, targetTick: currentTick, targetSqrtPriceX64: currentSqrtPriceX64 };
+    }
+    const targetSqrtPriceX64 = computeTargetSqrtX64(currentSqrtPriceX64, targetBps, zeroForOne);
+    const ticksToTraverse = getTicksBetween(input.ticks, currentTick, zeroForOne);
+    let totalInput = 0n;
+    let totalOutput = 0n;
+    let sqrtPriceCursor = currentSqrtPriceX64;
+    for (const tick of ticksToTraverse) {
+        const sqrtPriceAtTick = tick.sqrtPriceX64;
+        if (zeroForOne && sqrtPriceAtTick <= targetSqrtPriceX64)
+            break;
+        if (!zeroForOne && sqrtPriceAtTick >= targetSqrtPriceX64)
+            break;
+        if (liquidity > 0n) {
+            totalInput += calcInputForRange(sqrtPriceCursor, sqrtPriceAtTick, liquidity, zeroForOne);
+            totalOutput += calcOutputForRange(sqrtPriceCursor, sqrtPriceAtTick, liquidity, zeroForOne);
+        }
+        let liquidityNet = tick.liquidityNet;
+        if (zeroForOne)
+            liquidityNet = -liquidityNet;
+        liquidity = liquidity + liquidityNet;
+        if (liquidity < 0n)
+            liquidity = 0n;
+        sqrtPriceCursor = sqrtPriceAtTick;
+    }
+    if (liquidity > 0n && sqrtPriceCursor !== targetSqrtPriceX64) {
+        totalInput += calcInputForRange(sqrtPriceCursor, targetSqrtPriceX64, liquidity, zeroForOne);
+        totalOutput += calcOutputForRange(sqrtPriceCursor, targetSqrtPriceX64, liquidity, zeroForOne);
+    }
+    const amountIn = Number(totalInput) / Math.pow(10, inputDecimals);
+    const amountOut = Number(totalOutput) / Math.pow(10, outputDecimals);
+    const sqrtPriceFloat = Number(targetSqrtPriceX64) / Number(Q64);
+    const targetTick = Math.floor(Math.log(sqrtPriceFloat * sqrtPriceFloat) / Math.log(1.0001));
+    return { amountInWei: totalInput, amountIn, amountOutWei: totalOutput, amountOut, currentTick, targetTick, targetSqrtPriceX64 };
+}
+function priceFromSqrtX64(sqrtPriceX64, baseDecimals, quoteDecimals, baseIsToken0) {
+    const sp = Number(sqrtPriceX64) / Number(Q64);
+    const priceToken1PerToken0 = sp * sp;
+    if (baseIsToken0) {
+        return priceToken1PerToken0 * Math.pow(10, baseDecimals - quoteDecimals);
+    }
+    else {
+        return (1 / priceToken1PerToken0) * Math.pow(10, baseDecimals - quoteDecimals);
+    }
+}
+function computeTargetSqrtX64(currentSqrtPriceX64, bps, zeroForOne) {
+    const PRECISION = 10n ** 18n;
+    const bpsBigInt = BigInt(bps);
+    const factor = zeroForOne ? 10000n - bpsBigInt : 10000n + bpsBigInt;
+    const sqrtFactor = bigIntSqrt(factor * PRECISION);
+    const sqrtBase = bigIntSqrt(10000n * PRECISION);
+    return currentSqrtPriceX64 * sqrtFactor / sqrtBase;
+}
+function bigIntSqrt(n) {
+    if (n < 0n)
+        throw new Error('sqrt of negative');
+    if (n === 0n)
+        return 0n;
+    if (n <= 3n)
+        return 1n;
+    let x = n;
+    let y = (x + 1n) / 2n;
+    while (y < x) {
+        x = y;
+        y = (x + n / x) / 2n;
+    }
+    return x;
+}
+function getTicksBetween(ticks, currentTick, zeroForOne) {
+    if (zeroForOne) {
+        return ticks.filter(t => t.index <= currentTick).sort((a, b) => b.index - a.index);
+    }
+    else {
+        return ticks.filter(t => t.index > currentTick).sort((a, b) => a.index - b.index);
+    }
+}
+function calcInputForRange(sqrtPriceA, sqrtPriceB, liquidity, zeroForOne) {
+    const lower = sqrtPriceA < sqrtPriceB ? sqrtPriceA : sqrtPriceB;
+    const upper = sqrtPriceA < sqrtPriceB ? sqrtPriceB : sqrtPriceA;
+    const diff = upper - lower;
+    if (diff === 0n || liquidity === 0n)
+        return 0n;
+    if (zeroForOne) {
+        return liquidity * diff * Q64 / (lower * upper);
+    }
+    else {
+        return liquidity * diff / Q64;
+    }
+}
+function calcOutputForRange(sqrtPriceA, sqrtPriceB, liquidity, zeroForOne) {
+    const lower = sqrtPriceA < sqrtPriceB ? sqrtPriceA : sqrtPriceB;
+    const upper = sqrtPriceA < sqrtPriceB ? sqrtPriceB : sqrtPriceA;
+    const diff = upper - lower;
+    if (diff === 0n || liquidity === 0n)
+        return 0n;
+    if (zeroForOne) {
+        return liquidity * diff / Q64;
+    }
+    else {
+        return liquidity * diff * Q64 / (lower * upper);
+    }
+}

package/dist/quote/depth/index.d.ts

@@ -0,0 +1,24 @@
+import { QuoteDepthOutput } from '@clonegod/ttd-core';
+import { DepthTick } from './clmm_depth_calculator';
+export { calculateClmmDepth, priceFromSqrtX64, computeTargetSqrtX64, bigIntSqrt } from './clmm_depth_calculator';
+export type { DepthTick, ClmmDepthInput, DepthResult } from './clmm_depth_calculator';
+export interface BuildClmmDepthInput {
+    poolInfo: {
+        pool_name: string;
+        tokenA: any;
+        tokenB: any;
+        quote_token: string;
+    };
+    poolAddress: string;
+    poolState: {
+        currentSqrtPriceX64: bigint;
+        currentTick: number;
+        liquidity: bigint;
+        baseIsToken0: boolean;
+    };
+    ticks: DepthTick[];
+    basePriceUsd: number;
+    quotePriceUsd: number;
+    feeRateBps: number;
+}
+export declare function buildClmmDepth(input: BuildClmmDepthInput): QuoteDepthOutput | undefined;

package/dist/quote/depth/index.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigIntSqrt = exports.computeTargetSqrtX64 = exports.priceFromSqrtX64 = exports.calculateClmmDepth = void 0;
+exports.buildClmmDepth = buildClmmDepth;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const ttd_core_2 = require("@clonegod/ttd-core");
+const trade_direction_1 = require("../../utils/trade_direction");
+const clmm_depth_calculator_1 = require("./clmm_depth_calculator");
+var clmm_depth_calculator_2 = require("./clmm_depth_calculator");
+Object.defineProperty(exports, "calculateClmmDepth", { enumerable: true, get: function () { return clmm_depth_calculator_2.calculateClmmDepth; } });
+Object.defineProperty(exports, "priceFromSqrtX64", { enumerable: true, get: function () { return clmm_depth_calculator_2.priceFromSqrtX64; } });
+Object.defineProperty(exports, "computeTargetSqrtX64", { enumerable: true, get: function () { return clmm_depth_calculator_2.computeTargetSqrtX64; } });
+Object.defineProperty(exports, "bigIntSqrt", { enumerable: true, get: function () { return clmm_depth_calculator_2.bigIntSqrt; } });
+let _depthPctLogged = false;
+function logDepthLevelsOnce() {
+    if (_depthPctLogged)
+        return;
+    _depthPctLogged = true;
+    (0, ttd_core_1.log_info)(`[Depth] pctLevels=${JSON.stringify((0, ttd_core_2.getDepthPricePctLevels)())}, default=${ttd_core_2.DEFAULT_TIER_PCT}`);
+}
+function grossUpFee(amountInNet, feeRateBps) {
+    if (feeRateBps <= 0 || amountInNet <= 0)
+        return { amountInGross: amountInNet, feeAmount: 0 };
+    const feeRatio = feeRateBps / 10000;
+    const amountInGross = amountInNet / (1 - feeRatio);
+    return { amountInGross, feeAmount: amountInGross - amountInNet };
+}
+function assembleEntry(tiers) {
+    const def = tiers.find(t => t.pct === ttd_core_2.DEFAULT_TIER_PCT) ?? tiers[0];
+    return {
+        price: def.price, amount: def.amount, amount_in: def.amount_in, amount_in_usd: def.amount_in_usd,
+        fee: def.fee, fee_usd: def.fee_usd, tick_move: def.tick_move, tiers,
+    };
+}
+function buildClmmDepth(input) {
+    logDepthLevelsOnce();
+    const pctLevels = (0, ttd_core_2.getDepthPricePctLevels)();
+    if (pctLevels.length === 0)
+        return undefined;
+    const { poolInfo, poolState, ticks, basePriceUsd, quotePriceUsd, feeRateBps } = input;
+    if (poolState.liquidity <= 0n)
+        return undefined;
+    if (feeRateBps == null || feeRateBps < 0) {
+        (0, ttd_core_1.log_debug)(`[Depth] ${poolInfo.pool_name} CLMM: invalid feeRateBps=${feeRateBps}, skip`, '');
+        return undefined;
+    }
+    try {
+        const dir = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const baseToken = dir.baseToken;
+        const quoteToken = dir.quoteToken;
+        const baseIsToken0 = poolState.baseIsToken0;
+        const askZeroForOne = !baseIsToken0;
+        const bidZeroForOne = baseIsToken0;
+        const midPrice = (0, clmm_depth_calculator_1.priceFromSqrtX64)(poolState.currentSqrtPriceX64, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+        const askTiers = [];
+        const bidTiers = [];
+        for (const pct of pctLevels) {
+            const bps = Math.round(pct * 100);
+            const askResult = (0, clmm_depth_calculator_1.calculateClmmDepth)({
+                sqrtPriceX64: poolState.currentSqrtPriceX64, currentTick: poolState.currentTick,
+                liquidity: poolState.liquidity, ticks, zeroForOne: askZeroForOne, targetBps: bps,
+                inputDecimals: quoteToken.decimals, outputDecimals: baseToken.decimals,
+            });
+            const bidResult = (0, clmm_depth_calculator_1.calculateClmmDepth)({
+                sqrtPriceX64: poolState.currentSqrtPriceX64, currentTick: poolState.currentTick,
+                liquidity: poolState.liquidity, ticks, zeroForOne: bidZeroForOne, targetBps: bps,
+                inputDecimals: baseToken.decimals, outputDecimals: quoteToken.decimals,
+            });
+            const askTargetPrice = (0, clmm_depth_calculator_1.priceFromSqrtX64)(askResult.targetSqrtPriceX64, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+            const bidTargetPrice = (0, clmm_depth_calculator_1.priceFromSqrtX64)(bidResult.targetSqrtPriceX64, baseToken.decimals, quoteToken.decimals, baseIsToken0);
+            const askGross = grossUpFee(askResult.amountIn, feeRateBps);
+            const bidGross = grossUpFee(bidResult.amountIn, feeRateBps);
+            const askTickMove = `${askResult.targetTick} <- ${askResult.currentTick}`;
+            const bidTickMove = `${bidResult.currentTick} -> ${bidResult.targetTick}`;
+            const askEffPrice = askResult.amountOut > 0 ? askGross.amountInGross / askResult.amountOut : askTargetPrice;
+            const bidEffPrice = bidGross.amountInGross > 0 ? bidResult.amountOut / bidGross.amountInGross : bidTargetPrice;
+            askTiers.push({
+                pct, price: askEffPrice, amount: askResult.amountOut,
+                amount_in: askGross.amountInGross, amount_in_usd: askGross.amountInGross * quotePriceUsd,
+                fee: askGross.feeAmount, fee_usd: askGross.feeAmount * quotePriceUsd, tick_move: askTickMove,
+            });
+            bidTiers.push({
+                pct, price: bidEffPrice, amount: bidResult.amountOut,
+                amount_in: bidGross.amountInGross, amount_in_usd: bidGross.amountInGross * basePriceUsd,
+                fee: bidGross.feeAmount, fee_usd: bidGross.feeAmount * basePriceUsd, tick_move: bidTickMove,
+            });
+        }
+        return {
+            mid_price: midPrice,
+            fee_rate_bps: feeRateBps,
+            ask: assembleEntry(askTiers),
+            bid: assembleEntry(bidTiers),
+        };
+    }
+    catch (error) {
+        (0, ttd_core_1.log_debug)(`[Depth] ${poolInfo.pool_name} CLMM depth failed: ${error.message}`, '');
+        return undefined;
+    }
+}

package/dist/quote/index.d.ts

@@ -5,4 +5,5 @@ export * from './quote_trace';
 export * from './quote_amount';
 export * from './verify';
 export * from './tick';
+export * from './depth';
 export * from './abstract_dex_quote';

package/dist/quote/index.js

@@ -21,4 +21,5 @@ __exportStar(require("./quote_trace"), exports);
 __exportStar(require("./quote_amount"), exports);
 __exportStar(require("./verify"), exports);
 __exportStar(require("./tick"), exports);
+__exportStar(require("./depth"), exports);
 __exportStar(require("./abstract_dex_quote"), exports);

package/dist/trade/abstract_sui_dex_trade.js

@@ -46,7 +46,7 @@ class AbstractSuiDexTrade extends dist_1.AbastrcatTrade {
             try {
                 const msg = JSON.parse(message);
                 if (msg.digest)
-                    this.appConfig.emit(`SUI_TX_RESULT_${msg.digest}`, msg.digest);
+                    this.appConfig.emit(`SUI_TX_RESULT_${msg.digest}`, msg.receipt ?? msg.digest);
             }
             catch (e) {
                 (0, dist_1.log_warn)(`[trade] bad tx result msg`, message);

package/dist/trade/check/tx_result_checker.d.ts

@@ -10,5 +10,6 @@ export declare class TransactionResultChecker extends AbstractTransactionResultC
     private isValidTransactionResult;
     check_tx_result_interval(): Promise<void>;
     on_subscibe_transaction(): void;
+    private ensureCheckpoint;
     private processTransactionResult;
 }

package/dist/trade/check/tx_result_checker.js

@@ -59,6 +59,7 @@ class TransactionResultChecker extends trade_1.AbstractTransactionResultCheck {
         this.event_emitter.once(`SUI_TX_RESULT_${this.txid}`, async (response) => {
             (0, dist_1.log_info)(`receive tx result notification, txid=${this.txid}`);
             if (response.transaction) {
+                await this.ensureCheckpoint(response);
                 this.processTransactionResult(response, 'grpc');
                 return;
             }
@@ -86,6 +87,25 @@ class TransactionResultChecker extends trade_1.AbstractTransactionResultCheck {
             }
         });
     }
+    async ensureCheckpoint(receipt) {
+        if (receipt.transaction?.checkpoint)
+            return;
+        for (let i = 0; i < 10; i++) {
+            try {
+                const r = await this.leadgerService.getTransaction(this.txid, ['checkpoint', 'timestamp']);
+                const t = r?.transaction;
+                if (t?.checkpoint) {
+                    receipt.transaction.checkpoint = t.checkpoint;
+                    if (t.timestamp)
+                        receipt.transaction.timestamp = t.timestamp;
+                    return;
+                }
+            }
+            catch { }
+            await (0, dist_1.sleep)(200);
+        }
+        (0, dist_1.log_warn)(`ensureCheckpoint: 补查超窗仍无 checkpoint 号, txid=${this.txid}（block_number 将为 0）`);
+    }
     async processTransactionResult(txReceipt, source) {
         if (this.trade_result_already_processed) {
             (0, dist_1.log_warn)(`trade_result_already_processed=${this.trade_result_already_processed}, ignore trade result fetch by ${source} check!`);

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

@@ -30,7 +30,11 @@ export interface CentralExecutorOptions {
         digest: string;
         success: boolean;
         error?: string;
+        receipt?: {
+            transaction: any;
+        };
     }) => void;
+    tradeCoinTypes?: () => Promise<string[]>;
 }
 type TxResponse = SuiClientTypes.Transaction<{
     effects: true;
@@ -46,12 +50,20 @@ export declare class CentralExecutor {
     private tradeWallets;
     private sharedRefCache;
     private seq;
+    private readonly tradeCoinTypesProvider?;
     constructor(core: ExecutorCore, opts?: CentralExecutorOptions);
     init(): Promise<void>;
-    reconcileCoins(wallet: string, coinType: string): Promise<void>;
+    reconcileCoins(wallet: string, coinType: string, quietIfUnchanged?: boolean): Promise<void>;
     rebalanceWalletFunds(): Promise<void>;
     private rebalanceOne;
+    private decimalsCache;
+    private objectReader?;
+    private getCoinDecimalsCached;
+    private maintainCoinObjects;
     private execMaintenance;
+    private poolGenericsCache;
+    private getPoolGenerics;
+    private canonicalizeReq;
     private getSharedRefCached;
     private chainIdentifier;
     private epochCache;
@@ -64,8 +76,11 @@ export declare class CentralExecutor {
     private registerShared;
     submitSwap(req: SwapExecRequest): Promise<SwapSubmitResult>;
     private broadcastAndCommit;
+    private toCheckerReceipt;
     private reconcileAfterFailure;
     simulateSwap(req: SwapExecRequest): Promise<TxResponse>;
+    private minSplitFor;
+    private postTradeRebalance;
     private buildSwapTx;
     private onSuccess;
     get coinCache(): InProcessCoinCache;

package/dist/trade/executor/central_executor.js

@@ -2,12 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CentralExecutor = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
+const grpc_connection_1 = require("../../grpc/grpc-connection");
+const sui_object_reader_1 = require("../../grpc/sui_object_reader");
+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 effects_1 = require("./effects");
 const swap_1 = require("../swap");
 const constants_1 = require("../../constants");
+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;
+}
 class CentralExecutor {
     constructor(core, opts = {}) {
         this.core = core;
@@ -15,11 +38,14 @@ class CentralExecutor {
         this.tradeWallets = new Map();
         this.sharedRefCache = new Map();
         this.seq = 0;
+        this.decimalsCache = new Map();
+        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.onBroadcastResult = opts.onBroadcastResult;
+        this.tradeCoinTypesProvider = opts.tradeCoinTypes;
     }
     async init() {
         const tradeIds = (process.env.SUI_WALLET_GROUP_IDS || '').split(',').map(s => s.trim()).filter(Boolean);
@@ -34,18 +60,22 @@ class CentralExecutor {
         }
         (0, dist_1.log_info)(`[executor] init: trade=${[...this.tradeWallets.keys()].join(',')} (单钱包模式: gas=各自地址余额), gasBudget=${this.gasBudget}`);
     }
-    async reconcileCoins(wallet, coinType) {
+    async reconcileCoins(wallet, coinType, quietIfUnchanged = false) {
         try {
-            const refs = [];
-            let cursor = undefined;
-            do {
-                const page = await this.core.listCoins({ owner: wallet, coinType, cursor });
-                for (const c of page.objects) {
-                    refs.push({ objectId: c.objectId, version: c.version, digest: c.digest, balance: c.balance });
-                }
-                cursor = page.hasNextPage ? page.cursor : null;
-            } while (cursor);
-            this.cache.reconcile(wallet, coinType, refs);
+            for (let attempt = 0; attempt < 2; attempt++) {
+                const epoch = this.cache.mutationEpoch(wallet, coinType);
+                const refs = [];
+                let cursor = undefined;
+                do {
+                    const page = await this.core.listCoins({ owner: wallet, coinType, cursor });
+                    for (const c of page.objects) {
+                        refs.push({ objectId: c.objectId, version: c.version, digest: c.digest, balance: c.balance });
+                    }
+                    cursor = page.hasNextPage ? page.cursor : null;
+                } while (cursor);
+                if (this.cache.reconcile(wallet, coinType, refs, epoch, quietIfUnchanged))
+                    return;
+            }
         }
         catch (e) {
             (0, dist_1.log_error)(`[executor] reconcileCoins 失败 ${wallet} ${coinType}`, e);
@@ -66,11 +96,10 @@ class CentralExecutor {
         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 || 8);
-        const minSplit = BigInt(process.env.SUI_INPUT_COIN_MIN_SPLIT || '100000000');
+        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);
+        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' });
@@ -87,8 +116,7 @@ class CentralExecutor {
             const tx = new transactions_1.Transaction();
             tx.setSender(addr);
             const [dep] = tx.splitCoins(tx.gas, [tx.pure.u64(need)]);
-            const bal = tx.moveCall({ target: '0x2::coin::into_balance', typeArguments: ['0x2::sui::SUI'], arguments: [dep] });
-            tx.moveCall({ target: '0x2::balance::send_funds', typeArguments: ['0x2::sui::SUI'], arguments: [bal, tx.pure.address(addr)] });
+            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;
@@ -106,42 +134,136 @@ class CentralExecutor {
             await this.execMaintenance(tx, addr, kp, budget, `redeem 超额 ${excess} → coin`, rawClient);
             return;
         }
-        if (coins.length > 0 && coins.length < coinTarget && BigInt(coins[0].balance) >= minSplit * 2n) {
-            const big = coins[0];
-            const half = BigInt(big.balance) / 2n;
-            const tx = new transactions_1.Transaction();
-            tx.setSender(addr);
-            const c = tx.object(transactions_1.Inputs.ObjectRef(big));
-            const [piece] = tx.splitCoins(c, [tx.pure.u64(half)]);
-            tx.transferObjects([piece], tx.pure.address(addr));
-            tx.setGasPayment([]);
-            tx.setExpiration(await this.getValidDuringExpiration());
-            await this.execMaintenance(tx, addr, kp, budget, `split ${big.objectId.slice(0, 10)}… 对半（${coins.length}→${coins.length + 1} 个）`);
-            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}`);
+            }
         }
-        if (coins.length > coinMax) {
-            const primary = coins[0];
-            const toMerge = coins.slice(coinTarget);
-            const tx = new transactions_1.Transaction();
-            tx.setSender(addr);
-            const primaryArg = tx.object(transactions_1.Inputs.ObjectRef(primary));
-            tx.mergeCoins(primaryArg, toMerge.map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
-            tx.setGasPayment([]);
-            tx.setExpiration(await this.getValidDuringExpiration());
-            await this.execMaintenance(tx, addr, kp, budget, `merge ${toMerge.length} 个碎片（${coins.length}→${coinTarget + 1} 个）`);
-            return;
+        const types = [SUI, ...new Set(tradeTypes.filter(t => t !== SUI))];
+        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);
+            }
+            catch (e) {
+                (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)
+                return;
         }
     }
-    async execMaintenance(tx, addr, kp, budget, label, buildClient) {
-        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 : ''}`);
-        await this.reconcileCoins(addr, constants_1.SUI_TOKEN_ADDRESS.LONG);
+    async getCoinDecimalsCached(coinType) {
+        let d = this.decimalsCache.get(coinType);
+        if (d == null) {
+            if (!this.objectReader) {
+                const { grpc_endpoint, grpc_token } = (0, dist_1.getCoreEnv)();
+                if (!grpc_endpoint)
+                    throw new Error('GRPC_ENDPOINT 未配置（读 CoinMetadata decimals 需要）');
+                this.objectReader = new sui_object_reader_1.SuiObjectReader(grpc_connection_1.GrpcConnection.getInstance(grpc_endpoint, grpc_token));
+            }
+            d = await this.objectReader.getCoinDecimals(coinType);
+            this.decimalsCache.set(coinType, d);
+        }
+        return d;
+    }
+    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))));
+        if (pieces > 1) {
+            const per = total / BigInt(pieces);
+            const splits = tx.splitCoins(primary, Array.from({ length: pieces - 1 }, () => tx.pure.u64(per)));
+            tx.transferObjects(Array.from({ length: pieces - 1 }, (_, i) => splits[i]), tx.pure.address(addr));
+        }
+        tx.setGasPayment([]);
+        tx.setExpiration(await this.getValidDuringExpiration());
+        await this.execMaintenance(tx, addr, kp, opts.budget, `整理 ${short}：${valued.length} 值 + ${zeros.length} 壳 → ${pieces} 份均分（每份≈${(total / BigInt(pieces)).toString()}）`, undefined, coinType, tag);
+        return true;
+    }
+    async execMaintenance(tx, addr, kp, budget, label, buildClient, coinType = constants_1.SUI_TOKEN_ADDRESS.LONG, reserveTag) {
+        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 : ''}`);
+        }
+        finally {
+            if (reserveTag)
+                this.cache.abort(reserveTag, true);
+            await this.reconcileCoins(addr, coinType);
+        }
+    }
+    async getPoolGenerics(poolId) {
+        const hit = this.poolGenericsCache.get(poolId);
+        if (hit !== undefined)
+            return hit;
+        const res = await this.core.getObjects({ objectIds: [poolId] });
+        const obj = res.objects[0];
+        if (obj instanceof Error)
+            throw new Error(`[executor] getObjects(${poolId}) 失败: ${obj.message}`);
+        const t = obj.type ?? obj.objectType;
+        let out = null;
+        const m = t?.match(/<(.+)>$/);
+        if (m) {
+            const parts = splitTopLevelGenerics(m[1]);
+            if (parts.length === 2) {
+                out = { typeA: (0, format_1.normalizeSuiTokenAddress)(parts[0]), typeB: (0, format_1.normalizeSuiTokenAddress)(parts[1]) };
+            }
+        }
+        this.poolGenericsCache.set(poolId, out);
+        return out;
+    }
+    async canonicalizeReq(req) {
+        const g = await this.getPoolGenerics(req.poolId);
+        if (!g)
+            return req;
+        const a = (0, format_1.normalizeSuiTokenAddress)(req.coinTypeA);
+        const b = (0, format_1.normalizeSuiTokenAddress)(req.coinTypeB);
+        if (a === g.typeA && b === g.typeB)
+            return req;
+        if (a === g.typeB && b === g.typeA) {
+            if (req.sqrtPriceLimit !== 0n)
+                throw new Error(`[executor] pool ${req.poolId} token 序翻转时不支持显式 sqrtPriceLimit`);
+            (0, dist_1.log_info)(`[executor] pool ${req.poolId.slice(0, 10)}… 配置 token 序与链上相反，已翻转（a2b ${req.a2b}→${!req.a2b}）`);
+            return { ...req, coinTypeA: b, coinTypeB: a, a2b: !req.a2b };
+        }
+        throw new Error(`[executor] pool token 与链上不符: 链上 <${g.typeA}, ${g.typeB}> vs 请求 <${a}, ${b}>（配置可能指错池子）`);
     }
     async getSharedRefCached(objectId) {
         let isv = this.sharedRefCache.get(objectId);
@@ -160,7 +282,13 @@ class CentralExecutor {
     }
     async getValidDuringExpiration() {
         if (!this.chainIdentifier) {
-            this.chainIdentifier = (await this.core.getChainIdentifier()).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}`);
+            }
         }
         const now = Date.now();
         if (!this.epochCache || now - this.epochCache.ts > 300_000) {
@@ -208,16 +336,30 @@ class CentralExecutor {
         tx.object(transactions_1.Inputs.SharedObjectRef({ objectId, initialSharedVersion, mutable }));
     }
     async submitSwap(req) {
+        const t0 = Date.now();
+        req = await this.canonicalizeReq(req);
         const inType = this.inputCoinType(req);
-        const wallet = this.chooseTradeWallet(req, inType, req.amountIn);
+        let wallet;
+        try {
+            wallet = this.chooseTradeWallet(req, inType, req.amountIn);
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[executor] ${inType} 选钱包失败（${e.message}），按需 reconcile 后重试`);
+            await Promise.all([...this.tradeWallets.keys()].map(w => this.reconcileCoins(w, inType)));
+            wallet = this.chooseTradeWallet(req, inType, req.amountIn);
+        }
         const inputTag = this.nextTag('in');
         const inputRes = this.cache.acquire(wallet, inType, req.amountIn, inputTag);
+        const tAcquire = Date.now();
+        (0, dist_1.log_info)(`[executor] coin 已占用 wallet=${wallet.slice(0, 10)}… ${inputRes.coins.length} 个 ${inType.split('::').pop()} (选钱包+占币 ${tAcquire - t0}ms)`);
         try {
             const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
+            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, inType, this.outputCoinType(req), inputRes.coins, inputTag);
-            (0, dist_1.log_info)(`[executor] swap 已签提交 digest=${digest} dex=${req.dexId} ${req.a2b ? 'a2b' : 'b2a'} in=${req.amountIn}`);
+            (0, dist_1.log_info)(`[executor] swap 已签提交 digest=${digest} dex=${req.dexId} ${req.a2b ? 'a2b' : 'b2a'} in=${req.amountIn} cost={build:${tBuild - tAcquire}ms, sign+digest:${tSign - tBuild}ms, total:${tSign - t0}ms}`);
             return { digest, submitted: true };
         }
         catch (e) {
@@ -227,6 +369,7 @@ class CentralExecutor {
         }
     }
     async broadcastAndCommit(txBytes, signatures, digest, wallet, inType, outType, inputCoins, inputTag) {
+        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;
@@ -241,25 +384,50 @@ class CentralExecutor {
             if (!success) {
                 this.cache.abort(inputTag, true);
                 this.reconcileAfterFailure(wallet, inType, outType);
-                (0, dist_1.log_warn)(`[executor] swap 链上失败 digest=${digest} err=${error}`);
-                this.onBroadcastResult?.({ digest, success: false, error });
+                (0, dist_1.log_warn)(`[executor] swap 链上失败 digest=${digest} err=${error} broadcast=${Date.now() - tBroadcast}ms`);
+                this.onBroadcastResult?.({ digest, success: false, error, receipt: this.toCheckerReceipt(tr, digest) });
                 return;
             }
             await this.onSuccess(tr, wallet, inType, outType, inputCoins, inputTag);
-            (0, dist_1.log_info)(`[executor] swap quorum-executed 确认 digest=${digest}`);
-            this.onBroadcastResult?.({ digest, success: true });
+            (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);
             this.reconcileAfterFailure(wallet, inType, outType);
-            (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest}`, e);
+            (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest} broadcast=${Date.now() - tBroadcast}ms`, e);
         }
     }
+    toCheckerReceipt(tr, digest) {
+        const eff = tr.effects;
+        const status = eff?.status?.success
+            ? { success: true }
+            : { success: false, error: { kind: eff?.status?.error?.message ?? JSON.stringify(eff?.status?.error ?? 'unknown') } };
+        const g = eff?.gasUsed ?? {};
+        return {
+            transaction: {
+                digest,
+                effects: {
+                    status,
+                    gas_used: {
+                        computation_cost: g.computationCost,
+                        storage_cost: g.storageCost,
+                        storage_rebate: g.storageRebate,
+                        non_refundable_storage_fee: g.nonRefundableStorageFee,
+                    },
+                },
+                balance_changes: (tr.balanceChanges ?? []).map((b) => ({
+                    address: b.address, coin_type: b.coinType, amount: b.amount,
+                })),
+            },
+        };
+    }
     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);
@@ -282,6 +450,32 @@ class CentralExecutor {
         }
         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) {
         const tx = new transactions_1.Transaction();
         tx.setSender(wallet);
@@ -314,8 +508,7 @@ class CentralExecutor {
         const tradeChanges = (0, effects_1.extractCoinChangesFromCore)(tr.effects, objectTypes, { owners: new Set([wallet]), coinTypeById });
         this.cache.commit(inputTag, tradeChanges);
         if (this.reconcileAfterTx) {
-            for (const t of new Set([inType, outType, constants_1.SUI_TOKEN_ADDRESS.LONG]))
-                void this.reconcileCoins(wallet, t);
+            void this.postTradeRebalance(wallet, inType, outType);
         }
     }
     get coinCache() { return this.cache; }

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

@@ -2,16 +2,22 @@ import { CoinRef, CoinReservation, CoinObjectChange } from '../coin/types';
 export declare class InProcessCoinCache {
     private available;
     private inflight;
+    private epochs;
+    private epochKey;
+    private bumpEpoch;
+    mutationEpoch(wallet: string, coinType: string): number;
     private walletMap;
     private list;
     private sortDesc;
     seed(wallet: string, coinType: string, coins: CoinRef[]): void;
-    reconcile(wallet: string, coinType: string, freshCoins: 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;
+    reserve(wallet: string, coinType: string, objectIds: string[], txTag: string): CoinRef[] | null;
     hasInflight(wallet: string, coinType: string): boolean;
     commit(txTag: string, changes: CoinObjectChange[]): void;
     abort(txTag: string, consumed: boolean): void;
     private removeEverywhere;
+    coinTypes(wallet: string): string[];
     snapshot(wallet: string, coinType: string): {
         count: number;
         total: bigint;

package/dist/trade/executor/coin_cache.js

@@ -6,6 +6,15 @@ class InProcessCoinCache {
     constructor() {
         this.available = new Map();
         this.inflight = new Map();
+        this.epochs = new Map();
+    }
+    epochKey(wallet, coinType) { return `${wallet}|${coinType}`; }
+    bumpEpoch(wallet, coinType) {
+        const k = this.epochKey(wallet, coinType);
+        this.epochs.set(k, (this.epochs.get(k) || 0) + 1);
+    }
+    mutationEpoch(wallet, coinType) {
+        return this.epochs.get(this.epochKey(wallet, coinType)) || 0;
     }
     walletMap(wallet) {
         let m = this.available.get(wallet);
@@ -31,9 +40,14 @@ class InProcessCoinCache {
         const l = coins.slice();
         this.sortDesc(l);
         this.walletMap(wallet).set(coinType, l);
+        this.bumpEpoch(wallet, coinType);
         (0, dist_1.log_info)(`[coin-cache] seed ${wallet} ${coinType}: ${l.length} coins`);
     }
-    reconcile(wallet, coinType, freshCoins) {
+    reconcile(wallet, coinType, freshCoins, epochAtStart, quietIfUnchanged = false) {
+        if (epochAtStart != null && this.mutationEpoch(wallet, coinType) !== epochAtStart) {
+            (0, dist_1.log_info)(`[coin-cache] reconcile ${wallet} ${coinType}: 快照在途期间缓存已变更，丢弃（防旧覆盖新）`);
+            return false;
+        }
         const inflightIds = new Set();
         for (const r of this.inflight.values()) {
             if (r.wallet === wallet && r.coinType === coinType)
@@ -41,8 +55,15 @@ class InProcessCoinCache {
         }
         const kept = freshCoins.filter(c => !inflightIds.has(c.objectId));
         this.sortDesc(kept);
+        const sig = (l) => l.map(c => `${c.objectId}@${c.version}:${c.balance}`).join(',');
+        const unchanged = sig(kept) === sig(this.list(wallet, coinType));
         this.walletMap(wallet).set(coinType, kept);
-        (0, dist_1.log_info)(`[coin-cache] reconcile ${wallet} ${coinType}: ${kept.length} avail (${inflightIds.size} inflight kept)`);
+        const msg = `[coin-cache] reconcile ${wallet} ${coinType}: ${kept.length} avail (${inflightIds.size} inflight kept)`;
+        if (unchanged && quietIfUnchanged)
+            (0, dist_1.log_debug)(msg);
+        else
+            (0, dist_1.log_info)(msg);
+        return true;
     }
     acquire(wallet, coinType, amount, txTag, maxCoins = 8) {
         if (this.inflight.has(txTag))
@@ -65,8 +86,22 @@ class InProcessCoinCache {
         const pickedIds = new Set(picked.map(c => c.objectId));
         this.walletMap(wallet).set(coinType, l.filter(c => !pickedIds.has(c.objectId)));
         this.inflight.set(txTag, { wallet, coinType, coins: picked, gas: false });
+        this.bumpEpoch(wallet, coinType);
         return { txTag, coinType, coins: picked };
     }
+    reserve(wallet, coinType, objectIds, txTag) {
+        if (this.inflight.has(txTag))
+            throw new Error(`[coin-cache] txTag 重复: ${txTag}`);
+        const l = this.list(wallet, coinType);
+        const ids = new Set(objectIds);
+        const picked = l.filter(c => ids.has(c.objectId));
+        if (picked.length !== ids.size)
+            return null;
+        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;
+    }
     hasInflight(wallet, coinType) {
         for (const r of this.inflight.values()) {
             if (r.wallet === wallet && r.coinType === coinType)
@@ -81,6 +116,9 @@ class InProcessCoinCache {
             return;
         }
         this.inflight.delete(txTag);
+        this.bumpEpoch(res.wallet, res.coinType);
+        for (const ch of changes)
+            this.bumpEpoch(res.wallet, ch.coinType);
         for (const ch of changes) {
             const wallet = res.wallet;
             if (ch.kind === 'deleted') {
@@ -107,6 +145,7 @@ class InProcessCoinCache {
             return;
         }
         this.inflight.delete(txTag);
+        this.bumpEpoch(res.wallet, res.coinType);
         if (consumed) {
             (0, dist_1.log_warn)(`[coin-cache] abort consumed txTag=${txTag}（${res.coins.length} coin 交 reconcile 兜底）`);
             return;
@@ -123,6 +162,9 @@ class InProcessCoinCache {
         if (idx >= 0)
             l.splice(idx, 1);
     }
+    coinTypes(wallet) {
+        return [...this.walletMap(wallet).keys()];
+    }
     snapshot(wallet, coinType) {
         const l = this.list(wallet, coinType);
         const total = l.reduce((s, c) => s + BigInt(c.balance), 0n);

package/dist/trade/executor/core_channel.js

@@ -21,6 +21,9 @@ const GRPC_CLIENT_OPTIONS = {
     'grpc.max_send_message_length': 8 * 1024 * 1024,
     'grpc.initial_reconnect_backoff_ms': 1000,
     'grpc.max_reconnect_backoff_ms': 30000,
+    'grpc-node.flow_control_window': 8 * 1024 * 1024,
+    'grpc-node.max_session_memory': 64,
+    'grpc.default_compression_algorithm': 2,
 };
 function buildGrpcCore(opts = {}) {
     const endpoint = opts.endpoint ?? (0, dist_1.getCoreEnv)().grpc_endpoint;

package/dist/trade/parse/sui_tx_parser.js

@@ -39,10 +39,18 @@ class SuiTransactionParser {
         let tokenBChangeAmount = new decimal_js_1.default(0);
         const balanceChanges = tx_receipt.transaction?.balance_changes || [];
         (0, dist_1.log_info)('balance_changes', { txid, balance_changes: balanceChanges });
+        const g = tx_receipt.transaction?.effects?.gas_used;
+        const gasNetMist = g
+            ? new decimal_js_1.default(g.computation_cost || 0).plus(g.storage_cost || 0).minus(g.storage_rebate || 0)
+            : new decimal_js_1.default(0);
+        const SUI_LONG = (0, index_1.normalizeSuiTokenAddress)('0x2::sui::SUI');
         for (const change of balanceChanges) {
-            const amount = new decimal_js_1.default(change.amount);
+            let amount = new decimal_js_1.default(change.amount);
             const coinType = change.coin_type;
             const normalizedCoinType = (0, index_1.normalizeSuiTokenAddress)(coinType);
+            if (normalizedCoinType === SUI_LONG) {
+                amount = amount.plus(gasNetMist);
+            }
             const poolTokenAAddress = (0, index_1.normalizeSuiTokenAddress)(pool_info.tokenA.address);
             const poolTokenBAddress = (0, index_1.normalizeSuiTokenAddress)(pool_info.tokenB.address);
             if (normalizedCoinType === poolTokenAAddress) {
@@ -177,7 +185,7 @@ class SuiTransactionParser {
         return Date.now();
     }
     extractCheckpoint(receipt) {
-        return parseInt(receipt.checkpoint || '0');
+        return parseInt(receipt.transaction?.checkpoint || receipt.checkpoint || '0');
     }
 }
 exports.SuiTransactionParser = SuiTransactionParser;

package/dist/trade/tx_result_channel.d.ts

@@ -4,4 +4,7 @@ export interface SuiTxResultMsg {
     success?: boolean;
     error?: string;
     source?: 'executor' | 'stream-trade';
+    receipt?: {
+        transaction: any;
+    };
 }

package/package.json

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