@clonegod/ttd-sui-common 1.0.101 → 2.0.1

package/dist/trade/executor/core_channel.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResilientCore = void 0;
+exports.buildGrpcCore = buildGrpcCore;
+exports.buildGraphqlCore = buildGraphqlCore;
+exports.buildDefaultCore = buildDefaultCore;
+exports.buildResilientCore = buildResilientCore;
+const grpc_js_1 = require("@grpc/grpc-js");
+const grpc_transport_1 = require("@protobuf-ts/grpc-transport");
+const dist_1 = require("@clonegod/ttd-core/dist");
+const grpc_1 = require("@mysten/sui/grpc");
+const graphql_1 = require("@mysten/sui/graphql");
+const GRPC_CLIENT_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': 8 * 1024 * 1024,
+    'grpc.max_send_message_length': 8 * 1024 * 1024,
+    'grpc.initial_reconnect_backoff_ms': 1000,
+    'grpc.max_reconnect_backoff_ms': 30000,
+};
+function buildGrpcCore(opts = {}) {
+    const endpoint = opts.endpoint ?? process.env.SUI_GRPC_ENDPOINT;
+    const token = opts.token ?? process.env.SUI_GRPC_TOKEN;
+    if (!endpoint)
+        throw new Error('SUI_GRPC_ENDPOINT 未配置（集中执行器需 gRPC 端点）');
+    const transport = new grpc_transport_1.GrpcTransport({
+        host: endpoint,
+        channelCredentials: grpc_js_1.ChannelCredentials.createSsl(),
+        clientOptions: GRPC_CLIENT_OPTIONS,
+        meta: token ? { 'x-token': token } : undefined,
+    });
+    const core = new grpc_1.SuiGrpcClient({ network: opts.network ?? 'mainnet', transport }).core;
+    (0, dist_1.log_info)(`[core-channel] gRPC(native) core ready, endpoint=${endpoint}`);
+    return core;
+}
+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;
+    (0, dist_1.log_info)(`[core-channel] GraphQL core ready, url=${url}`);
+    return core;
+}
+function buildDefaultCore() {
+    return buildGrpcCore();
+}
+function withTimeout(p, ms, label) {
+    return Promise.race([
+        p,
+        new Promise((_, rej) => setTimeout(() => rej(new Error(`[core] ${label} 超时 ${ms}ms`)), ms)),
+    ]);
+}
+async function withRetry(fn, opts) {
+    let lastErr;
+    for (let i = 0; i <= opts.retries; i++) {
+        try {
+            return await withTimeout(fn(), opts.deadlineMs, opts.label);
+        }
+        catch (e) {
+            lastErr = e;
+            if (i < opts.retries)
+                await (0, dist_1.sleep)(Math.min(100 * 2 ** i, 1000));
+        }
+    }
+    throw lastErr;
+}
+class ResilientCore {
+    constructor(primary, fallback, opts = {}) {
+        this.primary = primary;
+        this.fallback = fallback;
+        this.retries = opts.retries ?? Number(process.env.SUI_CORE_RETRIES || 2);
+        this.readDeadlineMs = opts.readDeadlineMs ?? Number(process.env.SUI_CORE_READ_DEADLINE_MS || 5000);
+        this.execDeadlineMs = opts.execDeadlineMs ?? Number(process.env.SUI_CORE_EXEC_DEADLINE_MS || 30000);
+        this.gasPriceTtlMs = opts.gasPriceTtlMs ?? Number(process.env.SUI_GAS_PRICE_TTL_MS || 3600000);
+    }
+    async read(label, call) {
+        try {
+            return await withRetry(() => call(this.primary), { retries: this.retries, deadlineMs: this.readDeadlineMs, label });
+        }
+        catch (e) {
+            if (!this.fallback)
+                throw e;
+            (0, dist_1.log_warn)(`[core] ${label} 主通道失败，转 GraphQL fallback: ${e.message}`);
+            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));
+    }
+    getObjects(o) {
+        return this.read('getObjects', c => c.getObjects(o));
+    }
+    dryRunTransaction(o) {
+        return this.read('dryRunTransaction', c => c.dryRunTransaction(o));
+    }
+    async getReferenceGasPrice() {
+        const fresh = this.gasPriceCache && (Date.now() - this.gasPriceCache.ts) < this.gasPriceTtlMs;
+        if (fresh)
+            return { referenceGasPrice: this.gasPriceCache.value };
+        const r = await this.read('getReferenceGasPrice', c => {
+            if (!c.getReferenceGasPrice)
+                throw new Error('core 不支持 getReferenceGasPrice');
+            return c.getReferenceGasPrice();
+        });
+        this.gasPriceCache = { value: r.referenceGasPrice, ts: Date.now() };
+        return r;
+    }
+    async executeTransaction(o) {
+        return withTimeout(this.primary.executeTransaction(o), this.execDeadlineMs, 'executeTransaction');
+    }
+}
+exports.ResilientCore = ResilientCore;
+function buildResilientCore(opts = {}) {
+    const primary = buildGrpcCore();
+    let fallback;
+    const gqlUrl = process.env.SUI_GRAPHQL_URL;
+    if (gqlUrl) {
+        try {
+            fallback = buildGraphqlCore({ url: gqlUrl });
+        }
+        catch (e) {
+            (0, dist_1.log_warn)(`[core] GraphQL fallback 构建失败: ${e.message}`);
+        }
+    }
+    (0, dist_1.log_info)(`[core] ResilientCore ready (failover=${fallback ? 'graphql' : 'none'})`);
+    return new ResilientCore(primary, fallback, opts);
+}

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

