@clonegod/ttd-base-common 1.1.2 → 1.1.4

package/dist/common/constants.d.ts

@@ -17,4 +17,5 @@ export declare const EVENT_SIGNATURES: {
     BURN: string;
 };
 export declare const UniswapV3PoolABI: string[];
+export declare const SlipstreamV3PoolABI: string[];
 export declare const UniswapV3RouterABI: string[];

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniswapV3RouterABI = exports.UniswapV3PoolABI = exports.EVENT_SIGNATURES = exports.EVENT_NAMES = exports.WETH_ADDRESS = exports.NATIVE_ETH_ADDRESS = exports.BASE_CHAIN_ID = void 0;
+exports.UniswapV3RouterABI = exports.SlipstreamV3PoolABI = exports.UniswapV3PoolABI = exports.EVENT_SIGNATURES = exports.EVENT_NAMES = exports.WETH_ADDRESS = exports.NATIVE_ETH_ADDRESS = exports.BASE_CHAIN_ID = void 0;
 exports.BASE_CHAIN_ID = 8453;
 exports.NATIVE_ETH_ADDRESS = '0x0000000000000000000000000000000000000000';
 exports.WETH_ADDRESS = '0x4200000000000000000000000000000000000006';
@@ -33,6 +33,20 @@ exports.UniswapV3PoolABI = [
     "event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)",
     "event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)"
 ];
+exports.SlipstreamV3PoolABI = [
+    "function slot0() external view returns (uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, bool unlocked)",
+    "function liquidity() external view returns (uint128)",
+    "function tickSpacing() external view returns (int24)",
+    "function factory() external view returns (address)",
+    "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, 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)",
+    "event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)"
+];
 exports.UniswapV3RouterABI = [
     'function exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)',
     'function exactInput(tuple(bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum)) external payable returns (uint256 amountOut)',

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.2",
+  "version": "1.1.4",
   "description": "Base common library",
   "license": "UNLICENSED",
   "main": "dist/index.js",