@clonegod/ttd-base-common 1.1.3 → 1.1.5

package/dist/appconfig/base_env_args.d.ts

@@ -37,6 +37,7 @@ export declare class BaseEnvArgs extends EnvArgs {
     tick_cache_neighboring_words: number;
     tick_cache_ttl: number;
     tick_cache_min_update_interval: number;
+    standard_wss_enabled: boolean;
     flashblocks_enabled: boolean;
     flashblocks_quicknode_wss: string;
     flashblocks_dedup_ttl_ms: number;

package/dist/appconfig/base_env_args.js

@@ -38,6 +38,7 @@ const constants_1 = require("../common/constants");
     min_quote_interval_ms: { env: 'MIN_QUOTE_INTERVAL_MS', type: 'number', default: 10000, desc: '最小询价间隔(ms)' },
     use_pricefeed_for_orderbook: { env: 'USE_PRICEFEED_FOR_ORDERBOOK', type: 'boolean', default: false, desc: 'PriceFeed (v3 source) 报价是否推 orderbook' },
     trade_parse_fetch_block_time: { env: 'TRADE_PARSE_FETCH_BLOCK_TIME', type: 'boolean', default: false, desc: '解析交易 receipt 时是否额外 RPC 查询 block 时间戳' },
+    standard_wss_enabled: { env: 'STANDARD_WSS_ENABLED', type: 'boolean', default: false, desc: '标准 WSS confirmed logs 订阅开关；默认关闭（newFlashblocks 已替代）' },
     flashblocks_enabled: { env: 'FLASHBLOCKS_ENABLED', type: 'boolean', default: true, desc: 'Flashblocks pending logs 主路径开关' },
     flashblocks_quicknode_wss: { env: 'FLASHBLOCKS_QUICKNODE_WSS', type: 'string', default: '', desc: 'QuickNode Flashblocks WSS endpoint（FLASHBLOCKS_ENABLED=true 时必填；不提供默认值，避免误用 demo endpoint）' },
     flashblocks_dedup_ttl_ms: { env: 'FLASHBLOCKS_DEDUP_TTL_MS', type: 'number', default: 30000, desc: '事件去重 TTL：Flashblocks + 标准 WSS 同 tx 重复推送的去重窗口(ms)' },

package/dist/common/constants.js

@@ -41,7 +41,7 @@ exports.SlipstreamV3PoolABI = [
     "function token0() external view returns (address)",
     "function token1() external view returns (address)",
     "function fee() external view returns (uint24)",
-    "function ticks(int24 tick) external view returns (uint128 liquidityGross, int128 liquidityNet, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized)",
+    "function ticks(int24 tick) external view returns (uint128 liquidityGross, int128 liquidityNet, uint128 stakedLiquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, uint256 rewardGrowthOutsideX128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized)",
     "function tickBitmap(int16 wordPosition) external view returns (uint256)",
     "event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1)",
     "event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)",

package/dist/quote/get_base_token_price.d.ts

@@ -1,6 +1,5 @@
 import { FormattedTokenPrice } from '@clonegod/ttd-core';
-type PriceSource = 'force_fetch' | 'cache_only' | 'cache_first';
+export type PriceSource = 'cache_only' | 'cache_first' | 'force_fetch';
 export declare function get_base_token_price_info(addresses: string[], opts?: {
     source?: PriceSource;
 }): Promise<Map<string, FormattedTokenPrice>>;
-export {};

package/dist/quote/get_base_token_price.js

@@ -4,8 +4,9 @@ exports.get_base_token_price_info = get_base_token_price_info;
 const ttd_core_1 = require("@clonegod/ttd-core");
 const DEFI_LLAMA_BASE_CHAIN = 'base';
 const GECKO_BASE_NETWORK = 'base';
-const BATCH_SIZE = 10;
-const BATCH_DELAY_MS = 1000;
+const EXTERNAL_BATCH_SIZE = 10;
+const EXTERNAL_BATCH_DELAY_MS = 1000;
+const CACHE_BATCH_SIZE = 100;
 async function fetchFromDefiLlama(addresses) {
     const result = new Map();
     if (addresses.length === 0)
@@ -54,36 +55,57 @@ async function fetchFromGeckoTerminal(addresses) {
     }
     return result;
 }
+const CACHE_CHANNEL = {
+    name: 'CachedPrice',
+    fn: ttd_core_1.fetchPriceFromCache,
+    batchSize: CACHE_BATCH_SIZE,
+    batchDelayMs: 0,
+};
+const EXTERNAL_CHANNELS = [
+    { name: 'DefiLlama', fn: fetchFromDefiLlama, batchSize: EXTERNAL_BATCH_SIZE, batchDelayMs: EXTERNAL_BATCH_DELAY_MS },
+    { name: 'GeckoTerminal', fn: fetchFromGeckoTerminal, batchSize: EXTERNAL_BATCH_SIZE, batchDelayMs: EXTERNAL_BATCH_DELAY_MS },
+];
 async function get_base_token_price_info(addresses, opts) {
+    const source = opts?.source ?? 'cache_only';
     addresses = Array.from(new Set(addresses.map(a => a.toLowerCase())));
     const result = new Map();
     if (addresses.length === 0)
         return result;
-    const channels = [
-        { name: 'DefiLlama', fn: fetchFromDefiLlama },
-        { name: 'GeckoTerminal', fn: fetchFromGeckoTerminal },
-    ];
+    const channels = source === 'cache_only' ? [CACHE_CHANNEL] :
+        source === 'cache_first' ? [CACHE_CHANNEL, ...EXTERNAL_CHANNELS] :
+            [...EXTERNAL_CHANNELS];
+    const externalHits = [];
     let remaining = [...addresses];
     for (const ch of channels) {
         if (remaining.length === 0)
             break;
-        const batches = (0, ttd_core_1.chunkArray)(remaining, BATCH_SIZE);
+        const batches = (0, ttd_core_1.chunkArray)(remaining, ch.batchSize);
         (0, ttd_core_1.log_debug)(`[get_base_token_price] ${ch.name}: ${remaining.length} addrs in ${batches.length} batches`);
         for (let i = 0; i < batches.length; i++) {
             try {
                 const hit = await ch.fn(batches[i]);
-                for (const [k, v] of hit)
+                for (const [k, v] of hit) {
                     result.set(k, v);
+                    if (ch.name !== 'CachedPrice') {
+                        externalHits.push({ address: k, price: v.price, source: ch.name });
+                    }
+                }
             }
             catch (e) {
                 (0, ttd_core_1.log_warn)(`[get_base_token_price] ${ch.name} batch ${i + 1} error: ${e?.message ?? e}`);
             }
-            if (i < batches.length - 1)
-                await (0, ttd_core_1.sleep)(BATCH_DELAY_MS);
+            if (i < batches.length - 1 && ch.batchDelayMs > 0)
+                await (0, ttd_core_1.sleep)(ch.batchDelayMs);
         }
         remaining = remaining.filter(a => !result.has(a));
     }
-    if (opts?.source === 'force_fetch' && result.size === 0) {
+    if (externalHits.length > 0) {
+        await (0, ttd_core_1.cache_new_market_price_batch)(externalHits);
+    }
+    if (source === 'cache_only' && remaining.length > 0) {
+        (0, ttd_core_1.warnPriceCacheMiss)(remaining);
+    }
+    if (source === 'force_fetch' && result.size === 0) {
         throw new Error(`Unable to fetch price for any token: ${addresses.join(', ')}`);
     }
     return result;

package/dist/quote/tick/tick_lens_loaders.d.ts

@@ -22,3 +22,18 @@ export declare class MulticallTickLensLoader implements TickLensLoader {
     loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
     private loadBitmapWordsIndividually;
 }
+export declare class SlipstreamTickLensLoader implements TickLensLoader {
+    private ethersLib;
+    private provider;
+    private multicallAddress;
+    private poolIface;
+    private multicallContract;
+    private tickSpacingCache;
+    constructor(params: {
+        ethersLib: any;
+        provider: any;
+        multicallAddress?: string;
+    });
+    loadBitmapWords(poolAddress: string, bitmapIndexes: number[]): Promise<Map<number, TickInfo>>;
+    private getTickSpacing;
+}

package/dist/quote/tick/tick_lens_loaders.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MulticallTickLensLoader = exports.BASE_TICK_LENS_ADDRESSES = exports.MULTICALL3_ADDRESS = void 0;
+exports.SlipstreamTickLensLoader = exports.MulticallTickLensLoader = exports.BASE_TICK_LENS_ADDRESSES = exports.MULTICALL3_ADDRESS = void 0;
 const ttd_core_1 = require("@clonegod/ttd-core");
+const constants_1 = require("../../common/constants");
 exports.MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
 exports.BASE_TICK_LENS_ADDRESSES = {
     UNISWAP_V3: '0x0CdeE061c75D43c82520eD998C23ac2991c9ac6d',
@@ -156,3 +157,88 @@ class MulticallTickLensLoader {
     }
 }
 exports.MulticallTickLensLoader = MulticallTickLensLoader;
+class SlipstreamTickLensLoader {
+    constructor(params) {
+        this.tickSpacingCache = new Map();
+        this.ethersLib = params.ethersLib;
+        this.provider = params.provider;
+        this.multicallAddress = params.multicallAddress || exports.MULTICALL3_ADDRESS;
+        const InterfaceClass = params.ethersLib.Interface || params.ethersLib.utils?.Interface;
+        if (!InterfaceClass) {
+            throw new Error('ethersLib.Interface not found, ensure ethers v5 or v6 is passed');
+        }
+        this.poolIface = new InterfaceClass(constants_1.SlipstreamV3PoolABI);
+        this.multicallContract = new params.ethersLib.Contract(this.multicallAddress, MULTICALL3_ABI, this.provider);
+    }
+    async loadBitmapWords(poolAddress, bitmapIndexes) {
+        const result = new Map();
+        if (bitmapIndexes.length === 0)
+            return result;
+        try {
+            const tickSpacing = await this.getTickSpacing(poolAddress);
+            const bitmapCalls = bitmapIndexes.map(idx => ({
+                target: poolAddress,
+                callData: this.poolIface.encodeFunctionData('tickBitmap', [idx]),
+            }));
+            const callMethod = this.multicallContract.aggregate.staticCall || this.multicallContract.callStatic?.aggregate;
+            const [, bitmapReturnData] = await callMethod(bitmapCalls);
+            const populatedTicks = [];
+            for (let i = 0; i < bitmapReturnData.length; i++) {
+                try {
+                    const decoded = this.poolIface.decodeFunctionResult('tickBitmap', bitmapReturnData[i]);
+                    const bitmap = typeof decoded[0] === 'bigint' ? decoded[0] : BigInt(decoded[0].toString());
+                    if (bitmap === BigInt(0))
+                        continue;
+                    const wordPos = bitmapIndexes[i];
+                    for (let bit = 0; bit < 256; bit++) {
+                        if ((bitmap & (BigInt(1) << BigInt(bit))) !== BigInt(0)) {
+                            const compressed = wordPos * 256 + bit;
+                            populatedTicks.push(compressed * tickSpacing);
+                        }
+                    }
+                }
+                catch (e) {
+                    (0, ttd_core_1.log_warn)(`[SlipstreamTickLens] decode tickBitmap idx=${bitmapIndexes[i]} failed: ${e.message}`);
+                }
+            }
+            if (populatedTicks.length === 0) {
+                (0, ttd_core_1.log_debug)(`[SlipstreamTickLens] no populated ticks in ${bitmapIndexes.length} bitmap words for ${poolAddress}`);
+                return result;
+            }
+            const tickCalls = populatedTicks.map(t => ({
+                target: poolAddress,
+                callData: this.poolIface.encodeFunctionData('ticks', [t]),
+            }));
+            const [, tickReturnData] = await callMethod(tickCalls);
+            for (let i = 0; i < tickReturnData.length; i++) {
+                try {
+                    const decoded = this.poolIface.decodeFunctionResult('ticks', tickReturnData[i]);
+                    const liquidityGross = typeof decoded[0] === 'bigint' ? decoded[0] : BigInt(decoded[0].toString());
+                    const liquidityNet = typeof decoded[1] === 'bigint' ? decoded[1] : BigInt(decoded[1].toString());
+                    if (liquidityGross === BigInt(0) && liquidityNet === BigInt(0))
+                        continue;
+                    result.set(populatedTicks[i], { liquidityNet, liquidityGross });
+                }
+                catch (e) {
+                    (0, ttd_core_1.log_warn)(`[SlipstreamTickLens] decode ticks(${populatedTicks[i]}) failed: ${e.message}`);
+                }
+            }
+            (0, ttd_core_1.log_debug)(`[SlipstreamTickLens] Loaded ${result.size}/${populatedTicks.length} ticks from ${bitmapIndexes.length} bitmap words (2 RPC calls)`);
+        }
+        catch (error) {
+            (0, ttd_core_1.log_warn)(`[SlipstreamTickLens] multicall failed for ${poolAddress}: ${error.message}`);
+        }
+        return result;
+    }
+    async getTickSpacing(poolAddress) {
+        const cached = this.tickSpacingCache.get(poolAddress);
+        if (cached !== undefined)
+            return cached;
+        const poolContract = new this.ethersLib.Contract(poolAddress, constants_1.SlipstreamV3PoolABI, this.provider);
+        const ts = await poolContract.tickSpacing();
+        const value = Number(ts);
+        this.tickSpacingCache.set(poolAddress, value);
+        return value;
+    }
+}
+exports.SlipstreamTickLensLoader = SlipstreamTickLensLoader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-base-common",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Base common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",
@@ -14,7 +14,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "3.1.75",
+    "@clonegod/ttd-core": "3.1.76",
     "axios": "1.15.0",
     "dotenv": "^16.4.7",
     "ethers": "^5.8.0"