@clonegod/ttd-sui-common 2.0.2 → 2.0.4

package/dist/grpc/grpc-connection.js

@@ -51,6 +51,23 @@ class GrpcConnection {
         }
         return GrpcConnection.instance;
     }
+    static { this.CHANNEL_OPTIONS = {
+        'grpc.keepalive_time_ms': 60000,
+        'grpc.keepalive_timeout_ms': 10000,
+        'grpc.keepalive_permit_without_calls': 0,
+        'grpc.http2.max_pings_without_data': 0,
+        'grpc.http2.min_time_between_pings_ms': 60000,
+        'grpc.http2.min_ping_interval_without_data_ms': 60000,
+        'grpc.max_receive_message_length': 4 * 1024 * 1024,
+        'grpc.max_send_message_length': 4 * 1024 * 1024,
+        'grpc.initial_reconnect_backoff_ms': 1000,
+        'grpc.max_reconnect_backoff_ms': 30000,
+        'grpc.enable_retries': 1,
+        'grpc.retry_buffer_size': 256 * 1024,
+        'grpc.http2.max_frame_size': 16384,
+        'grpc.http2.max_header_list_size': 16384,
+        'grpc.http2.initial_window_size': 65535,
+    }; }
     getChannel() {
         if (!this.channel) {
             this.channel = new grpc.Channel(this.endpoint, grpc.credentials.createSsl(), GrpcConnection.CHANNEL_OPTIONS);
@@ -91,20 +108,3 @@ class GrpcConnection {
     }
 }
 exports.GrpcConnection = GrpcConnection;
-GrpcConnection.CHANNEL_OPTIONS = {
-    'grpc.keepalive_time_ms': 60000,
-    'grpc.keepalive_timeout_ms': 10000,
-    'grpc.keepalive_permit_without_calls': 0,
-    'grpc.http2.max_pings_without_data': 0,
-    'grpc.http2.min_time_between_pings_ms': 60000,
-    'grpc.http2.min_ping_interval_without_data_ms': 60000,
-    'grpc.max_receive_message_length': 4 * 1024 * 1024,
-    'grpc.max_send_message_length': 4 * 1024 * 1024,
-    'grpc.initial_reconnect_backoff_ms': 1000,
-    'grpc.max_reconnect_backoff_ms': 30000,
-    'grpc.enable_retries': 1,
-    'grpc.retry_buffer_size': 256 * 1024,
-    'grpc.http2.max_frame_size': 16384,
-    'grpc.http2.max_header_list_size': 16384,
-    'grpc.http2.initial_window_size': 65535,
-};

package/dist/quote/pricing/token_price_cache.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenPriceCache = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
+const format_1 = require("../../utils/format");
 class TokenPriceCache {
     constructor() {
         this.tokenPriceCache = new Map();
@@ -12,6 +13,7 @@ class TokenPriceCache {
         let tokenParts = tokenAddress.split('::');
         tokenParts[0] = tokenParts[0].toLowerCase();
         tokenAddress = tokenParts.join('::');
+        tokenAddress = (0, format_1.normalizeSuiTokenAddress)(tokenAddress, false);
         const now = Date.now();
         const cachedData = this.tokenPriceCache.get(tokenAddress);
         if (cachedData && (now - cachedData.timestamp) < this.PRICE_CACHE_TIMEOUT_MILLS) {

package/dist/quote/quote_amount.js

@@ -7,6 +7,7 @@ exports.getQuoteAmountUsd = getQuoteAmountUsd;
 exports.usdToTokenUiAmount = usdToTokenUiAmount;
 const ttd_core_1 = require("@clonegod/ttd-core");
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const format_1 = require("../utils/format");
 function getQuoteAmountUsd(poolInfo) {
     const envValue = Number(process.env.QUOTE_AMOUNT_USD);
     if (envValue > 0) {
@@ -15,6 +16,7 @@ function getQuoteAmountUsd(poolInfo) {
     return poolInfo.quote_amount_usd;
 }
 async function usdToTokenUiAmount(amountInUsd, tokenAddress) {
+    tokenAddress = (0, format_1.normalizeSuiTokenAddress)(tokenAddress, false);
     const priceMap = await (0, ttd_core_1.get_sui_token_price_info)([tokenAddress]);
     const price = priceMap.get(tokenAddress)?.price;
     if (!price || price === '0') {

package/dist/trade/abstract_sui_dex_trade.d.ts

@@ -1,9 +1,8 @@
 import { QuoteResultType } from "@clonegod/ttd-core";
 import { AbastrcatTrade, AppConfig, CHAIN_ID, TradeContext } from "@clonegod/ttd-core/dist";
-import { SuiClient } from "@mysten/sui/client";
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { Transaction } from '@mysten/sui/transactions';
-import { PoolObjectInfo, SuiGrpcClient, SuiTxSender } from '../index';
+import { PoolObjectInfo, SuiGrpcClient } from '../index';
 import { SimpleRedisClient } from '../redis';
 import { ExecutorWsClient } from './executor';
 export declare abstract class AbstractSuiDexTrade extends AbastrcatTrade {
@@ -12,9 +11,7 @@ export declare abstract class AbstractSuiDexTrade extends AbastrcatTrade {
     protected group_wallets: Ed25519Keypair[];
     protected wallet: Ed25519Keypair;
     protected walletMode: 'single' | 'multi';
-    sui_client: SuiClient;
     grpcClient: SuiGrpcClient;
-    transactionSender: SuiTxSender;
     protected redisClient: SimpleRedisClient;
     protected executorClient: ExecutorWsClient;
     walletAddresses: string[];
@@ -22,7 +19,6 @@ export declare abstract class AbstractSuiDexTrade extends AbastrcatTrade {
     protected chainNameLower: string;
     constructor(appConfig: AppConfig, grpcClient: SuiGrpcClient);
     init(): Promise<void>;
-    private initSuiClient;
     protected getWalletMode(): 'single' | 'multi';
     protected getSingleWallet(): Ed25519Keypair;
     protected getGroupWallets(): Ed25519Keypair[];

package/dist/trade/abstract_sui_dex_trade.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractSuiDexTrade = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
-const client_1 = require("@mysten/sui/client");
 const ed25519_1 = require("@mysten/sui/keypairs/ed25519");
 const transactions_1 = require("@mysten/sui/transactions");
 const decimal_js_1 = __importDefault(require("decimal.js"));
@@ -25,7 +24,6 @@ class AbstractSuiDexTrade extends dist_1.AbastrcatTrade {
         this.redisClient = new redis_1.SimpleRedisClient(`${this.chainNameLower}:tx`);
     }
     async init() {
-        this.initSuiClient();
         await this.initConfigs();
         const walletGroupIds = process.env.SUI_WALLET_GROUP_IDS || process.env.WALLET_GROUP_IDS || '';
         this.walletMode = walletGroupIds && walletGroupIds.trim().split(',').length > 0 ? 'multi' : 'single';
@@ -42,7 +40,6 @@ class AbstractSuiDexTrade extends dist_1.AbastrcatTrade {
             this.walletAddresses = [this.currentWalletAddress];
             (0, dist_1.log_info)(`init wallet mode: single, walletAddress= ${this.currentWalletAddress}`);
         }
-        this.transactionSender = new index_1.SuiTxSender(this.appConfig, this.sui_client, this.grpcClient);
         this.executorClient = new executor_1.ExecutorWsClient();
         const txResultChannel = (0, tx_result_channel_1.get_sui_tx_result_channel)();
         this.appConfig.arb_cache.redis_cmd.subscribe(txResultChannel, (message) => {
@@ -56,11 +53,6 @@ class AbstractSuiDexTrade extends dist_1.AbastrcatTrade {
             }
         });
     }
-    initSuiClient() {
-        const sui_rpc_url = process.env.RPC_ENDPOINT || 'https://fullnode.mainnet.sui.io:443';
-        this.sui_client = new client_1.SuiClient({ url: sui_rpc_url });
-        (0, dist_1.log_info)(`init sui client, rpc_url: ${sui_rpc_url}`);
-    }
     getWalletMode() {
         return this.walletMode;
     }
@@ -246,7 +238,7 @@ class AbstractSuiDexTrade extends dist_1.AbastrcatTrade {
         const { aToB, amount: uiAmount, price: cex_order_price } = order_msg;
         let { inputToken, outputToken } = (0, dist_1.get_input_out_token)(pool_info, aToB);
         let amountIn = new decimal_js_1.default(uiAmount).mul(10 ** inputToken.decimals);
-        let slippage = slippage_bps / 10000;
+        let slippage = slippage_bps / 100_00;
         let price;
         let amountOut;
         let amountOutMin;

package/dist/trade/coin/types.d.ts

@@ -9,10 +9,6 @@ export interface CoinReservation {
     coinType: string;
     coins: CoinRef[];
 }
-export interface GasReservation {
-    txTag: string;
-    coin: CoinRef;
-}
 export interface CoinObjectChange {
     kind: 'mutated' | 'created' | 'deleted';
     objectId: string;

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

@@ -1,6 +1,5 @@
 import { DEX_ID } from '@clonegod/ttd-core/dist';
-import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
-import type { Experimental_SuiClientTypes } from '@mysten/sui/experimental';
+import type { SuiClientTypes } from '@mysten/sui/client';
 import { InProcessCoinCache } from './coin_cache';
 import { ExecutorCore } from './core_channel';
 export interface SwapExecRequest {
@@ -26,7 +25,6 @@ export interface SwapSubmitResult {
 }
 export interface CentralExecutorOptions {
     gasBudget?: bigint;
-    gasMinCoin?: bigint;
     reconcileAfterTx?: boolean;
     onBroadcastResult?: (r: {
         digest: string;
@@ -34,23 +32,30 @@ export interface CentralExecutorOptions {
         error?: string;
     }) => void;
 }
-type TxResponse = Experimental_SuiClientTypes.TransactionResponse;
+type TxResponse = SuiClientTypes.Transaction<{
+    effects: true;
+    objectTypes: true;
+    balanceChanges: true;
+}>;
 export declare class CentralExecutor {
     private readonly core;
     private readonly cache;
     private readonly gasBudget;
-    private readonly gasMinCoin;
     private readonly reconcileAfterTx;
     private readonly onBroadcastResult?;
-    private gasKeypair;
-    private gasAddress;
     private tradeWallets;
     private sharedRefCache;
     private seq;
     constructor(core: ExecutorCore, opts?: CentralExecutorOptions);
     init(): Promise<void>;
     reconcileCoins(wallet: string, coinType: string): Promise<void>;
+    rebalanceWalletFunds(): Promise<void>;
+    private rebalanceOne;
+    private execMaintenance;
     private getSharedRefCached;
+    private chainIdentifier;
+    private epochCache;
+    private getValidDuringExpiration;
     private getGasPrice;
     private nextTag;
     private inputCoinType;
@@ -64,8 +69,6 @@ export declare class CentralExecutor {
     private buildSwapTx;
     private onSuccess;
     get coinCache(): InProcessCoinCache;
-    get gasWalletAddress(): string;
-    get gasSigner(): Ed25519Keypair;
     get tradeWalletAddresses(): string[];
     get coreClient(): ExecutorCore;
 }

package/dist/trade/executor/central_executor.js

@@ -12,42 +12,36 @@ class CentralExecutor {
     constructor(core, opts = {}) {
         this.core = core;
         this.cache = new coin_cache_1.InProcessCoinCache();
-        this.gasAddress = '';
         this.tradeWallets = new Map();
         this.sharedRefCache = new Map();
         this.seq = 0;
+        this.chainIdentifier = '';
+        this.epochCache = null;
         this.gasBudget = opts.gasBudget ?? BigInt(process.env.SUI_GAS_BUDGET || '50000000');
-        this.gasMinCoin = opts.gasMinCoin ?? BigInt(process.env.SUI_GAS_MIN_COIN || this.gasBudget.toString());
         this.reconcileAfterTx = opts.reconcileAfterTx ?? true;
         this.onBroadcastResult = opts.onBroadcastResult;
     }
     async init() {
         const tradeIds = (process.env.SUI_WALLET_GROUP_IDS || '').split(',').map(s => s.trim()).filter(Boolean);
-        const gasIds = (process.env.SUI_GAS_WALLET_GROUP_IDS || '').split(',').map(s => s.trim()).filter(Boolean);
         if (!tradeIds.length)
             throw new Error('SUI_WALLET_GROUP_IDS 未配置（集中执行器需交易钱包）');
-        if (!gasIds.length)
-            throw new Error('SUI_GAS_WALLET_GROUP_IDS 未配置（集中执行器需 gas 赞助钱包）');
         for (const info of (0, dist_1.load_wallet_multi)(tradeIds, false)) {
             const kp = ed25519_1.Ed25519Keypair.fromSecretKey(info.private_key);
             this.tradeWallets.set(kp.getPublicKey().toSuiAddress(), kp);
         }
-        const gasInfos = (0, dist_1.load_wallet_multi)(gasIds, false);
-        if (!gasInfos.length)
-            throw new Error('gas 钱包加载为空');
-        this.gasKeypair = ed25519_1.Ed25519Keypair.fromSecretKey(gasInfos[0].private_key);
-        this.gasAddress = this.gasKeypair.getPublicKey().toSuiAddress();
-        await this.reconcileCoins(this.gasAddress, constants_1.SUI_TOKEN_ADDRESS.LONG);
-        (0, dist_1.log_info)(`[executor] init: trade=${[...this.tradeWallets.keys()].join(',')}, gas=${this.gasAddress}, gasBudget=${this.gasBudget}`);
+        for (const w of this.tradeWallets.keys()) {
+            await this.reconcileCoins(w, constants_1.SUI_TOKEN_ADDRESS.LONG);
+        }
+        (0, dist_1.log_info)(`[executor] init: trade=${[...this.tradeWallets.keys()].join(',')} (单钱包模式: gas=各自地址余额), gasBudget=${this.gasBudget}`);
     }
     async reconcileCoins(wallet, coinType) {
         try {
             const refs = [];
             let cursor = undefined;
             do {
-                const page = await this.core.getCoins({ address: wallet, coinType, cursor });
+                const page = await this.core.listCoins({ owner: wallet, coinType, cursor });
                 for (const c of page.objects) {
-                    refs.push({ objectId: c.id, version: c.version, digest: c.digest, balance: c.balance });
+                    refs.push({ objectId: c.objectId, version: c.version, digest: c.digest, balance: c.balance });
                 }
                 cursor = page.hasNextPage ? page.cursor : null;
             } while (cursor);
@@ -57,6 +51,98 @@ class CentralExecutor {
             (0, dist_1.log_error)(`[executor] reconcileCoins 失败 ${wallet} ${coinType}`, e);
         }
     }
+    async rebalanceWalletFunds() {
+        for (const [addr, kp] of this.tradeWallets) {
+            try {
+                await this.rebalanceOne(addr, kp);
+            }
+            catch (e) {
+                (0, dist_1.log_error)(`[executor] rebalance 失败 ${addr.slice(0, 10)}…`, e);
+            }
+        }
+    }
+    async rebalanceOne(addr, kp) {
+        const SUI = constants_1.SUI_TOKEN_ADDRESS.LONG;
+        const balanceMin = BigInt(process.env.SUI_GAS_BALANCE_MIN || '500000000');
+        const balanceTarget = BigInt(process.env.SUI_GAS_BALANCE_TARGET || (balanceMin * 2n).toString());
+        const coinTarget = Number(process.env.SUI_INPUT_COIN_TARGET || 3);
+        const coinMax = Number(process.env.SUI_INPUT_COIN_MAX || 8);
+        const minSplit = BigInt(process.env.SUI_INPUT_COIN_MIN_SPLIT || '100000000');
+        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);
+        if (this.cache.hasInflight(addr, SUI))
+            return;
+        const b = await this.core.getBalance({ owner: addr, coinType: '0x2::sui::SUI' });
+        const ab = BigInt(b.balance.addressBalance ?? '0');
+        const coins = this.cache.snapshot(addr, SUI).coins.slice()
+            .sort((x, y) => (BigInt(y.balance) > BigInt(x.balance) ? 1 : BigInt(y.balance) < BigInt(x.balance) ? -1 : 0));
+        if (ab < balanceMin) {
+            const need = balanceTarget - ab;
+            const src = coins.find(c => BigInt(c.balance) >= need + budget);
+            if (!src) {
+                (0, dist_1.log_warn)(`[executor] ${addr.slice(0, 10)}… 地址余额 ${ab} < min ${balanceMin} 且无足额 SUI coin 充值 —— 请注资（balance 转账即可）`);
+                return;
+            }
+            const tx = new transactions_1.Transaction();
+            tx.setSender(addr);
+            const [dep] = tx.splitCoins(tx.gas, [tx.pure.u64(need)]);
+            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.setGasPayment([{ objectId: src.objectId, version: src.version, digest: src.digest }]);
+            await this.execMaintenance(tx, addr, kp, budget, `deposit ${need} → balance`);
+            return;
+        }
+        if (ab > balanceTarget + chunk) {
+            const excess = ab - balanceTarget;
+            const rawClient = this.core.rawClient;
+            if (!rawClient)
+                return;
+            const tx = new transactions_1.Transaction();
+            tx.setSender(addr);
+            tx.transferObjects([(0, transactions_1.coinWithBalance)({ type: '0x2::sui::SUI', balance: excess, useGasCoin: false })], tx.pure.address(addr));
+            tx.setGasPayment([]);
+            tx.setExpiration(await this.getValidDuringExpiration());
+            await this.execMaintenance(tx, addr, kp, budget, `redeem 超额 ${excess} → coin`, rawClient);
+            return;
+        }
+        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;
+        }
+        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;
+        }
+    }
+    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 getSharedRefCached(objectId) {
         let isv = this.sharedRefCache.get(objectId);
         if (!isv) {
@@ -72,6 +158,26 @@ class CentralExecutor {
         }
         return isv;
     }
+    async getValidDuringExpiration() {
+        if (!this.chainIdentifier) {
+            this.chainIdentifier = (await this.core.getChainIdentifier()).chainIdentifier;
+        }
+        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 };
+        }
+        return { ValidDuring: {
+                minEpoch: String(this.epochCache.epoch),
+                maxEpoch: String(this.epochCache.epoch + 1n),
+                minTimestamp: null, maxTimestamp: null,
+                chain: this.chainIdentifier,
+                nonce: Math.floor(Math.random() * 0xFFFFFFFF),
+            } };
+    }
     async getGasPrice() {
         return BigInt((await this.core.getReferenceGasPrice()).referenceGasPrice);
     }
@@ -105,39 +211,27 @@ class CentralExecutor {
         const inType = this.inputCoinType(req);
         const wallet = this.chooseTradeWallet(req, inType, req.amountIn);
         const inputTag = this.nextTag('in');
-        const gasTag = this.nextTag('gas');
         const inputRes = this.cache.acquire(wallet, inType, req.amountIn, inputTag);
-        let gasRes;
         try {
-            gasRes = this.cache.acquireGas(this.gasAddress, constants_1.SUI_TOKEN_ADDRESS.LONG, this.gasMinCoin, gasTag);
-        }
-        catch (e) {
-            this.cache.abort(inputTag, false);
-            throw e;
-        }
-        try {
-            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins, gasRes.coin);
+            const { txBytes, tx } = await this.buildSwapTx(req, wallet, inputRes.coins);
             const { signature: senderSig } = await this.tradeWallets.get(wallet).signTransaction(txBytes);
-            const { signature: sponsorSig } = await this.gasKeypair.signTransaction(txBytes);
             const digest = await tx.getDigest();
-            void this.broadcastAndCommit(txBytes, [senderSig, sponsorSig], digest, wallet, inType, this.outputCoinType(req), inputRes.coins, gasRes.coin.objectId, inputTag, gasTag);
+            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}`);
             return { digest, submitted: true };
         }
         catch (e) {
             this.cache.abort(inputTag, false);
-            this.cache.abort(gasTag, false);
             (0, dist_1.log_error)(`[executor] submitSwap 失败 dex=${req.dexId}`, e);
             return { digest: '', submitted: false, error: e.message };
         }
     }
-    async broadcastAndCommit(txBytes, signatures, digest, wallet, inType, outType, inputCoins, gasCoinId, inputTag, gasTag) {
+    async broadcastAndCommit(txBytes, signatures, digest, wallet, inType, outType, inputCoins, inputTag) {
         try {
-            const resp = await this.core.executeTransaction({ transaction: txBytes, signatures });
-            const tr = resp.transaction;
+            const resp = await this.core.executeTransaction({ transaction: txBytes, signatures, include: { effects: true, objectTypes: true, balanceChanges: true } });
+            const tr = resp.Transaction;
             if (!tr?.effects) {
                 this.cache.abort(inputTag, true);
-                this.cache.abort(gasTag, true);
                 this.reconcileAfterFailure(wallet, inType, outType);
                 (0, dist_1.log_error)(`[executor] 响应缺 effects，无法更新 cache digest=${digest}`, new Error('missing effects'));
                 this.onBroadcastResult?.({ digest, success: false, error: 'missing effects' });
@@ -146,19 +240,17 @@ class CentralExecutor {
             const { success, error } = (0, effects_1.coreTxStatus)(tr.effects);
             if (!success) {
                 this.cache.abort(inputTag, true);
-                this.cache.abort(gasTag, true);
                 this.reconcileAfterFailure(wallet, inType, outType);
                 (0, dist_1.log_warn)(`[executor] swap 链上失败 digest=${digest} err=${error}`);
                 this.onBroadcastResult?.({ digest, success: false, error });
                 return;
             }
-            await this.onSuccess(tr, wallet, inType, outType, inputCoins, gasCoinId, inputTag, gasTag);
+            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 });
         }
         catch (e) {
             this.cache.abort(inputTag, true);
-            this.cache.abort(gasTag, true);
             this.reconcileAfterFailure(wallet, inType, outType);
             (0, dist_1.log_error)(`[executor] broadcast 失败 digest=${digest}`, e);
         }
@@ -166,7 +258,6 @@ class CentralExecutor {
     reconcileAfterFailure(wallet, inType, outType) {
         for (const t of new Set([inType, outType, constants_1.SUI_TOKEN_ADDRESS.LONG]))
             void this.reconcileCoins(wallet, t);
-        void this.reconcileCoins(this.gasAddress, constants_1.SUI_TOKEN_ADDRESS.LONG);
     }
     async simulateSwap(req) {
         const inType = this.inputCoinType(req);
@@ -184,14 +275,14 @@ class CentralExecutor {
         }
         if (sum < req.amountIn)
             throw new Error(`[executor] simulate 输入不足 ${sum} < ${req.amountIn}`);
-        const gasSnap = this.cache.snapshot(this.gasAddress, constants_1.SUI_TOKEN_ADDRESS.LONG);
-        const gasCoin = gasSnap.coins.find(c => BigInt(c.balance) >= this.gasMinCoin);
-        if (!gasCoin)
-            throw new Error(`[executor] simulate 无 ≥ ${this.gasMinCoin} 的 gas coin`);
-        const { txBytes } = await this.buildSwapTx(req, wallet, picked, gasCoin);
-        return (await this.core.dryRunTransaction({ transaction: txBytes })).transaction;
-    }
-    async buildSwapTx(req, wallet, inputCoins, gasCoin) {
+        const { txBytes } = await this.buildSwapTx(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)}`);
+        }
+        return res.Transaction;
+    }
+    async buildSwapTx(req, wallet, inputCoins) {
         const tx = new transactions_1.Transaction();
         tx.setSender(wallet);
         await this.registerShared(tx, req.poolId, true);
@@ -208,32 +299,26 @@ class CentralExecutor {
             amountLimit: req.minOut, sqrtPriceLimit: req.sqrtPriceLimit,
         }, inCoin);
         tx.transferObjects([outputCoin, ...leftoverCoins], tx.pure.address(wallet));
-        tx.setGasOwner(this.gasAddress);
-        tx.setGasPayment([{ objectId: gasCoin.objectId, version: gasCoin.version, digest: gasCoin.digest }]);
+        tx.setGasPayment([]);
+        tx.setExpiration(await this.getValidDuringExpiration());
         tx.setGasBudget(this.gasBudget);
         tx.setGasPrice(await this.getGasPrice());
         const txBytes = await tx.build();
         return { txBytes, tx };
     }
-    async onSuccess(tr, wallet, inType, outType, inputCoins, gasCoinId, inputTag, gasTag) {
+    async onSuccess(tr, wallet, inType, outType, inputCoins, inputTag) {
         const objectTypes = await tr.objectTypes;
         const coinTypeById = new Map();
         for (const c of inputCoins)
             coinTypeById.set(c.objectId, inType);
-        coinTypeById.set(gasCoinId, constants_1.SUI_TOKEN_ADDRESS.LONG);
         const tradeChanges = (0, effects_1.extractCoinChangesFromCore)(tr.effects, objectTypes, { owners: new Set([wallet]), coinTypeById });
-        const gasChanges = (0, effects_1.extractCoinChangesFromCore)(tr.effects, objectTypes, { owners: new Set([this.gasAddress]), coinTypeById });
         this.cache.commit(inputTag, tradeChanges);
-        this.cache.commit(gasTag, gasChanges);
         if (this.reconcileAfterTx) {
             for (const t of new Set([inType, outType, constants_1.SUI_TOKEN_ADDRESS.LONG]))
                 void this.reconcileCoins(wallet, t);
-            void this.reconcileCoins(this.gasAddress, constants_1.SUI_TOKEN_ADDRESS.LONG);
         }
     }
     get coinCache() { return this.cache; }
-    get gasWalletAddress() { return this.gasAddress; }
-    get gasSigner() { return this.gasKeypair; }
     get tradeWalletAddresses() { return [...this.tradeWallets.keys()]; }
     get coreClient() { return this.core; }
 }

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

@@ -1,4 +1,4 @@
-import { CoinRef, CoinReservation, GasReservation, CoinObjectChange } from '../coin/types';
+import { CoinRef, CoinReservation, CoinObjectChange } from '../coin/types';
 export declare class InProcessCoinCache {
     private available;
     private inflight;
@@ -8,7 +8,7 @@ export declare class InProcessCoinCache {
     seed(wallet: string, coinType: string, coins: CoinRef[]): void;
     reconcile(wallet: string, coinType: string, freshCoins: CoinRef[]): void;
     acquire(wallet: string, coinType: string, amount: bigint, txTag: string, maxCoins?: number): CoinReservation;
-    acquireGas(wallet: string, coinType: string, minGas: bigint, txTag: string): GasReservation;
+    hasInflight(wallet: string, coinType: string): boolean;
     commit(txTag: string, changes: CoinObjectChange[]): void;
     abort(txTag: string, consumed: boolean): void;
     private removeEverywhere;

package/dist/trade/executor/coin_cache.js

@@ -67,22 +67,12 @@ class InProcessCoinCache {
         this.inflight.set(txTag, { wallet, coinType, coins: picked, gas: false });
         return { txTag, coinType, coins: picked };
     }
-    acquireGas(wallet, coinType, minGas, txTag) {
-        if (this.inflight.has(txTag))
-            throw new Error(`[coin-cache] gas txTag 重复: ${txTag}`);
-        const l = this.list(wallet, coinType);
-        let chosen;
-        for (let i = l.length - 1; i >= 0; i--) {
-            if (BigInt(l[i].balance) >= minGas) {
-                chosen = l[i];
-                break;
-            }
+    hasInflight(wallet, coinType) {
+        for (const r of this.inflight.values()) {
+            if (r.wallet === wallet && r.coinType === coinType)
+                return true;
         }
-        if (!chosen)
-            throw new Error(`[coin-cache] gas 钱包 ${wallet} 无 ≥ ${minGas} 的 gas coin（需 split 补给）`);
-        this.walletMap(wallet).set(coinType, l.filter(c => c.objectId !== chosen.objectId));
-        this.inflight.set(txTag, { wallet, coinType, coins: [chosen], gas: true });
-        return { txTag, coin: chosen };
+        return false;
     }
     commit(txTag, changes) {
         const res = this.inflight.get(txTag);

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

@@ -1,32 +1,12 @@
-import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { CentralExecutor } from './central_executor';
-import { ExecutorCore } from './core_channel';
-export interface CoinMaintainerOptions {
-    gasTarget?: number;
-    gasMin?: number;
-    gasMax?: number;
-    gasCoinSize?: bigint;
-    intervalMs?: number;
-    maintainGasBudget?: bigint;
-}
 export declare class CoinMaintainer {
-    private readonly core;
-    private readonly gasKeypair;
     private readonly executor;
-    private readonly gasTarget;
-    private readonly gasMin;
-    private readonly gasMax;
-    private readonly gasCoinSize;
     private readonly intervalMs;
-    private readonly maintainGasBudget;
     private timer;
     private running;
-    constructor(core: ExecutorCore, gasKeypair: Ed25519Keypair, executor: CentralExecutor, opts?: CoinMaintainerOptions);
+    constructor(executor: CentralExecutor, opts?: {
+        intervalMs?: number;
+    });
     start(): void;
     stop(): void;
-    maintainGasPool(): Promise<void>;
-    private splitGasCoins;
-    private mergeGasCoins;
-    private sortedDesc;
-    private buildAndSend;
 }

package/dist/trade/executor/coin_maintainer.js

@@ -2,36 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoinMaintainer = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
-const transactions_1 = require("@mysten/sui/transactions");
-const effects_1 = require("./effects");
-const constants_1 = require("../../constants");
 class CoinMaintainer {
-    constructor(core, gasKeypair, executor, opts = {}) {
-        this.core = core;
-        this.gasKeypair = gasKeypair;
+    constructor(executor, opts = {}) {
         this.executor = executor;
         this.timer = null;
         this.running = false;
-        this.gasTarget = opts.gasTarget ?? Number(process.env.SUI_GAS_POOL_TARGET || 8);
-        this.gasMin = opts.gasMin ?? Number(process.env.SUI_GAS_POOL_MIN || 5);
-        this.gasMax = opts.gasMax ?? Number(process.env.SUI_GAS_POOL_MAX || 10);
-        this.gasCoinSize = opts.gasCoinSize ?? BigInt(process.env.SUI_GAS_COIN_SIZE || '150000000');
         this.intervalMs = opts.intervalMs ?? Number(process.env.SUI_COIN_MAINTAIN_INTERVAL_MS || 30000);
-        this.maintainGasBudget = opts.maintainGasBudget ?? BigInt(process.env.SUI_MAINTAIN_GAS_BUDGET || '20000000');
     }
     start() {
         if (this.timer)
             return;
-        (0, dist_1.log_info)(`[maintainer] start: gas target=${this.gasTarget}[${this.gasMin}-${this.gasMax}], size=${this.gasCoinSize}, interval=${this.intervalMs}ms`);
+        (0, dist_1.log_info)(`[maintainer] start: 单钱包资金平衡（balance↔coin 双向 + split/merge），interval=${this.intervalMs}ms`);
         const tick = async () => {
             if (this.running)
                 return;
             this.running = true;
             try {
-                await this.maintainGasPool();
+                await this.executor.rebalanceWalletFunds();
             }
             catch (e) {
-                (0, dist_1.log_error)('[maintainer] tick 失败', e);
+                (0, dist_1.log_error)('[maintainer] rebalance tick 失败', e);
             }
             finally {
                 this.running = false;
@@ -44,80 +34,5 @@ class CoinMaintainer {
         clearInterval(this.timer);
         this.timer = null;
     } }
-    async maintainGasPool() {
-        const gasAddr = this.executor.gasWalletAddress;
-        const snap = this.executor.coinCache.snapshot(gasAddr, constants_1.SUI_TOKEN_ADDRESS.LONG);
-        const count = snap.count;
-        if (count >= this.gasMin && count <= this.gasMax)
-            return;
-        if (count < this.gasMin)
-            await this.splitGasCoins(gasAddr, snap.coins, this.gasTarget - count);
-        else
-            await this.mergeGasCoins(gasAddr, snap.coins, count - this.gasTarget);
-        await this.executor.reconcileCoins(gasAddr, constants_1.SUI_TOKEN_ADDRESS.LONG);
-    }
-    async splitGasCoins(gasAddr, coins, n) {
-        if (n <= 0)
-            return;
-        const sorted = this.sortedDesc(coins);
-        const src = sorted[0];
-        const gasPay = sorted[1];
-        if (!src || !gasPay) {
-            (0, dist_1.log_warn)('[maintainer] gas coin 不足 2 个，无法独立挑 gas payment 做 split');
-            return;
-        }
-        const need = this.gasCoinSize * BigInt(n);
-        if (BigInt(src.balance) < need) {
-            (0, dist_1.log_warn)(`[maintainer] gas 源 coin ${src.balance} 不足 split ${n} × ${this.gasCoinSize}=${need}`);
-            return;
-        }
-        const tx = new transactions_1.Transaction();
-        tx.setSender(gasAddr);
-        const srcCoin = tx.object(transactions_1.Inputs.ObjectRef(src));
-        const amounts = Array.from({ length: n }, () => tx.pure.u64(this.gasCoinSize));
-        const newCoins = tx.splitCoins(srcCoin, amounts);
-        tx.transferObjects(Array.from({ length: n }, (_, i) => newCoins[i]), tx.pure.address(gasAddr));
-        await this.buildAndSend(tx, gasAddr, gasPay, `split ${n} gas coins`);
-    }
-    async mergeGasCoins(gasAddr, coins, n) {
-        if (n <= 0)
-            return;
-        const sorted = this.sortedDesc(coins);
-        const primary = sorted[0];
-        const toMerge = sorted.slice(-n).filter(c => c.objectId !== primary.objectId);
-        if (!toMerge.length)
-            return;
-        const mergeIds = new Set(toMerge.map(c => c.objectId));
-        const gasPay = sorted.find(c => c.objectId !== primary.objectId && !mergeIds.has(c.objectId));
-        if (!gasPay) {
-            (0, dist_1.log_warn)('[maintainer] 无空闲 gas coin 付 merge 交易 gas');
-            return;
-        }
-        const tx = new transactions_1.Transaction();
-        tx.setSender(gasAddr);
-        const primaryArg = tx.object(transactions_1.Inputs.ObjectRef(primary));
-        tx.mergeCoins(primaryArg, toMerge.map(c => tx.object(transactions_1.Inputs.ObjectRef(c))));
-        await this.buildAndSend(tx, gasAddr, gasPay, `merge ${toMerge.length} gas coins`);
-    }
-    sortedDesc(coins) {
-        return coins.slice().sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : BigInt(b.balance) < BigInt(a.balance) ? -1 : 0));
-    }
-    async buildAndSend(tx, gasAddr, gasPay, label) {
-        try {
-            tx.setGasOwner(gasAddr);
-            tx.setGasPayment([{ objectId: gasPay.objectId, version: gasPay.version, digest: gasPay.digest }]);
-            tx.setGasBudget(this.maintainGasBudget);
-            tx.setGasPrice(BigInt((await this.core.getReferenceGasPrice()).referenceGasPrice));
-            const bytes = await tx.build();
-            const { signature } = await this.gasKeypair.signTransaction(bytes);
-            const resp = await this.core.executeTransaction({ transaction: bytes, signatures: [signature] });
-            const tr = resp.transaction;
-            const { success, error } = (0, effects_1.coreTxStatus)(tr.effects);
-            (0, dist_1.log_info)(`[maintainer] ${label} ${success ? 'OK' : 'FAILED'} digest=${tr.digest}${error ? ' err=' + error : ''}`);
-        }
-        catch (e) {
-            (0, dist_1.log_error)(`[maintainer] ${label} 失败`, e);
-        }
-    }
 }
 exports.CoinMaintainer = CoinMaintainer;

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

@@ -1,17 +1,29 @@
-import { Experimental_CoreClient, Experimental_SuiClientTypes } from '@mysten/sui/experimental';
+import { CoreClient, SuiClientTypes } from '@mysten/sui/client';
 export interface GrpcCoreOptions {
     endpoint?: string;
     token?: string;
     network?: 'mainnet' | 'testnet' | 'devnet' | 'localnet';
 }
-export declare function buildGrpcCore(opts?: GrpcCoreOptions): Experimental_CoreClient;
+export declare function buildGrpcCore(opts?: GrpcCoreOptions): CoreClient;
 export interface GraphqlCoreOptions {
     url?: string;
 }
-export declare function buildGraphqlCore(opts?: GraphqlCoreOptions): Experimental_CoreClient;
-export declare function buildDefaultCore(): Experimental_CoreClient;
-export type ExecutorCore = Pick<Experimental_CoreClient, 'getCoins' | 'getObjects' | 'executeTransaction' | 'dryRunTransaction'> & {
-    getReferenceGasPrice(): Promise<Experimental_SuiClientTypes.GetReferenceGasPriceResponse>;
+export declare function buildGraphqlCore(opts?: GraphqlCoreOptions): CoreClient;
+export declare function buildDefaultCore(): CoreClient;
+export type ExecInclude = {
+    effects: true;
+    objectTypes: true;
+    balanceChanges: true;
+};
+export type ExecutorCore = {
+    listCoins(o: SuiClientTypes.ListCoinsOptions): Promise<SuiClientTypes.ListCoinsResponse>;
+    getBalance(o: SuiClientTypes.GetBalanceOptions): Promise<SuiClientTypes.GetBalanceResponse>;
+    getChainIdentifier(): Promise<SuiClientTypes.GetChainIdentifierResponse>;
+    getCurrentSystemState(): Promise<SuiClientTypes.GetCurrentSystemStateResponse>;
+    getObjects(o: SuiClientTypes.GetObjectsOptions): Promise<SuiClientTypes.GetObjectsResponse>;
+    executeTransaction(o: SuiClientTypes.ExecuteTransactionOptions<ExecInclude>): Promise<SuiClientTypes.TransactionResult<ExecInclude>>;
+    simulateTransaction(o: SuiClientTypes.SimulateTransactionOptions<ExecInclude>): Promise<SuiClientTypes.SimulateTransactionResult<ExecInclude>>;
+    getReferenceGasPrice(): Promise<SuiClientTypes.GetReferenceGasPriceResponse>;
 };
 export interface ResilientCoreOptions {
     retries?: number;
@@ -27,12 +39,16 @@ export declare class ResilientCore implements ExecutorCore {
     private readonly execDeadlineMs;
     private readonly gasPriceTtlMs;
     private gasPriceCache?;
-    constructor(primary: Experimental_CoreClient, fallback?: Experimental_CoreClient, opts?: ResilientCoreOptions);
+    constructor(primary: CoreClient, fallback?: CoreClient, opts?: ResilientCoreOptions);
     private read;
-    getCoins(o: Experimental_SuiClientTypes.GetCoinsOptions): Promise<Experimental_SuiClientTypes.GetCoinsResponse>;
-    getObjects(o: Experimental_SuiClientTypes.GetObjectsOptions): Promise<Experimental_SuiClientTypes.GetObjectsResponse>;
-    dryRunTransaction(o: Experimental_SuiClientTypes.DryRunTransactionOptions): Promise<Experimental_SuiClientTypes.DryRunTransactionResponse>;
-    getReferenceGasPrice(): Promise<Experimental_SuiClientTypes.GetReferenceGasPriceResponse>;
-    executeTransaction(o: Experimental_SuiClientTypes.ExecuteTransactionOptions): Promise<Experimental_SuiClientTypes.ExecuteTransactionResponse>;
+    listCoins(o: SuiClientTypes.ListCoinsOptions): Promise<SuiClientTypes.ListCoinsResponse>;
+    getBalance(o: SuiClientTypes.GetBalanceOptions): Promise<SuiClientTypes.GetBalanceResponse>;
+    getChainIdentifier(): Promise<SuiClientTypes.GetChainIdentifierResponse>;
+    getCurrentSystemState(): Promise<SuiClientTypes.GetCurrentSystemStateResponse>;
+    get rawClient(): CoreClient;
+    getObjects(o: SuiClientTypes.GetObjectsOptions): Promise<SuiClientTypes.GetObjectsResponse<{}>>;
+    simulateTransaction(o: SuiClientTypes.SimulateTransactionOptions<ExecInclude>): Promise<SuiClientTypes.SimulateTransactionResult<ExecInclude>>;
+    getReferenceGasPrice(): Promise<SuiClientTypes.GetReferenceGasPriceResponse>;
+    executeTransaction(o: SuiClientTypes.ExecuteTransactionOptions<ExecInclude>): Promise<SuiClientTypes.TransactionResult<ExecInclude>>;
 }
 export declare function buildResilientCore(opts?: ResilientCoreOptions): ResilientCore;

package/dist/trade/executor/core_channel.js

@@ -23,9 +23,8 @@ const GRPC_CLIENT_OPTIONS = {
     'grpc.max_reconnect_backoff_ms': 30000,
 };
 function buildGrpcCore(opts = {}) {
-    const coreEnv = (0, dist_1.getCoreEnv)();
-    const endpoint = opts.endpoint ?? coreEnv.grpc_endpoint;
-    const token = opts.token ?? coreEnv.grpc_token;
+    const endpoint = opts.endpoint ?? (0, dist_1.getCoreEnv)().grpc_endpoint;
+    const token = opts.token ?? (0, dist_1.getCoreEnv)().grpc_token;
     if (!endpoint)
         throw new Error('GRPC_ENDPOINT 未配置（集中执行器需 gRPC 端点）');
     const transport = new grpc_transport_1.GrpcTransport({
@@ -42,7 +41,7 @@ function buildGraphqlCore(opts = {}) {
     const url = opts.url ?? process.env.SUI_GRAPHQL_URL;
     if (!url)
         throw new Error('SUI_GRAPHQL_URL 未配置（GraphQL fallback 通道需端点）');
-    const core = new graphql_1.SuiGraphQLClient({ url }).core;
+    const core = new graphql_1.SuiGraphQLClient({ url, network: 'mainnet' }).core;
     (0, dist_1.log_info)(`[core-channel] GraphQL core ready, url=${url}`);
     return core;
 }
@@ -89,14 +88,24 @@ class ResilientCore {
             return await withRetry(() => call(this.fallback), { retries: this.retries, deadlineMs: this.readDeadlineMs, label: label + ':fallback' });
         }
     }
-    getCoins(o) {
-        return this.read('getCoins', c => c.getCoins(o));
+    listCoins(o) {
+        return this.read('listCoins', c => c.listCoins(o));
     }
+    getBalance(o) {
+        return this.read('getBalance', c => c.getBalance(o));
+    }
+    getChainIdentifier() {
+        return this.read('getChainIdentifier', c => c.getChainIdentifier());
+    }
+    getCurrentSystemState() {
+        return this.read('getCurrentSystemState', c => c.getCurrentSystemState());
+    }
+    get rawClient() { return this.primary; }
     getObjects(o) {
         return this.read('getObjects', c => c.getObjects(o));
     }
-    dryRunTransaction(o) {
-        return this.read('dryRunTransaction', c => c.dryRunTransaction(o));
+    simulateTransaction(o) {
+        return this.read('simulateTransaction', c => c.simulateTransaction(o));
     }
     async getReferenceGasPrice() {
         const fresh = this.gasPriceCache && (Date.now() - this.gasPriceCache.ts) < this.gasPriceTtlMs;

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

@@ -1,6 +1,6 @@
-import type { Experimental_SuiClientTypes } from '@mysten/sui/experimental';
+import type { SuiClientTypes } from '@mysten/sui/client';
 import { CoinObjectChange } from '../coin/types';
-type TransactionEffects = Experimental_SuiClientTypes.TransactionEffects;
+type TransactionEffects = SuiClientTypes.TransactionEffects;
 export declare function parseCoinType(type: string | undefined): string | null;
 export declare function coreTxStatus(effects: TransactionEffects): {
     success: boolean;

package/dist/trade/executor/effects.js

@@ -21,7 +21,7 @@ function ownerAddress(owner) {
 }
 function coreTxStatus(effects) {
     const s = effects.status;
-    return { success: s.success, error: s.success ? undefined : s.error };
+    return { success: s.success, error: s.success ? undefined : (s.error?.message ?? JSON.stringify(s.error)) };
 }
 function coreGasUsed(effects) {
     const g = effects.gasUsed;
@@ -33,7 +33,7 @@ function extractCoinChangesFromCore(effects, objectTypes, opts = {}) {
         const kind = changedKind(ch);
         if (!kind)
             continue;
-        const coinType = parseCoinType(objectTypes[ch.id]) ?? opts.coinTypeById?.get(ch.id);
+        const coinType = parseCoinType(objectTypes[ch.objectId]) ?? opts.coinTypeById?.get(ch.objectId);
         if (!coinType)
             continue;
         if (opts.owners?.size) {
@@ -43,11 +43,11 @@ function extractCoinChangesFromCore(effects, objectTypes, opts = {}) {
         }
         out.push({
             kind,
-            objectId: ch.id,
+            objectId: ch.objectId,
             coinType,
             version: ch.outputVersion ?? undefined,
             digest: ch.outputDigest ?? undefined,
-            balance: opts.balanceById?.get(ch.id),
+            balance: opts.balanceById?.get(ch.objectId),
         });
     }
     return out;

package/dist/trade/index.d.ts

@@ -1,4 +1,3 @@
-export * from './send_tx';
 export * from './check';
 export * from './parse';
 export * from './coin';

package/dist/trade/index.js

@@ -14,7 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./send_tx"), exports);
 __exportStar(require("./check"), exports);
 __exportStar(require("./parse"), exports);
 __exportStar(require("./coin"), exports);

package/dist/trade/swap/dex_swap_config.js

@@ -4,15 +4,15 @@ exports.SQRT_PRICE_LIMIT = exports.MOMENTUM_SWAP_CONFIG = exports.BLUEFIN_SWAP_C
 exports.configSharedObjectId = configSharedObjectId;
 exports.SUI_CLOCK_ID = '0x6';
 exports.CETUS_SWAP_CONFIG = {
-    integratePkg: '0x2d8c2e0fc6dd25b0214b3fa747e0fd27fd54608142cd2e4f64c1cd350cc4add4',
+    integratePkg: '0xae9c208cf58fd5ba36737c9ee5dcfa7f152d0fb5a5a99eebb7c881ebc2fe59e0',
     globalConfig: '0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f',
 };
 exports.MAGMA_SWAP_CONFIG = {
-    integratePkg: '0x4a9d6fb6f34ca8918756c2dfddf8f0a7fd5ef590bcffa6c03db24a6f10f42c5e',
+    integratePkg: '0x668909f9f30380dd1b63834534dc2bd19b274e6312a0dfa9be0ee5b0cef73446',
     globalConfig: '0x4c4e1402401f72c7d8533d0ed8d5f8949da363c7a3319ccef261ffe153d32f8a',
 };
 exports.BLUEFIN_SWAP_CONFIG = {
-    pkg: '0x67b34b728c4e28e704dcfecf7c5cf55c7fc593b6c65c20d1836d97c209c1928a',
+    pkg: '0xd075338d105482f1527cbfd363d6413558f184dec36d9138a70261e87f486e9c',
     globalConfig: '0x03db251ba509a8d5d8777b6338836082335d93eecbdd09a11e190a1cff51c352',
 };
 exports.MOMENTUM_SWAP_CONFIG = {

package/dist/utils/checkpoint_parse.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/checkpoint_parse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-sui-common",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Sui common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -18,7 +18,7 @@
     "@clonegod/ttd-core": "3.1.82",
     "@grpc/grpc-js": "^1.13.4",
     "@grpc/proto-loader": "^0.8.0",
-    "@mysten/sui": "^1.37.5",
+    "@mysten/sui": "^2.17.0",
     "@protobuf-ts/grpc-transport": "~2.11.1",
     "axios": "^1.12.0",
     "dotenv": "^16.4.7",