@clonegod/ttd-bsc-common 3.1.63 → 3.1.65

package/dist/quote/index.d.ts

@@ -5,3 +5,4 @@ export * from './depth';
 export * from './verify';
 export * from './price_feed_handler';
 export * from './quote_amount';
+export * from './preload_token_prices';

package/dist/quote/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./depth"), exports);
 __exportStar(require("./verify"), exports);
 __exportStar(require("./price_feed_handler"), exports);
 __exportStar(require("./quote_amount"), exports);
+__exportStar(require("./preload_token_prices"), exports);

package/dist/quote/preload_token_prices.d.ts

@@ -0,0 +1,2 @@
+import { StandardPoolInfoType } from '@clonegod/ttd-core';
+export declare function preloadTokenPrices(pool_list: StandardPoolInfoType[], label?: string): Promise<void>;

package/dist/quote/preload_token_prices.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preloadTokenPrices = preloadTokenPrices;
+const ttd_core_1 = require("@clonegod/ttd-core");
+async function preloadTokenPrices(pool_list, label = 'Quote') {
+    if (!pool_list || pool_list.length === 0)
+        return;
+    const addrSet = new Set();
+    for (const pool of pool_list) {
+        if (pool.tokenA?.address)
+            addrSet.add(pool.tokenA.address.toLowerCase());
+        if (pool.tokenB?.address)
+            addrSet.add(pool.tokenB.address.toLowerCase());
+    }
+    const addresses = Array.from(addrSet);
+    if (addresses.length === 0)
+        return;
+    try {
+        const priceMap = await (0, ttd_core_1.get_bsc_token_price_info)(addresses, { source: 'force_fetch' });
+        const got = [];
+        const miss = [];
+        for (const a of addresses) {
+            if (priceMap.get(a)?.price)
+                got.push(a);
+            else
+                miss.push(a);
+        }
+        (0, ttd_core_1.log_info)(`[${label}] preloadTokenPrices done, total=${addresses.length}, got=${got.length}, miss=${miss.length}`);
+        if (miss.length > 0) {
+            (0, ttd_core_1.log_warn)(`[${label}] preloadTokenPrices missing: ${miss.join(', ')}`);
+        }
+    }
+    catch (err) {
+        (0, ttd_core_1.log_warn)(`[${label}] preloadTokenPrices error (non-fatal): ${err.message}`);
+    }
+}

package/dist/quote/price_feed_handler.js

@@ -11,45 +11,33 @@ function buildQuoteFromPriceFeed(poolInfo, data) {
         return null;
     }
     const normSymbol = (s) => {
-        const u = s.toUpperCase();
+        const u = (s || '').toUpperCase();
         return u === 'WBNB' ? 'BNB' : u;
     };
-    let askPrice;
-    let bidPrice;
-    let baseToken;
-    let quoteToken;
     const tokenAIsQuote = normSymbol(tokenA.symbol) === normSymbol(quoteTokenSymbol);
     const tokenBIsQuote = normSymbol(tokenB.symbol) === normSymbol(quoteTokenSymbol);
     if (!tokenAIsQuote && !tokenBIsQuote) {
-        (0, ttd_core_1.log_warn)(`[PriceFeed] quote_token ${quoteTokenSymbol} not found in pool ${poolInfo.pool_name} (tokenA=${tokenA.symbol}, tokenB=${tokenB.symbol})`);
+        (0, ttd_core_1.log_warn)(`[PriceFeed] quote_token "${quoteTokenSymbol}" 在池子配置里找不到 (tokenA=${tokenA.symbol}, tokenB=${tokenB.symbol}, pool=${poolInfo.pool_name})`);
         return null;
     }