@@ -0,0 +1,27 @@
+import { CoinRef } from '../coin/types';
+import { RpcObjectChange } from './effects';
+export interface SharedRef {
+    objectId: string;
+    initialSharedVersion: string;
+}
+export interface NormalizedBalanceChange {
+    owner?: string;
+    coinType: string;
+    amount: string;
+}
+export interface NormalizedTxResult {
+    digest: string;
+    success: boolean;
+    error?: string;
+    objectChanges: RpcObjectChange[];
+    balanceChanges?: NormalizedBalanceChange[];
+    gasUsed?: bigint;
+}
+export interface DataChannel {
+    readonly kind: 'jsonrpc' | 'grpc';
+    listCoins(owner: string, coinType: string): Promise<CoinRef[]>;
+    getSharedRef(objectId: string): Promise<SharedRef>;
+    getGasPrice(): Promise<bigint>;
+    simulate(txBytes: Uint8Array): Promise<NormalizedTxResult>;
+    execute(txBytes: Uint8Array, signatures: string[]): Promise<NormalizedTxResult>;
+}

package/dist/trade/executor/data_channel.js

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

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

@@ -0,0 +1,16 @@
+import type { Experimental_SuiClientTypes } from '@mysten/sui/experimental';
+import { CoinObjectChange } from '../coin/types';
+type TransactionEffects = Experimental_SuiClientTypes.TransactionEffects;
+export declare function parseCoinType(type: string | undefined): string | null;
+export declare function coreTxStatus(effects: TransactionEffects): {
+    success: boolean;
+    error?: string;
+};
+export declare function coreGasUsed(effects: TransactionEffects): bigint;
+export interface ExtractCoinChangesOptions {
+    owners?: Set<string>;
+    balanceById?: Map<string, string>;
+    coinTypeById?: Map<string, string>;
+}
+export declare function extractCoinChangesFromCore(effects: TransactionEffects, objectTypes: Record<string, string>, opts?: ExtractCoinChangesOptions): CoinObjectChange[];
+export {};

