@clonegod/ttd-sui-common 1.0.101 → 2.0.1

package/dist/grpc/sui_object_reader.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiObjectReader = void 0;
+const ledger_service_1 = require("./ledger-service");
+const state_service_1 = require("./state-service");
+const proto_value_1 = require("./proto_value");
+const DF_PAGE_SIZE = 1000;
+const DF_MAX_PAGES = 5000;
+const BATCH_CHUNK = 50;
+class SuiObjectReader {
+    constructor(connection) {
+        this.ledger = new ledger_service_1.LedgerService(connection);
+        this.state = new state_service_1.StateService(connection);
+    }
+    async getCoinDecimals(coinType) {
+        const r = await this.state.getCoinInfo(coinType);
+        const d = r?.metadata?.decimals;
+        if (d == null || !Number.isInteger(Number(d))) {
+            throw new Error(`[SuiObjectReader] 链上 decimals 读取失败 coinType=${coinType}（不兜底，须停下排查）`);
+        }
+        return Number(d);
+    }
+    async getObjectJson(objectId) {
+        const r = await this.ledger.getObject(objectId, ['object_id', 'object_type', 'json']);
+        const obj = r?.object;
+        if (!obj)
+            throw new Error(`[SuiObjectReader] object not found: ${objectId}`);
+        return { objectId: obj.object_id, objectType: obj.object_type, json: (0, proto_value_1.unwrapProtoValue)(obj.json) };
+    }
+    async batchGetObjectJsons(objectIds) {
+        const out = [];
+        for (let i = 0; i < objectIds.length; i += BATCH_CHUNK) {
+            const chunk = objectIds.slice(i, i + BATCH_CHUNK);
+            const r = await this.ledger.batchGetObjects(chunk, ['object_id', 'object_type', 'json']);
+            for (const res of (r?.objects || [])) {
+                const obj = res?.object;
+                if (obj)
+                    out.push({ objectId: obj.object_id, objectType: obj.object_type, json: (0, proto_value_1.unwrapProtoValue)(obj.json) });
+            }
+        }
+        return out;
+    }
+    async listAllDynamicFieldObjectJsons(parent) {
+        const fieldIds = [];
+        let pageTokenHex;
+        for (let page = 0; page < DF_MAX_PAGES; page++) {
+            const resp = await this.state.listDynamicFields(parent, DF_PAGE_SIZE, pageTokenHex, ['field_id']);
+            for (const df of (resp?.dynamic_fields || [])) {
+                if (df.field_id)
+                    fieldIds.push(df.field_id);
+            }
+            const next = resp?.next_page_token ?? resp?.nextPageToken;
+            if (!next || (typeof next === 'string' && next.length === 0))
+                break;
+            pageTokenHex = typeof next === 'string' ? next : Buffer.from(next).toString('hex');
+        }
+        return this.batchGetObjectJsons(fieldIds);
+    }
+}
+exports.SuiObjectReader = SuiObjectReader;

