@bitpay-labs/bitcore-wallet-service 11.6.0 → 11.6.2

package/ts_build/src/externalservices/coingecko.js

@@ -37,120 +37,179 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoinGeckoService = void 0;
+const crypto_wallet_core_1 = require("@bitpay-labs/crypto-wallet-core");
 const request = __importStar(require("request"));
 const config_1 = __importDefault(require("../config"));
+const constants_1 = require("../lib/common/constants");
 const defaults_1 = require("../lib/common/defaults");
 const logger_1 = __importDefault(require("../lib/logger"));
 const SUPPORTED_FIAT_CODES = new Set(defaults_1.Defaults.FIAT_CURRENCIES.map(f => f.code));
+const ALLOWED_DAYS = new Set([1, 7, 30, 90, 365, 1825]);
+const DEFAULT_ALL_TIME_DAYS = 100000;
+const MAX_QUERY_PARAM_LENGTH = 64;
+const CHAIN_PARAM_PATTERN = /^[a-z0-9-_]+$/i;
+const COIN_GECKO_REQUEST_TIMEOUT_MS = 15000;
+const DEFAULT_COINS = {
+    btc: 'bitcoin',
+    bch: 'bitcoin-cash',
+    doge: 'dogecoin',
+    eth: 'ethereum',
+    ltc: 'litecoin',
+    pol: 'polygon-ecosystem-token',
+    sol: 'solana',
+    xrp: 'ripple',
+};
+const DEFAULT_COIN_ENTRIES = Object.entries(DEFAULT_COINS);
+const DEFAULT_IDS = DEFAULT_COIN_ENTRIES.map(([, id]) => id);
+const DEFAULT_ID_SET = new Set(DEFAULT_IDS);
+const CHAIN_ALIASES = {
+    pol: constants_1.Constants.EVM_CHAINS.MATIC
+};
+const COINGECKO_PLATFORM_ID_BY_CHAIN = {
+    [constants_1.Constants.EVM_CHAINS.ARB]: 'arbitrum-one',
+    [constants_1.Constants.EVM_CHAINS.BASE]: 'base',
+    [constants_1.Constants.EVM_CHAINS.ETH]: 'ethereum',
+    [constants_1.Constants.EVM_CHAINS.MATIC]: 'polygon-pos',
+    [constants_1.Constants.EVM_CHAINS.OP]: 'optimistic-ethereum',
+    [constants_1.Constants.SVM_CHAINS.SOL]: 'solana'
+};
+const CHAIN_BY_COINGECKO_PLATFORM_ID = Object.entries(COINGECKO_PLATFORM_ID_BY_CHAIN).reduce((acc, [chain, platformId]) => {
+    acc[platformId] = chain;
+    return acc;
+}, {});
+function isBitPayTokenChain(value) {
+    return Object.prototype.hasOwnProperty.call(COINGECKO_PLATFORM_ID_BY_CHAIN, value);
+}
+const first = (value) => (Array.isArray(value) ? value[0] : value);
+function badRequest(message) {
+    const err = new Error(message);
+    err.statusCode = 400;
+    return err;
+}
+function getQueryString(query, key) {
+    const raw = first(query?.[key]);
+    if (raw === undefined || raw === null)
+        return undefined;
+    const s = (typeof raw === 'string' ? raw : typeof raw === 'number' || typeof raw === 'boolean' ? String(raw) : '')
+        .trim();
+    if (!s)
+        return undefined;
+    if (s.length > MAX_QUERY_PARAM_LENGTH)
+        throw badRequest('Query param too long');
+    return s;
+}
+function validateQueryParam(query, key) {
+    try {
+        return getQueryString(query, key);
+    }
+    catch {
+        throw badRequest(`Unsupported ${key}`);
+    }
+}
+function parseCoinChainTokenAddress(query) {
+    return {
+        coin: validateQueryParam(query, 'coin'),
+        chain: validateQueryParam(query, 'chain'),
+        tokenAddress: validateQueryParam(query, 'tokenAddress')
+    };
+}
+function normalizeChainSafe(chain) {
+    const c = (chain ?? '').toString().trim().toLowerCase();
+    if (!c)
+        return undefined;
+    if (c.length > MAX_QUERY_PARAM_LENGTH)
+        return undefined;
+    if (!CHAIN_PARAM_PATTERN.test(c))
+        return undefined;
+    const normalizedChain = CHAIN_ALIASES[c] || (isBitPayTokenChain(c) ? c : undefined);
+    if (!normalizedChain)
+        return undefined;
+    return COINGECKO_PLATFORM_ID_BY_CHAIN[normalizedChain];
+}
+function asNumberOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function isValidTokenAddressForPlatform(tokenAddress, platformId) {
+    const chain = CHAIN_BY_COINGECKO_PLATFORM_ID[platformId];
+    if (!chain)
+        return false;
+    return crypto_wallet_core_1.Validation.validateAddress(chain, 'mainnet', tokenAddress);
+}
 class CoinGeckoService {
     request = request;
     storage;
     constructor(storage) {
         this.storage = storage;
     }
-    async coinGeckoGetFiatRatesForId(args) {
-        const { id, vsCurrency, days } = args;
-        const cacheKey = `cgFiatRates:${id}:${vsCurrency}:${days}`;
+    coinGeckoGetCredentials() {
+        if (!config_1.default.coinGecko)
+            throw new Error('coinGecko missing credentials');
+        return { API: config_1.default.coinGecko.api, API_KEY: config_1.default.coinGecko.apiKey };
+    }
+    coinGeckoGetHeaders(apiKey) {
+        return {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            'x-cg-pro-api-key': apiKey
+        };
+    }
+    cgUrl(path, params) {
+        const { API } = this.coinGeckoGetCredentials();
+        const base = API.endsWith('/') ? API.slice(0, -1) : API;
+        const url = new URL(path.startsWith('/') ? `${base}${path}` : `${base}/${path}`);
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v === undefined)
+                    continue;
+                url.searchParams.set(k, String(v));
+            }
+        }
+        return url.toString();
+    }
+    async withGlobalCache(cacheKey, duration, fetcher, logName = cacheKey) {
         return new Promise((resolve, reject) => {
-            this.storage.checkAndUseGlobalCache(cacheKey, defaults_1.Defaults.COIN_GECKO_MARKET_STATS_CACHE_DURATION, async (err, values, oldvalues) => {
+            this.storage.checkAndUseGlobalCache(cacheKey, duration, async (err, values, oldvalues) => {
                 if (err)
-                    logger_1.default.warn('CoinGecko fiat rates cache check failed: %o', err);
-                if (values)
+                    logger_1.default.warn('%s cache check failed: %o', logName, err);
+                if (values !== undefined && values !== null)
                     return resolve(values);
                 try {
-                    const credentials = this.coinGeckoGetCredentials();
-                    const headers = this.coinGeckoGetHeaders(credentials.API_KEY);
-                    const intervalParam = days >= 90 ? '&interval=daily' : '';
-                    const chartUrl = `${credentials.API}/v3/coins/${encodeURIComponent(id)}/market_chart?vs_currency=${encodeURIComponent(vsCurrency)}&days=${encodeURIComponent(days.toString())}${intervalParam}`;
-                    const chartBody = await this.coinGeckoGetJson(chartUrl, headers);
-                    const prices = chartBody?.prices || [];
-                    const response = prices.map(p => ({ ts: p[0], rate: p[1] }));
-                    this.storage.storeGlobalCache(cacheKey, response, storeErr => {
+                    const fetched = await fetcher();
+                    this.storage.storeGlobalCache(cacheKey, fetched, storeErr => {
                         if (storeErr)
-                            logger_1.default.warn('Could not cache CoinGecko fiat rates: %o', storeErr);
-                        return resolve(response);
+                            logger_1.default.warn('Could not cache %s: %o', logName, storeErr);
+                        resolve(fetched);
                     });
                 }
                 catch (e) {
-                    const statusCode = e?.statusCode;
-                    if (statusCode === 429 && oldvalues) {
+                    if (e?.statusCode === 429 && oldvalues)
                         return resolve(oldvalues);
-                    }
                     if (oldvalues) {
-                        logger_1.default.warn('Using old cached CoinGecko fiat rates values');
+                        logger_1.default.warn('Using old cached %s values', logName);
                         return resolve(oldvalues);
                     }
-                    return reject(e);
+                    reject(e);
                 }
             });
         });
     }
-    coinGeckoGetCredentials() {
-        if (!config_1.default.coinGecko)
-            throw new Error('coinGecko missing credentials');
-        const credentials = {
-            API: config_1.default.coinGecko.api,
-            API_KEY: config_1.default.coinGecko.apiKey,
-        };
-        return credentials;
-    }
-    coinGeckoGetHeaders(apiKey) {
-        return {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json',
-            'x-cg-pro-api-key': apiKey
-        };
-    }
-    getDefaultMarketStatsSymbols() {
-        return ['BTC', 'ETH', 'XRP', 'SOL', 'DOGE', 'BCH', 'SHIB', 'POL', 'APE', 'LTC', 'WBTC', 'WETH'];
-    }
-    resolveCoinGeckoId(coin) {
-        const normalized = coin.trim().toLowerCase();
-        const symbolToIdMap = {
-            btc: 'bitcoin',
-            eth: 'ethereum',
-            xrp: 'ripple',
-            sol: 'solana',
-            doge: 'dogecoin',
-            bch: 'bitcoin-cash',
-            shib: 'shiba-inu',
-            pol: 'polygon-ecosystem-token',
-            ape: 'apecoin',
-            ltc: 'litecoin',
-            wbtc: 'wrapped-bitcoin',
-            weth: 'weth'
-        };
-        if (symbolToIdMap[normalized])
-            return symbolToIdMap[normalized];
-        const knownIds = new Set(Object.values(symbolToIdMap));
-        if (knownIds.has(normalized))
-            return normalized;
-        throw new Error(`Unsupported coin '${coin}'`);
-    }
     coinGeckoGetJson(url, headers) {
         return new Promise((resolve, reject) => {
-            this.request.get(url, {
-                headers,
-                json: true
-            }, (err, data) => {
+            this.request.get(url, { headers, json: true, timeout: COIN_GECKO_REQUEST_TIMEOUT_MS }, (err, data) => {
                 const body = data?.body;
                 const status = body?.status;
                 const httpStatusCode = data?.statusCode;
                 const coinGeckoErrorCode = status?.error_code;
                 if (err) {
-                    logger_1.default.error('CoinGecko request failed: %o', {
-                        url,
-                        httpStatusCode,
-                        coinGeckoErrorCode,
-                        err: err?.message || err,
-                        body
-                    });
+                    logger_1.default.error('CoinGecko request failed: %o', { url, httpStatusCode, coinGeckoErrorCode, err, body });
                     return reject(err.body ?? err);
                 }
                 if (httpStatusCode === 429 || coinGeckoErrorCode === 429) {
                     logger_1.default.warn('CoinGecko rate limit: %o', { url, httpStatusCode, coinGeckoErrorCode, body });
                     const rateLimitErr = new Error('coinGecko rate limit');
                     rateLimitErr.statusCode = 429;
+                    rateLimitErr.coinGeckoErrorCode = coinGeckoErrorCode;
+                    rateLimitErr.body = body;
                     return reject(rateLimitErr);
                 }
                 const hasCoinGeckoError = !!(status?.error_code || status?.error_message);
@@ -162,252 +221,243 @@ class CoinGeckoService {
                     cgErr.body = body;
                     return reject(cgErr);
                 }
-                return resolve(body);
+                resolve(body);
             });
         });
     }
-    coinGeckoGetMarketStats(req) {
-        return new Promise((resolve, reject) => {
-            const currency = (req.params?.['code'] || 'USD').toString().toUpperCase();
-            if (!SUPPORTED_FIAT_CODES.has(currency)) {
-                return reject(new Error(`Unsupported fiat currency code '${currency}'`));
-            }
-            const vsCurrency = currency.toLowerCase();
-            const coinParam = req.query?.coin || null;
-            const symbols = this.getDefaultMarketStatsSymbols();
-            let requestedId = null;
-            if (coinParam) {
-                try {
-                    requestedId = this.resolveCoinGeckoId(coinParam);
-                }
-                catch (e) {
-                    return reject(e);
-                }
+    async resolveCoinGeckoId(coin, chain, tokenAddress) {
+        const sym = (coin || '').trim().toLowerCase();
+        if (sym && sym.length > MAX_QUERY_PARAM_LENGTH)
+            throw badRequest('Unsupported coin');
+        const chainRaw = first(chain);
+        const chainProvided = chainRaw !== undefined && chainRaw !== null && String(chainRaw).trim().length > 0;
+        const platformId = normalizeChainSafe(chainRaw);
+        const normalizedTokenAddress = tokenAddress?.trim();
+        if (chainProvided && !normalizedTokenAddress) {
+            if (!platformId)
+                throw badRequest('Unsupported chain');
+            throw badRequest('chain is only supported for token lookups; provide tokenAddress or omit chain for native coins');
+        }
+        if (normalizedTokenAddress) {
+            if (!platformId)
+                throw badRequest('tokenAddress requires valid chain');
+            if (!isValidTokenAddressForPlatform(normalizedTokenAddress, platformId)) {
+                throw badRequest('Invalid tokenAddress');
             }
-            const filterResponse = (stats) => {
-                if (!coinParam)
-                    return stats;
-                const normalizedSymbol = coinParam.trim().toUpperCase();
-                const defaultSymbolSet = new Set(symbols.map(s => s.toUpperCase()));
-                if (defaultSymbolSet.has(normalizedSymbol)) {
-                    return stats.filter(s => s.symbol === normalizedSymbol);
-                }
-                const defaultIds = symbols.map(s => this.resolveCoinGeckoId(s));
-                const idx = requestedId ? defaultIds.indexOf(requestedId) : -1;
-                if (idx >= 0) {
-                    const requestedSymbol = symbols[idx].toUpperCase();
-                    return stats.filter(s => s.symbol === requestedSymbol);
-                }
-                return [];
-            };
-            let ids;
+            const { API_KEY } = this.coinGeckoGetCredentials();
+            const headers = this.coinGeckoGetHeaders(API_KEY);
             try {
-                ids = symbols.map(s => this.resolveCoinGeckoId(s));
+                const url = this.cgUrl(`/v3/coins/${encodeURIComponent(platformId)}/contract/${encodeURIComponent(normalizedTokenAddress)}`);
+                const body = await this.coinGeckoGetJson(url, headers);
+                const id = (body?.id ?? '').toString().trim().toLowerCase();
+                if (!id)
+                    throw badRequest('Unsupported tokenAddress');
+                const tokenSymbol = (body?.symbol ?? '').toString().trim().toLowerCase();
+                if (sym && (!tokenSymbol || tokenSymbol !== sym))
+                    throw badRequest('tokenAddress does not match coin');
+                const tokenAssetPlatformId = (body?.asset_platform_id ?? '').toString().trim().toLowerCase();
+                const platforms = body?.platforms;
+                const detailPlatforms = body?.detail_platforms;
+                const platformKeys = (obj) => (obj && typeof obj === 'object' ? Object.keys(obj).map(k => k.toLowerCase()) : []);
+                const platformSignals = [
+                    ...(tokenAssetPlatformId ? [tokenAssetPlatformId] : []),
+                    ...platformKeys(platforms),
+                    ...platformKeys(detailPlatforms)
+                ];
+                if (platformSignals.length > 0 && !platformSignals.includes(platformId)) {
+                    throw badRequest('tokenAddress does not match chain');
+                }
+                return id;
             }
             catch (e) {
-                return reject(e);
-            }
-            const cacheKey = `cgMarketStats:${vsCurrency}`;
-            const credentials = this.coinGeckoGetCredentials();
-            const headers = this.coinGeckoGetHeaders(credentials.API_KEY);
-            this.storage.checkAndUseGlobalCache(cacheKey, defaults_1.Defaults.COIN_GECKO_MARKET_STATS_CACHE_DURATION, async (err, values, oldvalues) => {
-                if (err)
-                    logger_1.default.warn('CoinGecko market stats cache check failed: %o', err);
-                if (values)
-                    return resolve(filterResponse(values));
-                try {
-                    const marketsUrl = `${credentials.API}/v3/coins/markets?vs_currency=${encodeURIComponent(vsCurrency)}&ids=${encodeURIComponent(ids.join(','))}&order=market_cap_desc&per_page=250&page=1&sparkline=false`;
-                    const marketsBody = await this.coinGeckoGetJson(marketsUrl, headers);
-                    if (!Array.isArray(marketsBody))
-                        throw new Error('Could not get market data');
-                    const marketById = new Map();
-                    for (const marketItem of marketsBody) {
-                        if (marketItem?.id)
-                            marketById.set(marketItem.id, marketItem);
-                    }
-                    const perCoinStats = await Promise.all(ids.map(async (id) => {
-                        const marketItem = marketById.get(id);
-                        if (!marketItem)
-                            throw new Error(`Could not get market data for '${id}'`);
-                        const chartUrl = `${credentials.API}/v3/coins/${encodeURIComponent(id)}/market_chart?vs_currency=${encodeURIComponent(vsCurrency)}&days=365&interval=daily`;
-                        const infoUrl = `${credentials.API}/v3/coins/${encodeURIComponent(id)}?localization=false&tickers=false&market_data=false&community_data=false&developer_data=false&sparkline=false`;
-                        const [chartBody, infoBody] = await Promise.all([
-                            this.coinGeckoGetJson(chartUrl, headers),
-                            this.coinGeckoGetJson(infoUrl, headers)
-                        ]);
-                        const prices = chartBody?.prices || [];
-                        let high52w = null;
-                        let low52w = null;
-                        for (const p of prices) {
-                            const price = p?.[1];
-                            if (typeof price !== 'number')
-                                continue;
-                            if (high52w === null || price > high52w)
-                                high52w = price;
-                            if (low52w === null || price < low52w)
-                                low52w = price;
-                        }
-                        const about = infoBody?.description?.en;
-                        const stats = {
-                            symbol: (marketItem?.symbol || '').toUpperCase(),
-                            name: marketItem?.name,
-                            image: marketItem?.image,
-                            price: typeof marketItem?.current_price === 'number' ? marketItem.current_price : null,
-                            high52w,
-                            low52w,
-                            volume24h: typeof marketItem?.total_volume === 'number' ? marketItem.total_volume : null,
-                            circulatingSupply: typeof marketItem?.circulating_supply === 'number' ? marketItem.circulating_supply : null,
-                            marketCap: typeof marketItem?.market_cap === 'number' ? marketItem.market_cap : null,
-                            lastUpdated: marketItem?.last_updated,
-                            about: typeof about === 'string' ? about : undefined
-                        };
-                        return { id, stats };
-                    }));
-                    const order = new Map();
-                    let i = 0;
-                    for (const s of symbols) {
-                        order.set(this.resolveCoinGeckoId(s), i);
-                        i++;
-                    }
-                    const sortedStats = perCoinStats
-                        .slice()
-                        .sort((a, b) => {
-                        const ai = order.get(a.id) ?? Number.MAX_SAFE_INTEGER;
-                        const bi = order.get(b.id) ?? Number.MAX_SAFE_INTEGER;
-                        return ai - bi;
-                    })
-                        .map(entry => entry.stats);
-                    const response = sortedStats;
-                    this.storage.storeGlobalCache(cacheKey, response, storeErr => {
-                        if (storeErr)
-                            logger_1.default.warn('Could not cache CoinGecko market stats: %o', storeErr);
-                        return resolve(filterResponse(response));
-                    });
-                }
-                catch (e) {
-                    const statusCode = e?.statusCode;
-                    if (statusCode === 429 && oldvalues) {
-                        return resolve(filterResponse(oldvalues));
-                    }
-                    if (oldvalues) {
-                        logger_1.default.warn('Using old cached CoinGecko market stats values');
-                        return resolve(filterResponse(oldvalues));
-                    }
-                    return reject(e);
+                if (e?.statusCode === 404) {
+                    throw badRequest('Unsupported tokenAddress');
                 }
-            });
-        });
+                throw e;
+            }
+        }
+        if (!sym)
+            throw badRequest('Unsupported coin');
+        const defaultId = DEFAULT_COINS[sym];
+        if (defaultId)
+            return defaultId;
+        throw badRequest('Unsupported coin. For token symbols, pass `chain` and `tokenAddress`.');
     }
-    coinGeckoGetFiatRates(req) {
-        return new Promise((resolve, reject) => {
-            const currency = (req.params?.['code'] || '').toString().toUpperCase();
-            if (!SUPPORTED_FIAT_CODES.has(currency)) {
-                return reject(new Error(`Unsupported fiat currency code '${currency}'`));
+    async fetchFiatRatesForId(id, vsCurrency, days) {
+        const { API_KEY } = this.coinGeckoGetCredentials();
+        const headers = this.coinGeckoGetHeaders(API_KEY);
+        const params = { vs_currency: vsCurrency, days };
+        if (days >= 90)
+            params.interval = 'daily';
+        const url = this.cgUrl(`/v3/coins/${encodeURIComponent(id)}/market_chart`, params);
+        const body = await this.coinGeckoGetJson(url, headers);
+        const prices = Array.isArray(body?.prices) ? body.prices : null;
+        if (!prices)
+            throw new Error('CoinGecko market_chart response missing prices');
+        return prices
+            .map((p) => ({ ts: p?.[0], rate: p?.[1] }))
+            .filter((p) => typeof p.ts === 'number' && typeof p.rate === 'number');
+    }
+    async getFiatRatesForId(id, vsCurrency, days, useDbCache) {
+        if (!useDbCache)
+            return this.fetchFiatRatesForId(id, vsCurrency, days);
+        const cacheKey = `cgFiatRates:${id}:${vsCurrency}:${days}`;
+        return this.withGlobalCache(cacheKey, defaults_1.Defaults.COIN_GECKO_MARKET_STATS_CACHE_DURATION, () => this.fetchFiatRatesForId(id, vsCurrency, days));
+    }
+    async fetchMarketStats(ids, vsCurrency) {
+        const { API_KEY } = this.coinGeckoGetCredentials();
+        const headers = this.coinGeckoGetHeaders(API_KEY);
+        const marketsUrl = this.cgUrl('/v3/coins/markets', {
+            vs_currency: vsCurrency,
+            ids: ids.join(','),
+            order: 'market_cap_desc',
+            per_page: 250,
+            page: 1,
+            sparkline: false
+        });
+        const marketsBody = await this.coinGeckoGetJson(marketsUrl, headers);
+        if (!Array.isArray(marketsBody))
+            throw new Error('Could not get market data');
+        const marketById = new Map();
+        for (const m of marketsBody) {
+            const id = (m?.id ?? '').toString().toLowerCase();
+            if (id)
+                marketById.set(id, m);
+        }
+        const stats = await Promise.all(ids.map(async (id) => {
+            const market = marketById.get(id);
+            if (!market)
+                throw new Error(`Could not get market data for '${id}'`);
+            const chartUrl = this.cgUrl(`/v3/coins/${encodeURIComponent(id)}/market_chart`, {
+                vs_currency: vsCurrency,
+                days: 365,
+                interval: 'daily'
+            });
+            const infoUrl = this.cgUrl(`/v3/coins/${encodeURIComponent(id)}`, {
+                localization: false,
+                tickers: false,
+                market_data: false,
+                community_data: false,
+                developer_data: false,
+                sparkline: false
+            });
+            const [chartBody, infoBody] = await Promise.all([
+                this.coinGeckoGetJson(chartUrl, headers),
+                this.coinGeckoGetJson(infoUrl, headers)
+            ]);
+            const prices = Array.isArray(chartBody?.prices) ? chartBody.prices : [];
+            let high52w = null;
+            let low52w = null;
+            for (const p of prices) {
+                const price = p?.[1];
+                if (typeof price !== 'number')
+                    continue;
+                if (high52w === null || price > high52w)
+                    high52w = price;
+                if (low52w === null || price < low52w)
+                    low52w = price;
             }
-            const vsCurrency = currency.toLowerCase();
-            const coinParam = req.query?.coin || null;
-            const allowedDays = new Set([1, 7, 30, 90, 365, 1825]);
-            let days = 100000;
-            if (req.query?.days !== undefined) {
-                const parsed = +req.query.days;
-                if (!allowedDays.has(parsed))
-                    return reject(new Error('Invalid days'));
+            const about = infoBody?.description?.en;
+            return {
+                symbol: (market?.symbol || '').toString().toUpperCase(),
+                name: (market?.name || id).toString(),
+                image: typeof market?.image === 'string' ? market.image : undefined,
+                price: asNumberOrNull(market?.current_price),
+                high52w,
+                low52w,
+                volume24h: asNumberOrNull(market?.total_volume),
+                circulatingSupply: asNumberOrNull(market?.circulating_supply),
+                marketCap: asNumberOrNull(market?.market_cap),
+                lastUpdated: typeof market?.last_updated === 'string' ? market.last_updated : undefined,
+                about: typeof about === 'string' ? about : undefined
+            };
+        }));
+        return stats;
+    }
+    async coinGeckoGetMarketStats(req) {
+        const currency = (req.params?.['code'] || 'USD').toString().toUpperCase();
+        if (!SUPPORTED_FIAT_CODES.has(currency))
+            throw badRequest(`Unsupported fiat currency code '${currency}'`);
+        const vsCurrency = currency.toLowerCase();
+        const { coin: coinParam, chain: chainParam, tokenAddress: tokenAddressParam } = parseCoinChainTokenAddress(req.query);
+        let ids;
+        let cacheKey = null;
+        if (coinParam || chainParam || tokenAddressParam) {
+            const id = await this.resolveCoinGeckoId(coinParam, chainParam, tokenAddressParam);
+            ids = [id];
+            if (DEFAULT_ID_SET.has(id))
+                cacheKey = `cgMarketStats:${vsCurrency}:${id}`;
+        }
+        else {
+            ids = DEFAULT_IDS.slice();
+            cacheKey = `cgMarketStats:${vsCurrency}`;
+        }
+        if (!cacheKey)
+            return this.fetchMarketStats(ids, vsCurrency);
+        return this.withGlobalCache(cacheKey, defaults_1.Defaults.COIN_GECKO_MARKET_STATS_CACHE_DURATION, () => this.fetchMarketStats(ids, vsCurrency));
+    }
+    async coinGeckoGetFiatRates(req) {
+        const currency = (req.params?.['code'] || '').toString().toUpperCase();
+        if (!SUPPORTED_FIAT_CODES.has(currency))
+            throw badRequest(`Unsupported fiat currency code '${currency}'`);
+        const vsCurrency = currency.toLowerCase();
+        const { coin: coinParam, chain: chainParam, tokenAddress: tokenAddressParam } = parseCoinChainTokenAddress(req.query);
+        let days = DEFAULT_ALL_TIME_DAYS;
+        try {
+            const daysParam = getQueryString(req.query, 'days');
+            if (daysParam !== undefined) {
+                const parsed = +daysParam;
+                if (!ALLOWED_DAYS.has(parsed))
+                    throw badRequest('Invalid days');
                 days = parsed;
             }
-            if (coinParam) {
-                let id;
-                try {
-                    id = this.resolveCoinGeckoId(coinParam);
-                }
-                catch (e) {
-                    return reject(e);
-                }
-                this.coinGeckoGetFiatRatesForId({ id, vsCurrency, days })
-                    .then(resolve)
-                    .catch(reject);
-                return;
+        }
+        catch {
+            throw badRequest('Invalid days');
+        }
+        if (coinParam || chainParam || tokenAddressParam) {
+            const id = await this.resolveCoinGeckoId(coinParam, chainParam, tokenAddressParam);
+            const useDbCache = DEFAULT_ID_SET.has(id);
+            return this.getFiatRatesForId(id, vsCurrency, days, useDbCache);
+        }
+        const tasks = DEFAULT_COIN_ENTRIES.map(([, id]) => this.getFiatRatesForId(id, vsCurrency, days, true));
+        const results = await Promise.allSettled(tasks);
+        const out = {};
+        for (const [i, r] of results.entries()) {
+            const coin = DEFAULT_COIN_ENTRIES[i][0];
+            if (r.status === 'fulfilled')
+                out[coin] = r.value;
+            else {
+                const reason = r.reason;
+                logger_1.default.warn('CoinGecko fiat rates fetch failed: %o', {
+                    coin,
+                    statusCode: reason?.statusCode,
+                    err: reason?.message || reason
+                });
             }
-            const symbols = this.getDefaultMarketStatsSymbols();
-            Promise.allSettled(symbols.map(async (symbol) => {
-                const coin = symbol.trim().toLowerCase();
-                const id = this.resolveCoinGeckoId(symbol);
-                const rates = await this.coinGeckoGetFiatRatesForId({ id, vsCurrency, days });
-                return { coin, rates };
-            }))
-                .then(results => {
-                const out = {};
-                for (const r of results) {
-                    if (r.status === 'fulfilled') {
-                        out[r.value.coin] = r.value.rates;
-                    }
-                }
-                return resolve(out);
-            })
-                .catch(reject);
-        });
+        }
+        return out;
     }
-    coinGeckoGetTokens(req) {
-        return new Promise((resolve, reject) => {
-            const chain = req.params?.['chain'] || 'eth';
-            const cacheKey = `cgTokenList:${chain}`;
-            const credentials = this.coinGeckoGetCredentials();
-            const headers = this.coinGeckoGetHeaders(credentials.API_KEY);
-            this.storage.checkAndUseGlobalCache(cacheKey, defaults_1.Defaults.COIN_GECKO_CACHE_DURATION, (err, values, oldvalues) => {
-                if (err)
-                    logger_1.default.warn('CoinGecko token list cache check failed: %o', err);
-                if (values)
-                    return resolve(values);
-                const assetPlatformMap = {
-                    eth: 'ethereum',
-                    matic: 'polygon-pos',
-                    pol: 'polygon-pos',
-                    arb: 'arbitrum-one',
-                    base: 'base',
-                    op: 'optimistic-ethereum',
-                    sol: 'solana',
-                };
-                const assetId = assetPlatformMap[chain];
-                if (!assetId)
-                    return reject(new Error(`Unsupported chain '${chain}'`));
-                const URL = `${credentials.API}/v3/token_lists/${assetId}/all.json`;
-                this.request.get(URL, {
-                    headers,
-                    json: true
-                }, (err, data) => {
-                    const tokens = data?.body?.tokens;
-                    const status = data?.body?.status;
-                    if (err) {
-                        logger_1.default.warn('An error occurred while retrieving the CoinGecko token list: %o', err);
-                        if (oldvalues) {
-                            logger_1.default.warn('Using old cached CoinGecko token list values');
-                            return resolve(oldvalues);
-                        }
-                        return reject(err.body ?? err);
-                    }
-                    else if (status?.error_code === 429 && oldvalues) {
-                        return resolve(oldvalues);
-                    }
-                    else {
-                        if (!tokens) {
-                            if (oldvalues) {
-                                logger_1.default.warn('No token list available... using old cached CoinGecko token list values');
-                                return resolve(oldvalues);
-                            }
-                            return reject(new Error(`Could not get tokens list. Code: ${status?.error_code}. Error: ${status?.error_message || 'Unknown error'}`));
-                        }
-                        const updatedTokens = tokens.map(token => {
-                            if (token.logoURI?.includes('/thumb/')) {
-                                token.logoURI = token.logoURI.replace('/thumb/', '/large/');
-                            }
-                            return token;
-                        });
-                        this.storage.storeGlobalCache(cacheKey, updatedTokens, storeErr => {
-                            if (storeErr)
-                                logger_1.default.warn('Could not cache CoinGecko token list: %o', storeErr);
-                            return resolve(updatedTokens);
-                        });
-                    }
-                });
+    async coinGeckoGetTokens(req) {
+        const chain = (req.params?.['chain'] || 'eth').toString();
+        const platformId = normalizeChainSafe(chain);
+        if (!platformId) {
+            throw badRequest(`Unsupported chain '${chain}'`);
+        }
+        const cacheKey = `cgTokenList:${platformId}`;
+        return this.withGlobalCache(cacheKey, defaults_1.Defaults.COIN_GECKO_CACHE_DURATION, async () => {
+            const { API_KEY } = this.coinGeckoGetCredentials();
+            const headers = this.coinGeckoGetHeaders(API_KEY);
+            const url = this.cgUrl(`/v3/token_lists/${encodeURIComponent(platformId)}/all.json`);
+            const body = await this.coinGeckoGetJson(url, headers);
+            const tokens = Array.isArray(body?.tokens) ? body.tokens : null;
+            if (!tokens)
+                throw new Error('Could not get tokens list');
+            return tokens.map((t) => {
+                if (!t || typeof t !== 'object')
+                    return t;
+                const logoURI = t?.logoURI?.includes('/thumb/') ? t.logoURI.replace('/thumb/', '/large/') : t.logoURI;
+                return { ...t, logoURI };
             });
         });
     }