package/dist/trade/executor/effects.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCoinType = parseCoinType;
+exports.coreTxStatus = coreTxStatus;
+exports.coreGasUsed = coreGasUsed;
+exports.extractCoinChangesFromCore = extractCoinChangesFromCore;
+function parseCoinType(type) {
+    if (!type)
+        return null;
+    const m = type.match(/^0x2::coin::Coin<(.+)>$/);
+    return m ? m[1] : null;
+}
+function ownerAddress(owner) {
+    if (!owner)
+        return undefined;
+    if (owner.$kind === 'AddressOwner')
+        return owner.AddressOwner;
+    if (owner.$kind === 'ConsensusAddressOwner')
+        return owner.ConsensusAddressOwner.owner;
+    return undefined;
+}
+function coreTxStatus(effects) {
+    const s = effects.status;
+    return { success: s.success, error: s.success ? undefined : s.error };
+}
+function coreGasUsed(effects) {
+    const g = effects.gasUsed;
+    return BigInt(g.computationCost) + BigInt(g.storageCost) - BigInt(g.storageRebate);
+}
+function extractCoinChangesFromCore(effects, objectTypes, opts = {}) {
+    const out = [];
+    for (const ch of effects.changedObjects) {
+        const kind = changedKind(ch);
+        if (!kind)
+            continue;
+        const coinType = parseCoinType(objectTypes[ch.id]) ?? opts.coinTypeById?.get(ch.id);
+        if (!coinType)
+            continue;
+        if (opts.owners?.size) {
+            const addr = ownerAddress(ch.outputOwner);
+            if (!addr || !opts.owners.has(addr))
+                continue;
+        }
+        out.push({
+            kind,
+            objectId: ch.id,
+            coinType,
+            version: ch.outputVersion ?? undefined,
+            digest: ch.outputDigest ?? undefined,
+            balance: opts.balanceById?.get(ch.id),
+        });
+    }
+    return out;
+}
+function changedKind(ch) {
+    if (ch.idOperation === 'Created')
+        return 'created';
+    if (ch.idOperation === 'Deleted')
+        return 'deleted';
+    if (ch.outputState === 'ObjectWrite')
+        return 'mutated';
+    return null;
+}

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

@@ -0,0 +1,13 @@
+import { SwapExecRequest, SwapExecResult } from './central_executor';
+import { RedisPubSub } from './executor_protocol';
+export declare class ExecutorClient {
+    private readonly redis;
+    private readonly defaultTimeoutMs;
+    private pending;
+    private subscribed;
+    private seq;
+    constructor(redis: RedisPubSub, defaultTimeoutMs?: number);
+    private ensureSubscribed;
+    private nextReqId;
+    requestSwap(req: SwapExecRequest, timeoutMs?: number): Promise<SwapExecResult>;
+}