+    let askPrice;
+    let bidPrice;
+    let baseToken;
+    let quoteToken;
     if (tokenAIsQuote) {
         quoteToken = tokenA;
         baseToken = tokenB;
+        askPrice = data.askToken1InToken0;
+        bidPrice = data.bidToken1InToken0;
     }
     else {
         quoteToken = tokenB;
         baseToken = tokenA;
-    }
-    const feedToken0 = normSymbol(data.token0Symbol || '');
-    const feedToken1 = normSymbol(data.token1Symbol || '');
-    const baseSymbolNorm = normSymbol(baseToken.symbol);
-    const quoteSymbolNorm = normSymbol(quoteToken.symbol);
-    if (normSymbol(feedToken0) === quoteSymbolNorm) {
-        askPrice = data.askToken1InToken0;
-        bidPrice = data.bidToken1InToken0;
-    }
-    else if (normSymbol(feedToken1) === quoteSymbolNorm) {
         askPrice = data.askToken0InToken1;
         bidPrice = data.bidToken0InToken1;
     }
-    else {
-        (0, ttd_core_1.log_warn)(`[PriceFeed] Cannot match quote_token symbol: quote=${quoteSymbolNorm}, feed=[${feedToken0}/${feedToken1}], pool=${poolInfo.pool_name}`);
-        return null;
-    }
     if (!askPrice || !bidPrice) {
-        (0, ttd_core_1.log_warn)(`[PriceFeed] Missing price data for ${poolInfo.pool_name}`);
+        (0, ttd_core_1.log_warn)(`[PriceFeed] Missing price for pool=${poolInfo.pool_name}, direction=${tokenAIsQuote ? 'token1InToken0' : 'token0InToken1'}, feedSymbols=[${data.token0Symbol}/${data.token1Symbol}]`);
         return null;
     }
     const makeQuoteResult = (price, input, output) => ({

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

@@ -1,2 +1,2 @@
 export { QuotePriceVerify } from './quote_price_verify';
-export type { CheckSwapParams, CheckSyncParams } from './quote_price_verify';
+export type { CheckSwapParams } from './quote_price_verify';

package/dist/quote/verify/quote_price_verify.d.ts

@@ -16,30 +16,11 @@ export interface CheckSwapParams {
     };
     swapperDeltaConvention?: boolean;
 }
-export interface CheckSyncParams {
-    poolAddress: string;
-    poolName: string;
-    blockNumber: number;
-    reserve0: string;
-    reserve1: string;
-    token0Address: string;
-    token1Address: string;
-    token0Decimals: number;
-    token1Decimals: number;
-    poolInfo: {
-        tokenA: any;
-        tokenB: any;
-        quote_token: string;
-    };
-    txHash?: string;
-}
 export declare class QuotePriceVerify {
     private quoteCache;
-    private reserveCache;
     private get enabled();
-    seedReserves(poolAddress: string, reserve0: string, reserve1: string): void;
     cacheQuote(poolAddress: string, priceId: string, source: string, askPrice: number, bidPrice: number, blockNumber: number, quoteAmountUsd: number, token0PriceUsd?: number, token1PriceUsd?: number): void;
     checkSwap(params: CheckSwapParams): void;
-    checkSync(params: CheckSyncParams): void;
+    private deriveSwapDirection;
     private compareAndLog;
 }

package/dist/quote/verify/quote_price_verify.js

@@ -6,29 +6,28 @@ const ttd_core_1 = require("@clonegod/ttd-core");
 class QuotePriceVerify {
     constructor() {
         this.quoteCache = new Map();
-        this.reserveCache = new Map();
     }
     get enabled() {
         return process.env.VERIFY_QUOTE_PRICE === 'true';
     }
-    seedReserves(poolAddress, reserve0, reserve1) {
-        if (!this.enabled)
-            return;
-        try {
-            this.reserveCache.set(poolAddress, {
-                reserve0: BigInt(reserve0),
-                reserve1: BigInt(reserve1),
-            });
-        }
-        catch { }
-    }
     cacheQuote(poolAddress, priceId, source, askPrice, bidPrice, blockNumber, quoteAmountUsd, token0PriceUsd = 0, token1PriceUsd = 0) {
         if (!this.enabled)
             return;
-        this.quoteCache.set(poolAddress, {
+        if (!source)
+            return;
+        let sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap) {
+            sourceMap = new Map();
+            this.quoteCache.set(poolAddress, sourceMap);
+        }
+        const existing = sourceMap.get(source);
+        const verifiedReferenceBlock = (existing && existing.referenceBlock === blockNumber)
+            ? existing.verifiedReferenceBlock
+            : 0;
+        sourceMap.set(source, {
             priceId, source, askPrice, bidPrice,
             referenceBlock: blockNumber,
-            verifiedReferenceBlock: 0,
+            verifiedReferenceBlock,
             quoteAmountUsd,
             token0PriceUsd, token1PriceUsd,
         });
@@ -36,85 +35,74 @@ class QuotePriceVerify {
     checkSwap(params) {
         if (!this.enabled)
             return;
-        const { poolAddress, poolName, blockNumber, txHash, amount0, amount1, poolInfo } = params;
-        const { token0Address, token1Address, token0Decimals, token1Decimals } = params;
-        const cached = this.quoteCache.get(poolAddress);
-        if (!cached)
-            return;
-        if (blockNumber !== cached.referenceBlock + 1)
+        const { poolAddress, blockNumber, txHash, poolInfo, token0Address } = params;
+        const sourceMap = this.quoteCache.get(poolAddress);
+        if (!sourceMap || sourceMap.size === 0)
             return;
-        if (cached.verifiedReferenceBlock === cached.referenceBlock)
+        const swapData = this.deriveSwapDirection(params);
+        if (!swapData)
             return;
-        cached.verifiedReferenceBlock = cached.referenceBlock;
+        const direction = (0, trade_direction_1.resolveTradeDirection)(poolInfo, true);
+        const inputIsQuoteToken = swapData.inputTokenAddress.toLowerCase() === direction.quoteToken.address.toLowerCase();
+        const isBuy = inputIsQuoteToken;
+        const execPriceStr = (0, trade_direction_1.calculateStandardPrice)(swapData.inputAmountUi, swapData.outputAmountUi, isBuy);
+        const execPrice = Number(execPriceStr);
+        if (execPrice <= 0)
+            return;
+        const verifiable = [];
+        for (const [source, cached] of sourceMap) {
+            if (blockNumber <= cached.referenceBlock)
+                continue;
+            if (cached.verifiedReferenceBlock === cached.referenceBlock)
+                continue;
+            const refPrice = isBuy ? cached.askPrice : cached.bidPrice;
+            if (refPrice <= 0)
+                continue;
+            cached.verifiedReferenceBlock = cached.referenceBlock;
+            const diff_bps = (refPrice - execPrice) / refPrice * 10000;
+            verifiable.push({ source, cached, refPrice, diff_bps });
+        }
+        if (verifiable.length === 0)
+            return;
+        verifiable.sort((a, b) => b.cached.referenceBlock - a.cached.referenceBlock);
+        const primary = verifiable[0];
+        const sources = {};
+        for (const r of verifiable) {
+            sources[r.source] = {
+                ask: r.cached.askPrice,
+                bid: r.cached.bidPrice,
+                diff_bps: parseFloat(r.diff_bps.toFixed(1)),
+                quote_block: r.cached.referenceBlock,
+            };
+        }
+        this.compareAndLog(poolAddress, params.poolName, poolInfo, primary.cached, swapData.inputTokenAddress, swapData.outputTokenAddress, swapData.inputAmountUi, swapData.outputAmountUi, primary.cached.token0PriceUsd, primary.cached.token1PriceUsd, token0Address, blockNumber, txHash, sources);
+    }
+    deriveSwapDirection(params) {
+        const { amount0, amount1, token0Address, token1Address, token0Decimals, token1Decimals } = params;
         const sign = params.swapperDeltaConvention ? -1n : 1n;
         const amt0 = BigInt(amount0) * sign;
         const amt1 = BigInt(amount1) * sign;
         if (amt0 === 0n && amt1 === 0n)
-            return;
-        let inputTokenAddress;
-        let outputTokenAddress;
-        let inputAmountUi;
-        let outputAmountUi;
+            return null;
         if (amt0 > 0n && amt1 < 0n) {
-            inputTokenAddress = token0Address;
-            outputTokenAddress = token1Address;
-            inputAmountUi = Number(amt0) / Math.pow(10, token0Decimals);
-            outputAmountUi = Number(-amt1) / Math.pow(10, token1Decimals);
+            return {
+                inputTokenAddress: token0Address,
+                outputTokenAddress: token1Address,
+                inputAmountUi: Number(amt0) / Math.pow(10, token0Decimals),
+                outputAmountUi: Number(-amt1) / Math.pow(10, token1Decimals),
+            };
         }
         else if (amt0 < 0n && amt1 > 0n) {
-            inputTokenAddress = token1Address;
-            outputTokenAddress = token0Address;
-            inputAmountUi = Number(amt1) / Math.pow(10, token1Decimals);
-            outputAmountUi = Number(-amt0) / Math.pow(10, token0Decimals);
-        }
-        else {
-            return;
-        }
-        this.compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, cached.token0PriceUsd, cached.token1PriceUsd, token0Address, blockNumber, txHash);
-    }
-    checkSync(params) {
-        if (!this.enabled)
-            return;
-        const { poolAddress, poolName, blockNumber, reserve0, reserve1, poolInfo, txHash } = params;
-        const { token0Address, token1Address, token0Decimals, token1Decimals } = params;
-        const cached = this.quoteCache.get(poolAddress);
-        if (!cached)
-            return;
-        if (blockNumber !== cached.referenceBlock + 1)
-            return;
-        if (cached.verifiedReferenceBlock === cached.referenceBlock)
-            return;
-        const newR0 = BigInt(reserve0);
-        const newR1 = BigInt(reserve1);
-        const oldReserves = this.reserveCache.get(poolAddress);
-        this.reserveCache.set(poolAddress, { reserve0: newR0, reserve1: newR1 });
-        if (!oldReserves)
-            return;
-        const delta0 = newR0 - oldReserves.reserve0;
-        const delta1 = newR1 - oldReserves.reserve1;
-        if ((delta0 > 0n && delta1 > 0n) || (delta0 < 0n && delta1 < 0n) || (delta0 === 0n && delta1 === 0n)) {
-            return;
-        }
-        cached.verifiedReferenceBlock = cached.referenceBlock;
-        let inputTokenAddress;
-        let outputTokenAddress;
-        let inputAmountUi;
-        let outputAmountUi;
-        if (delta0 > 0n && delta1 < 0n) {
-            inputTokenAddress = token0Address;
-            outputTokenAddress = token1Address;
-            inputAmountUi = Number(delta0) / Math.pow(10, token0Decimals);
-            outputAmountUi = Number(-delta1) / Math.pow(10, token1Decimals);
-        }
-        else {
-            inputTokenAddress = token1Address;
-            outputTokenAddress = token0Address;
-            inputAmountUi = Number(delta1) / Math.pow(10, token1Decimals);
-            outputAmountUi = Number(-delta0) / Math.pow(10, token0Decimals);
+            return {
+                inputTokenAddress: token1Address,
+                outputTokenAddress: token0Address,
+                inputAmountUi: Number(amt1) / Math.pow(10, token1Decimals),
+                outputAmountUi: Number(-amt0) / Math.pow(10, token0Decimals),
+            };
         }
-        this.compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, cached.token0PriceUsd, cached.token1PriceUsd, token0Address, blockNumber, txHash);
+        return null;
     }
-    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash) {
+    compareAndLog(poolAddress, poolName, poolInfo, cached, inputTokenAddress, outputTokenAddress, inputAmountUi, outputAmountUi, token0PriceUsd, token1PriceUsd, token0Address, swapBlockNumber, txHash, sources) {
         if (inputAmountUi <= 0 || outputAmountUi <= 0)
             return;
         let swapUsd = 0;
@@ -175,6 +163,7 @@ class QuotePriceVerify {
                 output_symbol: isBuy ? baseToken.symbol : quoteToken.symbol,
                 status,
                 time: Date.now(),
+                sources: sources || undefined,
             });
         }
         catch (_) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-bsc-common",
-  "version": "3.1.63",
+  "version": "3.1.65",
   "description": "BSC common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -14,7 +14,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.1.54",
+    "@clonegod/ttd-core": "3.1.55",
     "axios": "1.15.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0",