@clonegod/ttd-core 3.1.79 → 3.1.81

package/dist/quote/depth_tier.d.ts

@@ -39,9 +39,3 @@ export interface OrderbookEntry {
 export declare function toOrderbookEntry(q: QuoteEntry): OrderbookEntry;
 export declare const DEFAULT_TIER_PCT = 0.2;
 export declare function getDepthPricePctLevels(): number[];
-export declare function assertTierPriceInvariant(poolName: string, side: 'ASK' | 'BID', tiers: Array<{
-    pct: number;
-    price: number;
-    amount: number;
-    amount_in: number;
-}>, log_warn?: (msg: string) => void): void;

package/dist/quote/depth_tier.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_TIER_PCT = void 0;
 exports.toOrderbookEntry = toOrderbookEntry;
 exports.getDepthPricePctLevels = getDepthPricePctLevels;
-exports.assertTierPriceInvariant = assertTierPriceInvariant;
 function toOrderbookEntry(q) {
     return {
         price: q.price,
@@ -35,34 +34,3 @@ function getDepthPricePctLevels() {
     _pctLevelsCache = levels;
     return levels;
 }
-const _tierInvariantLastWarn = new Map();
-function assertTierPriceInvariant(poolName, side, tiers, log_warn) {
-    if (!tiers || tiers.length === 0)
-        return;
-    const TOL_REL = 0.0001;
-    for (const t of tiers) {
-        if (!(t.price > 0) || !(t.amount > 0) || !(t.amount_in > 0))
-            continue;
-        const expected = side === 'ASK'
-            ? t.amount_in / t.amount
-            : t.amount / t.amount_in;
-        if (expected <= 0)
-            continue;
-        const relDiff = Math.abs(t.price - expected) / expected;
-        if (relDiff > TOL_REL) {
-            const key = `${poolName}_${side}_${t.pct}`;
-            const now = Date.now();
-            if ((now - (_tierInvariantLastWarn.get(key) || 0)) < 60000)
-                return;
-            _tierInvariantLastWarn.set(key, now);
-            const msg = `[tier-invariant] ${poolName} ${side} pct=${t.pct} price=${t.price.toFixed(10)} ` +
-                `≠ expected ${expected.toFixed(10)} (relDiff=${(relDiff * 10000).toFixed(2)}bps, amount_in=${t.amount_in}, amount=${t.amount}) ` +
-                `— check tier.price formula! Must be effective avg price including fee`;
-            if (log_warn)
-                log_warn(msg);
-            else
-                console.warn(msg);
-            return;
-        }
-    }
-}

package/dist/token/price/get_base_token_price.d.ts

@@ -0,0 +1,5 @@
+import { FormattedTokenPrice } from "../types";
+import type { PriceSource } from './get_bsc_token_price';
+export declare function get_base_token_price_info(addresses: string[], opts?: {
+    source?: PriceSource;
+}): Promise<Map<string, FormattedTokenPrice>>;

package/dist/token/price/get_base_token_price.js

@@ -0,0 +1,113 @@
+"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.get_base_token_price_info = get_base_token_price_info;
+require('dotenv').config();
+const index_1 = require("../../index");
+const defi_llama_1 = require("./defi_llama");
+const gecko_terminal_1 = require("./gecko_terminal");
+const price_cache_1 = require("./price_cache");
+const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
+const WETH_ADDR = '0x4200000000000000000000000000000000000006';
+function get_base_token_price_info(addresses, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const source = (_a = opts === null || opts === void 0 ? void 0 : opts.source) !== null && _a !== void 0 ? _a : 'cache_only';
+        addresses = addresses.map(addr => addr.toLowerCase());
+        const wantsNativeEth = addresses.includes(ZERO_ADDR);
+        if (wantsNativeEth) {
+            addresses = addresses.map(a => a === ZERO_ADDR ? WETH_ADDR : a);
+            addresses = Array.from(new Set(addresses));
+        }
+        const result = new Map();
+        const cachedChannel = {
+            name: 'CachedPrice',
+            fetchFn: price_cache_1.fetchPriceFromCache,
+            batchSize: 100,
+            batchDelay: 1000,
+        };
+        const externalChannels = [
+            {
+                name: 'DefiLlama',
+                fetchFn: (address_list) => (0, defi_llama_1.fetchPriceFromDefiLlama)(index_1.CHAIN_ID.BASE, address_list),
+                batchSize: 10,
+                batchDelay: 1000,
+            },
+            {
+                name: 'GeckoTerminal',
+                fetchFn: (address_list) => (0, gecko_terminal_1.fetchPriceFromGeckoTerminal)(index_1.CHAIN_ID.BASE, address_list),
+                batchSize: 10,
+                batchDelay: 1000,
+            },
+        ];
+        const PRICE_CHANNELS = source === 'cache_only' ? [cachedChannel] :
+            source === 'cache_first' ? [cachedChannel, ...externalChannels] :
+                [...externalChannels];
+        const externalHits = [];
+        try {
+            for (const channel of PRICE_CHANNELS) {
+                if (addresses.length === 0)
+                    break;
+                (0, index_1.log_debug)(`[get_base_token_price_info] Processing ${addresses.length} tokens using ${channel.name}`);
+                const batches = (0, index_1.chunkArray)(addresses, channel.batchSize);
+                let remainingAddresses = [...addresses];
+                for (let i = 0; i < batches.length; i++) {
+                    const batch = batches[i];
+                    if (batch.length === 0)
+                        continue;
+                    try {
+                        const channelResult = yield channel.fetchFn(batch);
+                        for (const [address, priceInfo] of channelResult.entries()) {
+                            result.set(address, priceInfo);
+                            remainingAddresses = remainingAddresses.filter(addr => addr !== address);
+                            if (channel.name !== 'CachedPrice') {
+                                externalHits.push({ address, price: priceInfo.price, source: channel.name });
+                            }
+                        }
+                    }
+                    catch (error) {
+                        (0, index_1.log_warn)(`[get_base_token_price_info] Error processing batch ${i + 1} with ${channel.name}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    if (i < batches.length - 1) {
+                        yield (0, index_1.sleep)(channel.batchDelay);
+                    }
+                }
+                addresses = [...remainingAddresses];
+                if (addresses.length === 0)
+                    break;
+            }
+            if (externalHits.length > 0) {
+                yield (0, price_cache_1.cache_new_market_price_batch)(externalHits);
+            }
+            if (source === 'cache_only' && addresses.length > 0) {
+                (0, price_cache_1.warnPriceCacheMiss)(addresses);
+            }
+            if (source === 'force_fetch' && result.size === 0) {
+                throw new Error(`Unable to get price information for any token: ${addresses.join(', ')}`);
+            }
+            if (source !== 'cache_only' && addresses.length > 0) {
+                (0, index_1.log_warn)(`[get_base_token_price_info] Failed to get prices for ${addresses.length} tokens after trying all channels: ${addresses.join(', ')}`);
+            }
+            if (wantsNativeEth) {
+                const wethInfo = result.get(WETH_ADDR);
+                if (wethInfo)
+                    result.set(ZERO_ADDR, wethInfo);
+            }
+            return result;
+        }
+        catch (error) {
+            if (source === 'force_fetch') {
+                throw new Error(`Failed to get token price information: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return result;
+        }
+    });
+}

package/dist/token/price/index.d.ts

@@ -1,4 +1,5 @@
 export * from './get_bsc_token_price';
+export * from './get_base_token_price';
 export * from './get_eth_token_price';
 export * from './get_solana_token_price';
 export * from './get_tron_token_price';

package/dist/token/price/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./get_bsc_token_price"), exports);
+__exportStar(require("./get_base_token_price"), exports);
 __exportStar(require("./get_eth_token_price"), exports);
 __exportStar(require("./get_solana_token_price"), exports);
 __exportStar(require("./get_tron_token_price"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-core",
-    "version": "3.1.79",
+    "version": "3.1.81",
     "description": "Common types and utilities for trading systems - use `npm run push` to publish",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",