package/dist/trade/executor/executor_client.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutorClient = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const executor_protocol_1 = require("./executor_protocol");
+class ExecutorClient {
+    constructor(redis, defaultTimeoutMs = 30000) {
+        this.redis = redis;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+        this.pending = new Map();
+        this.subscribed = false;
+        this.seq = 0;
+    }
+    async ensureSubscribed() {
+        if (this.subscribed)
+            return;
+        this.subscribed = true;
+        await this.redis.subscribe(executor_protocol_1.EXEC_RESPONSE_CHANNEL, (message) => {
+            try {
+                const env = JSON.parse(message);
+                const p = this.pending.get(env.reqId);
+                if (!p)
+                    return;
+                clearTimeout(p.timer);
+                this.pending.delete(env.reqId);
+                p.resolve(env.result);
+            }
+            catch (e) {
+                (0, dist_1.log_warn)('[executor-client] bad response message', message);
+            }
+        });
+    }
+    nextReqId() {
+        return `${Date.now()}-${++this.seq}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    async requestSwap(req, timeoutMs = this.defaultTimeoutMs) {
+        await this.ensureSubscribed();
+        const reqId = this.nextReqId();
+        const envelope = { reqId, req: (0, executor_protocol_1.toWire)(req) };
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(reqId);
+                (0, dist_1.log_error)(`[executor-client] 请求超时 reqId=${reqId} dex=${req.dexId}`, new Error('executor request timeout'));
+                resolve({ digest: '', success: false, error: `executor request timeout (${timeoutMs}ms)` });
+            }, timeoutMs);
+            this.pending.set(reqId, { resolve, timer });
+            Promise.resolve(this.redis.publish(executor_protocol_1.EXEC_REQUEST_CHANNEL, JSON.stringify(envelope))).catch(e => {
+                clearTimeout(timer);
+                this.pending.delete(reqId);
+                resolve({ digest: '', success: false, error: `publish failed: ${e.message}` });
+            });
+        });
+    }
+}
+exports.ExecutorClient = ExecutorClient;

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

@@ -0,0 +1,26 @@
+import { SwapExecRequest } from './central_executor';
+export declare const EXECUTOR_WS_PATH = "/sui/executor";
+export interface SwapExecRequestWire {
+    dexId: string;
+    poolId: string;
+    coinTypeA: string;
+    coinTypeB: string;
+    a2b: boolean;
+    amountIn: string;
+    minOut: string;
+    sqrtPriceLimit: string;
+    walletAddress?: string;
+}
+export interface ExecRequestEnvelope {
+    type: 'swap';
+    reqId: string;
+    req: SwapExecRequestWire;
+}
+export interface ExecResponseEnvelope {
+    reqId: string;
+    digest: string;
+    submitted: boolean;
+    error?: string;
+}
+export declare function toWire(req: SwapExecRequest): SwapExecRequestWire;
+export declare function fromWire(w: SwapExecRequestWire): SwapExecRequest;

package/dist/trade/executor/executor_protocol.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXECUTOR_WS_PATH = void 0;
+exports.toWire = toWire;
+exports.fromWire = fromWire;
+exports.EXECUTOR_WS_PATH = '/sui/executor';
+function toWire(req) {
+    return {
+        dexId: req.dexId,
+        poolId: req.poolId,
+        coinTypeA: req.coinTypeA,
+        coinTypeB: req.coinTypeB,
+        a2b: req.a2b,
+        amountIn: req.amountIn.toString(),
+        minOut: req.minOut.toString(),
+        sqrtPriceLimit: req.sqrtPriceLimit.toString(),
+        walletAddress: req.walletAddress,
+    };
+}
+function fromWire(w) {
+    return {
+        dexId: w.dexId,
+        poolId: w.poolId,
+        coinTypeA: w.coinTypeA,
+        coinTypeB: w.coinTypeB,
+        a2b: w.a2b,
+        amountIn: BigInt(w.amountIn),
+        minOut: BigInt(w.minOut),
+        sqrtPriceLimit: BigInt(w.sqrtPriceLimit),
+        walletAddress: w.walletAddress,
+    };
+}

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

@@ -0,0 +1,8 @@
+import { CentralExecutor } from './central_executor';
+import { RedisPubSub } from './executor_protocol';
+export declare class ExecutorServer {
+    private readonly executor;
+    private readonly redis;
+    constructor(executor: CentralExecutor, redis: RedisPubSub);
+    start(): Promise<void>;
+}

package/dist/trade/executor/executor_server.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutorServer = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const executor_protocol_1 = require("./executor_protocol");
+class ExecutorServer {
+    constructor(executor, redis) {
+        this.executor = executor;
+        this.redis = redis;
+    }
+    async start() {
+        await this.redis.subscribe(executor_protocol_1.EXEC_REQUEST_CHANNEL, async (message) => {
+            let reqId = '';
+            try {
+                const env = JSON.parse(message);
+                reqId = env.reqId;
+                const req = (0, executor_protocol_1.fromWire)(env.req);
+                const result = await this.executor.executeSwap(req);
+                const resp = { reqId, result };
+                await this.redis.publish(executor_protocol_1.EXEC_RESPONSE_CHANNEL, JSON.stringify(resp));
+            }
+            catch (e) {
+                (0, dist_1.log_error)(`[executor-server] 处理请求失败 reqId=${reqId}`, e);
+                if (reqId) {
+                    const resp = { reqId, result: { digest: '', success: false, error: e.message } };
+                    await Promise.resolve(this.redis.publish(executor_protocol_1.EXEC_RESPONSE_CHANNEL, JSON.stringify(resp))).catch(() => { });
+                }
+            }
+        });
+        (0, dist_1.log_info)('[executor-server] started, listening ' + executor_protocol_1.EXEC_REQUEST_CHANNEL);
+    }
+}
+exports.ExecutorServer = ExecutorServer;

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

@@ -0,0 +1,13 @@
+import { SwapExecRequest } from './central_executor';
+import { ExecResponseEnvelope } from './executor_protocol';
+export declare class ExecutorWsClient {
+    private readonly defaultTimeoutMs;
+    private ws;
+    private connected;
+    private pending;
+    private seq;
+    private clientName;
+    constructor(host?: string, port?: number, defaultTimeoutMs?: number);
+    private nextReqId;
+    requestSwap(req: SwapExecRequest, timeoutMs?: number): Promise<ExecResponseEnvelope>;
+}

package/dist/trade/executor/executor_ws_client.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutorWsClient = void 0;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const executor_protocol_1 = require("./executor_protocol");
+class ExecutorWsClient {
+    constructor(host, port = ttd_core_1.SERVICE_PORT.SEND_TX_WS, defaultTimeoutMs = 30000) {
+        this.defaultTimeoutMs = defaultTimeoutMs;
+        this.connected = false;
+        this.pending = new Map();
+        this.seq = 0;
+        const h = host || process.env.SUI_EXECUTOR_WS_HOST || process.env.SEND_TX_WS_HOST || '127.0.0.1';
+        const url = `ws://${h}:${port}${executor_protocol_1.EXECUTOR_WS_PATH}`;
+        this.clientName = process.env.APP_NAME || (process.env.pm_id ? `pm2-${process.env.pm_id}` : `pid-${process.pid}`);
+        this.ws = new ttd_core_1.WebSocketClient(url);
+        this.ws.onOpen(() => {
+            this.connected = true;
+            this.ws.send(JSON.stringify({ type: 'hello', clientName: this.clientName }));
+        });
+        this.ws.onMessage((data) => {
+            try {
+                const env = JSON.parse(typeof data === 'string' ? data : data.toString());
+                const p = this.pending.get(env.reqId);
+                if (!p)
+                    return;
+                clearTimeout(p.timer);
+                this.pending.delete(env.reqId);
+                p.resolve(env);
+            }
+            catch (e) {
+                (0, ttd_core_1.log_warn)('[executor-client] bad response', String(data));
+            }
+        });
+        this.ws.connect();
+    }
+    nextReqId() {
+        return `${Date.now()}-${++this.seq}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    async requestSwap(req, timeoutMs = this.defaultTimeoutMs) {
+        const reqId = this.nextReqId();
+        const envelope = { type: 'swap', reqId, req: (0, executor_protocol_1.toWire)(req) };
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(reqId);
+                (0, ttd_core_1.log_error)(`[executor-client] 请求超时 reqId=${reqId} dex=${req.dexId}`, new Error('executor request timeout'));
+                resolve({ reqId, digest: '', submitted: false, error: `executor request timeout (${timeoutMs}ms)` });
+            }, timeoutMs);
+            this.pending.set(reqId, { resolve, timer });
+            const ok = this.ws.send(JSON.stringify(envelope));
+            if (!ok && !this.connected) {
+                clearTimeout(timer);
+                this.pending.delete(reqId);
+                resolve({ reqId, digest: '', submitted: false, error: 'executor ws not connected' });
+            }
+        });
+    }
+}
+exports.ExecutorWsClient = ExecutorWsClient;

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

@@ -0,0 +1,14 @@
+import { SuiGrpcClient } from '../../grpc';
+import { CoinRef } from '../coin/types';
+import { DataChannel, NormalizedTxResult, SharedRef } from './data_channel';
+export declare class GrpcDataChannel implements DataChannel {
+    private readonly grpc;
+    readonly kind: "grpc";
+    constructor(grpc: SuiGrpcClient);
+    listCoins(owner: string, coinType: string): Promise<CoinRef[]>;
+    getSharedRef(objectId: string): Promise<SharedRef>;
+    getGasPrice(): Promise<bigint>;
+    simulate(_txBytes: Uint8Array): Promise<NormalizedTxResult>;
+    execute(txBytes: Uint8Array, signatures: string[]): Promise<NormalizedTxResult>;
+    private normalize;
+}

package/dist/trade/executor/grpc_channel.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcDataChannel = void 0;
+const utils_1 = require("@mysten/sui/utils");
+const dist_1 = require("@clonegod/ttd-core/dist");
+class GrpcDataChannel {
+    constructor(grpc) {
+        this.grpc = grpc;
+        this.kind = 'grpc';
+    }
+    async listCoins(owner, coinType) {
+        const objs = await this.grpc.stateService.listAllOwnedObjects(owner, coinType);
+        return objs.map(o => ({
+            objectId: o.object_id ?? o.objectId,
+            version: String(o.version),
+            digest: o.digest,
+            balance: String(o.balance ?? '0'),
+        })).filter(c => c.objectId);
+    }
+    async getSharedRef(objectId) {
+        const res = await this.grpc.ledgerService.getObject(objectId, ['owner']);
+        const owner = res?.object?.owner;
+        const isv = owner?.initial_shared_version ?? owner?.version;
+        if (isv == null)
+            throw new Error(`[grpc] ${objectId} 无 initial_shared_version（非共享对象?）`);
+        return { objectId, initialSharedVersion: String(isv) };
+    }
+    async getGasPrice() {
+        return BigInt(await this.grpc.gasPriceCache.getGasPrice());
+    }
+    async simulate(_txBytes) {
+        throw new Error('[grpc] simulate 待接入 live_data_service SimulateTransaction wrapper；dry-run 期请用 JsonRpcDataChannel');
+    }
+    async execute(txBytes, signatures) {
+        const sigBytes = signatures.map(s => (0, utils_1.fromB64)(s));
+        const resp = await this.grpc.transactionService.executeTransactionMultiSig(txBytes, sigBytes, ['transaction', 'effects', 'finality']);
+        return this.normalize(resp);
+    }
+    normalize(resp) {
+        const tx = resp?.transaction ?? resp;
+        const digest = tx?.digest ?? resp?.digest ?? '';
+        const effects = tx?.effects ?? resp?.effects;
+        const success = effects?.status?.success === true || (!!effects && !effects?.status?.error && effects?.status?.success !== false);
+        const error = success ? undefined : (effects?.status?.error || effects?.status?.description || 'unknown');
+        const changed = effects?.changed_objects ?? effects?.changedObjects ?? [];
+        const changes = changed.map((c) => {
+            const idOp = c.id_operation ?? c.idOperation;
+            const kind = idOp === 'CREATED' ? 'created' : idOp === 'DELETED' ? 'deleted' : 'mutated';
+            return {
+                type: kind,
+                objectId: c.object_id ?? c.objectId,
+                objectType: undefined,
+                version: (c.output_version ?? c.outputVersion) != null ? String(c.output_version ?? c.outputVersion) : undefined,
+                digest: c.output_digest ?? c.outputDigest,
+                owner: (c.output_owner ?? c.outputOwner)?.address ?? c.output_owner ?? c.outputOwner,
+            };
+        }).filter((c) => c.objectId);
+        let gasUsed;
+        const g = effects?.gas_used ?? effects?.gasUsed;
+        if (g) {
+            try {
+                gasUsed = BigInt(g.computation_cost ?? g.computationCost ?? 0)
+                    + BigInt(g.storage_cost ?? g.storageCost ?? 0)
+                    - BigInt(g.storage_rebate ?? g.storageRebate ?? 0);
+            }
+            catch {
+                (0, dist_1.log_warn)('[grpc] gasUsed 解析失败');
+            }
+        }
+        return { digest, success, error, objectChanges: changes, gasUsed };
+    }
+}
+exports.GrpcDataChannel = GrpcDataChannel;

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

@@ -0,0 +1,7 @@
+export * from './coin_cache';
+export * from './effects';
+export * from './core_channel';
+export * from './central_executor';
+export * from './coin_maintainer';
+export * from './executor_protocol';
+export * from './executor_ws_client';

package/dist/trade/executor/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./coin_cache"), exports);
+__exportStar(require("./effects"), exports);
+__exportStar(require("./core_channel"), exports);
+__exportStar(require("./central_executor"), exports);
+__exportStar(require("./coin_maintainer"), exports);
+__exportStar(require("./executor_protocol"), exports);
+__exportStar(require("./executor_ws_client"), exports);

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

@@ -0,0 +1,14 @@
+import { SuiClient } from '@mysten/sui/client';
+import { CoinRef } from '../coin/types';
+import { DataChannel, NormalizedTxResult, SharedRef } from './data_channel';
+export declare class JsonRpcDataChannel implements DataChannel {
+    private readonly client;
+    readonly kind: "jsonrpc";
+    constructor(client: SuiClient);
+    listCoins(owner: string, coinType: string): Promise<CoinRef[]>;
+    getSharedRef(objectId: string): Promise<SharedRef>;
+    getGasPrice(): Promise<bigint>;
+    simulate(txBytes: Uint8Array): Promise<NormalizedTxResult>;
+    execute(txBytes: Uint8Array, signatures: string[]): Promise<NormalizedTxResult>;
+    private normalize;
+}