@steerprotocol/liquidity-meter 1.0.0

package/dist/prices.js

@@ -0,0 +1,205 @@
+import axios from 'axios';
+import { createMemoryClient, http } from 'tevm';
+function norm(addr) { return addr.toLowerCase(); }
+function dexSlugFromChainId(chainId) {
+    switch (Number(chainId)) {
+        case 1: return 'ethereum';
+        case 10: return 'optimism';
+        case 56: return 'bsc';
+        case 137: return 'polygon';
+        case 8453: return 'base';
+        case 42161: return 'arbitrum';
+        case 43114: return 'avalanche';
+        case 100: return 'gnosis';
+        case 324: return 'zksync';
+        case 1101: return 'polygon-zkevm';
+        default: return undefined;
+    }
+}
+export async function fetchPricesLlama(addresses) {
+    const uniq = Array.from(new Set(addresses.map(norm)));
+    if (!uniq.length)
+        return {};
+    const coinsParam = uniq.map((a) => `ethereum:${a}`).join(',');
+    const url = `https://coins.llama.fi/prices/current/${coinsParam}`;
+    const res = await axios.get(url, { timeout: 8000, maxRedirects: 3 });
+    const coins = res.data?.coins || {};
+    const out = {};
+    for (const a of uniq) {
+        const key = `ethereum:${a}`;
+        const p = coins[key]?.price;
+        if (typeof p === 'number' && Number.isFinite(p))
+            out[a] = p;
+    }
+    return out;
+}
+export async function fetchPricesCoingecko(addresses, apiKey) {
+    const uniq = Array.from(new Set(addresses.map(norm)));
+    if (!uniq.length)
+        return {};
+    const url = 'https://api.coingecko.com/api/v3/simple/token_price/ethereum';
+    const params = { contract_addresses: uniq.join(','), vs_currencies: 'usd' };
+    const headers = apiKey ? { 'x-cg-pro-api-key': apiKey } : undefined;
+    const res = await axios.get(url, { params, headers, timeout: 8000, maxRedirects: 3 });
+    const body = res.data || {};
+    const out = {};
+    for (const a of uniq) {
+        const ent = body[a];
+        const p = ent?.usd;
+        if (typeof p === 'number' && Number.isFinite(p))
+            out[a] = p;
+    }
+    return out;
+}
+export async function fetchTokenUSDPrices(opts) {
+    const { addresses, source = 'auto', rpcUrl, chainId, debug = false, reserveLimit = 100 } = opts;
+    const uniq = Array.from(new Set(addresses.map(norm)));
+    const byAddress = {};
+    const coingeckoKey = process.env.COINGECKO_API_KEY;
+    async function resolveChainId(rpc) {
+        try {
+            if (!rpc)
+                return undefined;
+            const client = createMemoryClient({ fork: { transport: http(rpc), blockTag: 'latest' }, loggingLevel: 'error' });
+            if (client.tevmReady)
+                await client.tevmReady();
+            const id = await client.getChainId();
+            return id;
+        }
+        catch (_) {
+            return undefined;
+        }
+    }
+    async function fetchPricesReserve({ addresses, chainId, limit = 100 }) {
+        if (!chainId)
+            return {};
+        const url = `https://api.reserve.org/discover/dtf`;
+        const params = { chainId, limit };
+        const res = await axios.get(url, { params, timeout: 8000, maxRedirects: 3 });
+        const arr = Array.isArray(res.data) ? res.data : [];
+        const out = {};
+        const set = new Set(addresses.map(norm));
+        for (const ent of arr) {
+            const addr = norm(ent.address || '');
+            if (set.has(addr)) {
+                const p = Number(ent.price);
+                if (Number.isFinite(p))
+                    out[addr] = p;
+            }
+        }
+        if (debug)
+            console.error(`[prices] reserve: chainId=${chainId} limit=${limit} returned=${arr.length} matched=${Object.keys(out).length}`);
+        return out;
+    }
+    async function fetchPricesDexscreener({ addresses, chainId }) {
+        if (!chainId)
+            return {};
+        const slug = dexSlugFromChainId(chainId);
+        if (!slug)
+            return {};
+        const out = {};
+        for (const addr of addresses.map(norm)) {
+            try {
+                const url = `https://api.dexscreener.com/token-pairs/v1/${slug}/${addr}`;
+                const res = await axios.get(url, { timeout: 8000, maxRedirects: 3 });
+                const arr = Array.isArray(res.data) ? res.data : [];
+                let best = null;
+                for (const ent of arr) {
+                    const base = norm(ent?.baseToken?.address || '');
+                    if (base !== addr)
+                        continue;
+                    const liq = Number(ent?.liquidity?.usd ?? 0);
+                    if (!best || liq > Number(best?.liquidity?.usd ?? 0))
+                        best = ent;
+                }
+                if (best) {
+                    const p = Number(best.priceUsd);
+                    if (Number.isFinite(p))
+                        out[addr] = p;
+                    if (debug)
+                        console.error(`[prices] dexscreener: addr=${addr} bestLiq=${best?.liquidity?.usd ?? 0} priceUsd=${best?.priceUsd ?? 'n/a'}`);
+                }
+                else if (debug) {
+                    console.error(`[prices] dexscreener: addr=${addr} no baseToken match in ${arr.length} pairs`);
+                }
+            }
+            catch (e) {
+                if (debug)
+                    console.error(`[prices] dexscreener error for ${addr}: ${e?.message || e}`);
+            }
+        }
+        return out;
+    }
+    async function tryLlama() {
+        try {
+            const p = await fetchPricesLlama(uniq);
+            for (const k of Object.keys(p))
+                if (byAddress[k] == null)
+                    byAddress[k] = { price: p[k], source: 'llama' };
+            return Object.keys(p).length > 0;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    async function tryReserve(cid) {
+        try {
+            if (!cid)
+                return false;
+            const p = await fetchPricesReserve({ addresses: uniq, chainId: cid, limit: reserveLimit });
+            for (const k of Object.keys(p))
+                if (byAddress[k] == null)
+                    byAddress[k] = { price: p[k], source: 'reserve' };
+            return Object.keys(p).length > 0;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    async function tryDex(cid) {
+        try {
+            if (!cid)
+                return false;
+            const p = await fetchPricesDexscreener({ addresses: uniq, chainId: cid });
+            for (const k of Object.keys(p))
+                if (byAddress[k] == null)
+                    byAddress[k] = { price: p[k], source: 'dexscreener' };
+            return Object.keys(p).length > 0;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    async function tryCG() {
+        try {
+            const p = await fetchPricesCoingecko(uniq, coingeckoKey);
+            for (const k of Object.keys(p))
+                if (byAddress[k] == null)
+                    byAddress[k] = { price: p[k], source: 'coingecko' };
+            return Object.keys(p).length > 0;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    let cid = chainId;
+    if (!cid && (source === 'reserve' || source === 'dexscreener' || source === 'auto'))
+        cid = await resolveChainId(rpcUrl);
+    if (debug)
+        console.error(`[prices] source=${source} rpc=${rpcUrl ? 'yes' : 'no'} chainId=${cid ?? 'n/a'} addresses=${uniq.length}`);
+    if (source === 'reserve')
+        await tryReserve(cid);
+    else if (source === 'dexscreener')
+        await tryDex(cid);
+    else if (source === 'llama')
+        await tryLlama();
+    else if (source === 'coingecko')
+        await tryCG();
+    else {
+        await tryReserve(cid);
+        await tryDex(cid);
+        await tryLlama();
+        await tryCG();
+    }
+    return { byAddress };
+}