package/dist/grpc/transaction-service.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionService = void 0;
 class TransactionService {
@@ -15,38 +6,36 @@ class TransactionService {
         this.connection = connection;
         this.transactionClient = connection.createServiceClient('transaction_execution_service.proto', 'TransactionExecutionService');
     }
-    executeTransaction(transactionBytes, signatureBytes, fields) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!fields || fields.length === 0) {
-                fields = ['transaction', 'finality'];
-            }
-            return new Promise((resolve, reject) => {
-                const request = {
-                    transaction: {
+    async executeTransaction(transactionBytes, signatureBytes, fields) {
+        if (!fields || fields.length === 0) {
+            fields = ['transaction', 'finality'];
+        }
+        return new Promise((resolve, reject) => {
+            const request = {
+                transaction: {
+                    bcs: {
+                        value: transactionBytes
+                    }
+                },
+                signatures: [
+                    {
+                        scheme: 0,
                         bcs: {
-                            value: transactionBytes
-                        }
-                    },
-                    signatures: [
-                        {
-                            scheme: 0,
-                            bcs: {
-                                value: signatureBytes
-                            }
+                            value: signatureBytes
                         }
-                    ],
-                    read_mask: {
-                        paths: fields
                     }
-                };
-                this.transactionClient.ExecuteTransaction(request, this.connection.getMetadata(), (error, response) => {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve(response);
-                });
-                console.log('executeTransaction, read_mask=', request.read_mask);
+                ],
+                read_mask: {
+                    paths: fields
+                }
+            };
+            this.transactionClient.ExecuteTransaction(request, this.connection.getMetadata(), (error, response) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(response);
             });
+            console.log('executeTransaction, read_mask=', request.read_mask);
         });
     }
 }

package/dist/index.d.ts

@@ -5,6 +5,6 @@ export * from './type';
 export * from './grpc';
 export * from './utils';
 export * from './constants';
+export * from './appconfig';
 export * from './trade';
 export * from './redis';
-export * from './rpc';

package/dist/index.js

@@ -21,6 +21,6 @@ __exportStar(require("./type"), exports);
 __exportStar(require("./grpc"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./appconfig"), exports);
 __exportStar(require("./trade"), exports);
 __exportStar(require("./redis"), exports);
-__exportStar(require("./rpc"), exports);

package/dist/quote/abstract_dex_quote.d.ts

@@ -0,0 +1,60 @@
+import { AppConfig, QuoteDepthOutput, QuoteResultType, StandardPoolInfoType } from "@clonegod/ttd-core/dist";
+import { SuiChainOps } from "./chain_ops";
+import { SuiPoolEvent } from "./pool_event";
+import { QuotePriceVerify, CheckSwapParams } from "./verify/quote_price_verify";
+import { QuoteTrace } from "./quote_trace";
+export interface PoolInitSummary {
+    protocol_type: string;
+    fee_bps: number;
+    tick_spacing?: number;
+    token0: string;
+    token1: string;
+    verifyContract?: string;
+}
+export interface QuoteBundle {
+    poolInfo: StandardPoolInfoType;
+    quote_amount_usd: number;
+    streamTimestamp: number;
+    quoteStartTime: number;
+    blockNumber: number;
+    txIndex?: number;
+    askQuote: QuoteResultType;
+    bidQuote: QuoteResultType;
+    txid: string;
+    source?: string;
+    depth?: QuoteDepthOutput;
+    priceMap?: Map<string, {
+        price: string;
+    } | undefined>;
+    trace?: QuoteTrace;
+}
+export declare abstract class AbstractDexQuote<C extends SuiChainOps = SuiChainOps> {
+    protected appConfig: AppConfig;
+    protected chain: C;
+    protected poolInfoMap: Map<string, StandardPoolInfoType>;
+    private poolLastQuoteTimeMap;
+    private lastPublished;
+    protected quotePriceVerify: QuotePriceVerify;
+    private readonly MIN_QUOTE_INTERVAL_MS;
+    constructor(appConfig: AppConfig, chain: C);
+    protected abstract readonly dexId: string;
+    protected abstract readonly debouncedEventTypes: string[];
+    protected abstract loadPool(poolInfo: StandardPoolInfoType): Promise<PoolInitSummary>;
+    protected abstract quoteV1(poolInfo: StandardPoolInfoType, isBuy: boolean): Promise<QuoteResultType>;
+    protected abstract quoteV2(poolInfo: StandardPoolInfoType, isBuy: boolean): Promise<QuoteResultType>;
+    protected refreshStateFromEvent(_poolInfo: StandardPoolInfoType, _evt: SuiPoolEvent): Promise<void>;
+    protected calculateDepth(_poolInfo: StandardPoolInfoType, _poolAddress: string, _priceMap: Map<string, {
+        price: string;
+    } | undefined>): Promise<QuoteDepthOutput | undefined>;
+    protected buildSwapVerify(_poolInfo: StandardPoolInfoType, _evt: SuiPoolEvent): CheckSwapParams | null;
+    init(poolList: StandardPoolInfoType[]): Promise<void>;
+    protected beforeLoadPools(): Promise<void>;
+    protected getQuoteAmountUsd(poolInfo: StandardPoolInfoType): number;
+    private registerEventHandlers;
+    private assertValidBlockNumber;
+    private isStaleUpdate;
+    private handleBlockUpdateEvent;
+    private calculateQuote;
+    private calculateQuoteForPool;
+    protected publishQuote(result: QuoteBundle): void;
+}

package/dist/quote/abstract_dex_quote.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractDexQuote = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const quote_price_verify_1 = require("./verify/quote_price_verify");
+const quote_amount_1 = require("./quote_amount");
+const quote_trace_1 = require("./quote_trace");
+class AbstractDexQuote {
+    constructor(appConfig, chain) {
+        this.poolInfoMap = new Map();
+        this.poolLastQuoteTimeMap = new Map();
+        this.lastPublished = new Map();
+        this.quotePriceVerify = new quote_price_verify_1.QuotePriceVerify();
+        this.MIN_QUOTE_INTERVAL_MS = Math.max(3000, parseInt(process.env.MIN_QUOTE_INTERVAL_MS || '10000', 10) || 10000);
+        this.appConfig = appConfig;
+        this.chain = chain;
+    }
+    async refreshStateFromEvent(_poolInfo, _evt) { }
+    async calculateDepth(_poolInfo, _poolAddress, _priceMap) { return undefined; }
+    buildSwapVerify(_poolInfo, _evt) { return null; }
+    async init(poolList) {
+        (0, dist_1.log_info)(`初始化 ${this.dexId} Quote，共 ${poolList.length} 个池...`);
+        for (const poolInfo of poolList) {
+            if (!this.chain.isValidPoolAddress(poolInfo.pool_address)) {
+                (0, dist_1.log_warn)(`跳过无效的池地址: ${poolInfo.pool_address}`, '');
+                continue;
+            }
+            this.poolInfoMap.set(poolInfo.pool_address, poolInfo);
+        }
+        await this.beforeLoadPools();
+        await Promise.all(Array.from(this.poolInfoMap.values()).map(async (p) => {
+            const summary = await this.loadPool(p);
+            if (summary.verifyContract)
+                await this.chain.assertContractDeployed(summary.verifyContract);
+            (0, dist_1.log_info)(`[QUOTE INIT] ${p.pool_name} (${p.pool_address}) dex=${this.dexId}`, { ...summary });
+        }));
+        this.registerEventHandlers();
+        (0, dist_1.log_info)(`${this.dexId} Quote 初始化完成，${this.poolInfoMap.size} 个有效池`);
+    }
+    async beforeLoadPools() { }
+    getQuoteAmountUsd(poolInfo) { return (0, quote_amount_1.getQuoteAmountUsd)(poolInfo); }
+    registerEventHandlers() {
+        this.chain.subscribeNewBlock((raw) => this.handleBlockUpdateEvent(raw));
+        this.chain.subscribePoolEvents(this.dexId, Array.from(this.poolInfoMap.values()), async (evt) => {
+            const { bundle, verifyLog } = await this.calculateQuote(evt);
+            if (bundle)
+                this.publishQuote(bundle);
+            if (verifyLog)
+                (0, dist_1.log_info)(verifyLog);
+        });
+    }
+    assertValidBlockNumber(blockNumber, ctx) {
+        if (!Number.isInteger(blockNumber) || blockNumber <= 0) {
+            throw new Error(`[block-number] ${ctx}: 非法 blockNumber=${blockNumber}，每条数据源必须携带真实区块号`);
+        }
+    }
+    isStaleUpdate(poolAddr, block, txIndex) {
+        const last = this.lastPublished.get(poolAddr);
+        return !!last && (block < last.block || (block === last.block && txIndex <= last.txIndex));
+    }
+    async handleBlockUpdateEvent(eventData) {
+        const { blockNumber, blockTime } = JSON.parse(eventData);
+        this.assertValidBlockNumber(blockNumber, `${this.dexId} block-event`);
+        for (const poolInfo of this.poolInfoMap.values()) {
+            const poolAddress = poolInfo.pool_address;
+            const now = Date.now();
+            const last = this.poolLastQuoteTimeMap.get(poolAddress) || 0;
+            if (now - last >= this.MIN_QUOTE_INTERVAL_MS) {
+                this.poolLastQuoteTimeMap.set(poolAddress, now);
+                const result = await this.calculateQuoteForPool(poolInfo, blockTime, blockNumber);
+                if (result)
+                    this.publishQuote(result);
+            }
+        }
+    }
+    async calculateQuote(evt) {
+        const poolInfo = this.poolInfoMap.get(evt.pool_address);
+        if (!poolInfo)
+            return { bundle: null };
+        const eventType = evt.type?.toLowerCase();
+        let verifyLog;
+        if (eventType === 'swap') {
+            const v = this.buildSwapVerify(poolInfo, evt);
+            if (v)
+                verifyLog = this.quotePriceVerify.checkSwap(v) || undefined;
+            if (!this.debouncedEventTypes.includes('swap'))
+                return { bundle: null, verifyLog };
+        }
+        this.assertValidBlockNumber(evt.blockNumber, `${this.dexId} ${poolInfo.pool_name} ${eventType}`);
+        await this.refreshStateFromEvent(poolInfo, evt);
+        if (Number.isInteger(evt.txIndex) && this.isStaleUpdate(poolInfo.pool_address, evt.blockNumber, evt.txIndex))
+            return { bundle: null, verifyLog };
+        const bundle = await this.calculateQuoteForPool(poolInfo, evt.blockTime, evt.blockNumber, evt);
+        return { bundle, verifyLog };
+    }
+    async calculateQuoteForPool(poolInfo, streamTimestamp, blockNumber, evt) {
+        const { pool_address } = poolInfo;
+        const eventDriven = !!evt && this.debouncedEventTypes.includes(evt.type?.toLowerCase());
+        const source = eventDriven ? 'local:v2' : 'rpc:v1';
+        const trace = new quote_trace_1.QuoteTrace(poolInfo.pool_name, pool_address, blockNumber, source);
+        trace.mark('trigger');
+        let stage = 'compute';
+        try {
+            const quote_amount_usd = (0, quote_amount_1.getQuoteAmountUsd)(poolInfo);
+            const quoteStartTime = Date.now();
+            const txid = evt ? (evt.txHash || 'block') : 'block';
+            const txIndex = evt?.txIndex;
+            let askQuote, bidQuote;
+            if (eventDriven) {
+                ;
+                [askQuote, bidQuote] = await Promise.all([this.quoteV2(poolInfo, true), this.quoteV2(poolInfo, false)]);
+            }
+            else {
+                ;
+                [askQuote, bidQuote] = await Promise.all([this.quoteV1(poolInfo, true), this.quoteV1(poolInfo, false)]);
+            }
+            trace.mark('compute');
+            const askN = Number(askQuote.price), bidN = Number(bidQuote.price);
+            if (askN > 0 && bidN > 0 && askN < bidN) {
+                throw new Error(`ask(${askN}) < bid(${bidN}) — 异常价差，丢弃该报价`);
+            }
+            this.poolLastQuoteTimeMap.set(pool_address, Date.now());
+            stage = 'depth';
+            const t0a = poolInfo.tokenA?.address, t1a = poolInfo.tokenB?.address;
+            const priceMap = (t0a && t1a) ? await this.chain.loadTokenPrices([t0a, t1a]) : new Map();
+            const depth = await this.calculateDepth(poolInfo, pool_address, priceMap);
+            trace.mark('depth');
+            trace.set('ask', askQuote.price);
+            trace.set('bid', bidQuote.price);
+            trace.set('tiers', depth?.ask?.tiers?.length ?? 0);
+            trace.set('quote_amount_usd', quote_amount_usd);
+            trace.set('txid', txid);
+            return { poolInfo, quote_amount_usd, streamTimestamp, quoteStartTime, blockNumber, txIndex, askQuote, bidQuote, txid, source, depth, priceMap, trace };
+        }
+        catch (error) {
+            trace.markError(stage, error instanceof Error ? error.message : String(error));
+            trace.flush();
+            return null;
+        }
+    }
+    publishQuote(result) {
+        const poolAddr = result.poolInfo.pool_address;
+        const isV2 = result.source?.endsWith(':v2');
+        let shouldPush = true;
+        if (result.source?.endsWith(':v1')) {
+            shouldPush = true;
+        }
+        else {
+            const incomingTx = result.txIndex;
+            if (!Number.isInteger(incomingTx)) {
+                throw new Error(`[publish] ${result.source} ${poolAddr}: 缺/非法 txIndex=${incomingTx}，事件源必须提供块内序号`);
+            }
+            const tx = incomingTx;
+            shouldPush = !this.isStaleUpdate(poolAddr, result.blockNumber, tx);
+            if (shouldPush)
+                this.lastPublished.set(poolAddr, { block: result.blockNumber, txIndex: tx });
+        }
+        if (shouldPush) {
+            (0, dist_1.on_quote_response)({
+                appConfig: this.appConfig, poolInfo: result.poolInfo, quoteAmountUsd: result.quote_amount_usd,
+                streamTime: result.streamTimestamp, quoteStartTime: result.quoteStartTime, blockNumber: result.blockNumber,
+                quotes: [result.askQuote, result.bidQuote], txid: result.txid, source: result.source, depth: result.depth,
+            });
+        }
+        result.trace?.set('published', shouldPush);
+        result.trace?.mark('publish');
+        const candidateTiers = isV2 && result.depth ? {
+            ask_tiers: result.depth.ask.tiers.map(t => ({ pct: t.pct, price: t.price, amount: t.amount, amount_in: t.amount_in })),
+            bid_tiers: result.depth.bid.tiers.map(t => ({ pct: t.pct, price: t.price, amount: t.amount, amount_in: t.amount_in })),
+        } : {};
+        (0, dist_1.report_quote_candidate)({
+            pool_address: poolAddr, pair: result.poolInfo.pair, dex_id: result.poolInfo.dex_id,
+            source: result.source || '', block_number: result.blockNumber,
+            ask_price: result.askQuote.price, bid_price: result.bidQuote.price, ...candidateTiers,
+        });
+        const quoteId = result.txid?.slice(0, 10) || `blk:${result.blockNumber}`;
+        const tiersArg = isV2 ? { askTiers: result.depth?.ask?.tiers, bidTiers: result.depth?.bid?.tiers } : undefined;
+        const t0a = result.poolInfo.tokenA?.address, t1a = result.poolInfo.tokenB?.address;
+        const p0 = t0a ? Number(result.priceMap?.get(t0a.toLowerCase())?.price) || 0 : 0;
+        const p1 = t1a ? Number(result.priceMap?.get(t1a.toLowerCase())?.price) || 0 : 0;
+        this.quotePriceVerify.cacheQuote(poolAddr, quoteId, result.source || '', Number(result.askQuote.price), Number(result.bidQuote.price), result.blockNumber, result.quote_amount_usd, p0, p1, tiersArg);
+        result.trace?.mark('verify');
+        result.trace?.flush();
+    }
+}
+exports.AbstractDexQuote = AbstractDexQuote;

package/dist/quote/chain_ops.d.ts

@@ -0,0 +1,17 @@
+import { AppConfig, CHAIN_ID, StandardPoolInfoType } from "@clonegod/ttd-core/dist";
+import { TokenPriceCache } from "./pricing/token_price_cache";
+import { SuiPoolEvent } from "./pool_event";
+export declare class SuiChainOps {
+    private readonly appConfig;
+    private readonly tokenPriceCache;
+    readonly chainId = CHAIN_ID.SUI;
+    private readonly poolEventChannel;
+    constructor(appConfig: AppConfig, tokenPriceCache: TokenPriceCache);
+    isValidPoolAddress(addr: string): boolean;
+    assertContractDeployed(_contractAddress: string): Promise<void>;
+    loadTokenPrices(addresses: string[]): Promise<Map<string, {
+        price: string;
+    } | undefined>>;
+    subscribeNewBlock(handler: (raw: string) => void): void;
+    subscribePoolEvents(dexId: string, pools: StandardPoolInfoType[], handler: (evt: SuiPoolEvent) => void): void;
+}

package/dist/quote/chain_ops.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiChainOps = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const pool_event_1 = require("./pool_event");
+class SuiChainOps {
+    constructor(appConfig, tokenPriceCache) {
+        this.appConfig = appConfig;
+        this.tokenPriceCache = tokenPriceCache;
+        this.chainId = dist_1.CHAIN_ID.SUI;
+        this.poolEventChannel = (0, pool_event_1.get_sui_pool_event_channel)(dist_1.CHAIN_ID.SUI);
+    }
+    isValidPoolAddress(addr) {
+        return /^0x[0-9a-fA-F]{64}$/.test(addr);
+    }
+    async assertContractDeployed(_contractAddress) {
+    }
+    async loadTokenPrices(addresses) {
+        const out = new Map();
+        await Promise.all(addresses.map(async (addr) => {
+            try {
+                const p = await this.tokenPriceCache.getTokenPrice(addr);
+                out.set(addr.toLowerCase(), { price: p.price });
+            }
+            catch {
+                out.set(addr.toLowerCase(), undefined);
+            }
+        }));
+        return out;
+    }
+    subscribeNewBlock(handler) {
+        this.appConfig.arb_event_subscriber.subscribe_new_block(this.chainId, handler);
+    }
+    subscribePoolEvents(dexId, pools, handler) {
+        const dex = dexId.toUpperCase();
+        const poolSet = new Set(pools.map(p => p.pool_address.toLowerCase()));
+        this.appConfig.arb_cache.redis_cmd.subscribe(this.poolEventChannel, (message) => {
+            try {
+                const evt = JSON.parse(message);
+                if (evt.dex_id?.toUpperCase() !== dex)
+                    return;
+                if (!poolSet.has(evt.pool_address.toLowerCase()))
+                    return;
+                handler(evt);
+            }
+            catch (e) {
+                (0, dist_1.log_warn)(`[SuiChainOps] bad pool event message`, message);
+            }
+        });
+    }
+}
+exports.SuiChainOps = SuiChainOps;

package/dist/quote/index.d.ts

@@ -1 +1,8 @@
 export * from './pricing';
+export * from './pool_event';
+export * from './chain_ops';
+export * from './quote_trace';
+export * from './quote_amount';
+export * from './verify';
+export * from './tick';
+export * from './abstract_dex_quote';

package/dist/quote/index.js

@@ -15,3 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./pricing"), exports);
+__exportStar(require("./pool_event"), exports);
+__exportStar(require("./chain_ops"), exports);
+__exportStar(require("./quote_trace"), exports);
+__exportStar(require("./quote_amount"), exports);
+__exportStar(require("./verify"), exports);
+__exportStar(require("./tick"), exports);
+__exportStar(require("./abstract_dex_quote"), exports);

package/dist/quote/pool_event.d.ts

@@ -0,0 +1,21 @@
+export type SuiEventKind = 'swap' | 'add' | 'remove';
+export interface SuiPoolEvent {
+    pool_address: string;
+    dex_id: string;
+    pair: string;
+    type: string;
+    blockNumber: number;
+    txIndex: number;
+    txHash: string;
+    blockTime: number;
+    eventKind?: SuiEventKind;
+    afterSqrtPrice?: string;
+    tick?: number;
+    liquidity?: string;
+    tickLower?: number;
+    tickUpper?: number;
+    liquidityDelta?: string;
+    amount0?: string;
+    amount1?: string;
+}
+export declare function get_sui_pool_event_channel(chain_id: string): string;

package/dist/quote/pool_event.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_sui_pool_event_channel = get_sui_pool_event_channel;
+function get_sui_pool_event_channel(chain_id) {
+    return `${chain_id}:pool:events`;
+}

package/dist/quote/pricing/token_price_cache.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenPriceCache = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
@@ -17,26 +8,24 @@ class TokenPriceCache {
         this.PRICE_CACHE_TIMEOUT_MILLS = parseInt(process.env.PRICE_CACHE_TIMEOUT_MILLS || Number(1000 * 60 * 60 * 1).toString());
         (0, dist_1.log_info)(`代币价格缓存超时时间: ${this.PRICE_CACHE_TIMEOUT_MILLS} ms`);
     }
-    getTokenPrice(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let tokenParts = tokenAddress.split('::');
-            tokenParts[0] = tokenParts[0].toLowerCase();
-            tokenAddress = tokenParts.join('::');
-            const now = Date.now();
-            const cachedData = this.tokenPriceCache.get(tokenAddress);
-            if (cachedData && (now - cachedData.timestamp) < this.PRICE_CACHE_TIMEOUT_MILLS) {
-                (0, dist_1.log_debug)(`use cached token price: ${tokenAddress}, price: ${cachedData.price}`, '');
-                return cachedData;
-            }
-            const priceMap = yield (0, dist_1.get_sui_token_price_info)([tokenAddress]);
-            const tokenPrice = priceMap.get(tokenAddress);
-            if (!tokenPrice || !tokenPrice.price || Number(tokenPrice.price) <= 0) {
-                throw new Error(`无法获取代币 ${tokenAddress} 的有效USD价格`);
-            }
-            const newPrice = { price: tokenPrice.price, timestamp: now };
-            this.tokenPriceCache.set(tokenAddress, newPrice);
-            return newPrice;
-        });
+    async getTokenPrice(tokenAddress) {
+        let tokenParts = tokenAddress.split('::');
+        tokenParts[0] = tokenParts[0].toLowerCase();
+        tokenAddress = tokenParts.join('::');
+        const now = Date.now();
+        const cachedData = this.tokenPriceCache.get(tokenAddress);
+        if (cachedData && (now - cachedData.timestamp) < this.PRICE_CACHE_TIMEOUT_MILLS) {
+            (0, dist_1.log_debug)(`use cached token price: ${tokenAddress}, price: ${cachedData.price}`, '');
+            return cachedData;
+        }
+        const priceMap = await (0, dist_1.get_sui_token_price_info)([tokenAddress]);
+        const tokenPrice = priceMap.get(tokenAddress);
+        if (!tokenPrice || !tokenPrice.price || Number(tokenPrice.price) <= 0) {
+            throw new Error(`无法获取代币 ${tokenAddress} 的有效USD价格`);
+        }
+        const newPrice = { price: tokenPrice.price, timestamp: now };
+        this.tokenPriceCache.set(tokenAddress, newPrice);
+        return newPrice;
     }
 }
 exports.TokenPriceCache = TokenPriceCache;

package/dist/quote/quote_amount.d.ts

@@ -0,0 +1,4 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+import Decimal from 'decimal.js';
+export declare function getQuoteAmountUsd(poolInfo: StandardPoolInfoType): number;
+export declare function usdToTokenUiAmount(amountInUsd: number, tokenAddress: string): Promise<Decimal>;

package/dist/quote/quote_amount.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuoteAmountUsd = getQuoteAmountUsd;
+exports.usdToTokenUiAmount = usdToTokenUiAmount;
+const ttd_core_1 = require("@clonegod/ttd-core");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+function getQuoteAmountUsd(poolInfo) {
+    const envValue = Number(process.env.QUOTE_AMOUNT_USD);
+    if (envValue > 0) {
+        return envValue;
+    }
+    return poolInfo.quote_amount_usd;
+}
+async function usdToTokenUiAmount(amountInUsd, tokenAddress) {
+    const priceMap = await (0, ttd_core_1.get_sui_token_price_info)([tokenAddress]);
+    const price = priceMap.get(tokenAddress)?.price;
+    if (!price || price === '0') {
+        throw new Error(`price not available for ${tokenAddress}`);
+    }
+    return new decimal_js_1.default(amountInUsd).div(new decimal_js_1.default(price));
+}

package/dist/quote/quote_trace.d.ts

@@ -0,0 +1,16 @@
+export declare class QuoteTrace {
+    readonly poolName: string;
+    readonly poolAddress: string;
+    blockNumber: number;
+    source: string;
+    private startTime;
+    private marks;
+    private data;
+    private error;
+    constructor(poolName: string, poolAddress: string, blockNumber?: number, source?: string);
+    mark(name: string): void;
+    set(key: string, value: any): void;
+    markError(stage: string, message: string): void;
+    private buildTimeline;
+    flush(): void;
+}