@talismn/token-rates 3.0.22 → 4.0.0

package/dist/index.js

@@ -1,206 +1,354 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ALL_CURRENCY_IDS: () => ALL_CURRENCY_IDS,
-  DEFAULT_COINSAPI_CONFIG: () => DEFAULT_COINSAPI_CONFIG,
-  SUPPORTED_CURRENCIES: () => SUPPORTED_CURRENCIES,
-  TokenRatesError: () => TokenRatesError,
-  fetchTokenRates: () => fetchTokenRates,
-  newTokenRates: () => newTokenRates,
-  tryToDeleteOldTokenRatesDb: () => tryToDeleteOldTokenRatesDb
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _talismn_chaindata_provider = require("@talismn/chaindata-provider");
+let _talismn_util = require("@talismn/util");
+let scale_ts = require("scale-ts");
+let anylogger = require("anylogger");
+anylogger = __toESM(anylogger);
+//#endregion
+//#region src/log.ts
+var log_default = (0, anylogger.default)("@talismn/token-rates");
+//#endregion
+//#region src/types.ts
+const SUPPORTED_CURRENCIES = {
+	btc: {
+		name: "Bitcoin",
+		symbol: "₿"
+	},
+	eth: {
+		name: "Ethereum",
+		symbol: "Ξ"
+	},
+	dot: {
+		name: "Polkadot",
+		symbol: "D"
+	},
+	tao: {
+		name: "Bittensor",
+		symbol: "τ"
+	},
+	usd: {
+		name: "US Dollar",
+		symbol: "$"
+	},
+	cny: {
+		name: "Chinese Yuan",
+		symbol: "¥"
+	},
+	eur: {
+		name: "Euro",
+		symbol: "€"
+	},
+	gbp: {
+		name: "British Pound",
+		symbol: "£"
+	},
+	cad: {
+		name: "Canadian Dollar",
+		symbol: "C$"
+	},
+	aud: {
+		name: "Australian Dollar",
+		symbol: "A$"
+	},
+	nzd: {
+		name: "New Zealand Dollar",
+		symbol: "NZ$"
+	},
+	jpy: {
+		name: "Japanese Yen",
+		symbol: "¥"
+	},
+	rub: {
+		name: "Russian Ruble",
+		symbol: "₽"
+	},
+	krw: {
+		name: "South Korean Won",
+		symbol: "₩"
+	},
+	idr: {
+		name: "Indonesian Rupiah",
+		symbol: "Rp"
+	},
+	php: {
+		name: "Philippine Peso",
+		symbol: "₱"
+	},
+	thb: {
+		name: "Thai Baht",
+		symbol: "฿"
+	},
+	vnd: {
+		name: "Vietnamese Dong",
+		symbol: "₫"
+	},
+	inr: {
+		name: "Indian Rupee",
+		symbol: "₹"
+	},
+	try: {
+		name: "Turkish Lira",
+		symbol: "₺"
+	},
+	sgd: {
+		name: "Singapore Dollar",
+		symbol: "S$"
+	}
+};
+const newTokenRates = () => ({
+	btc: null,
+	eth: null,
+	dot: null,
+	tao: null,
+	usd: null,
+	cny: null,
+	eur: null,
+	gbp: null,
+	cad: null,
+	aud: null,
+	nzd: null,
+	jpy: null,
+	rub: null,
+	krw: null,
+	idr: null,
+	php: null,
+	thb: null,
+	vnd: null,
+	inr: null,
+	try: null,
+	sgd: null
 });
-module.exports = __toCommonJS(index_exports);
-
-// src/TalismanTokenRatesDatabase.ts
-var tryToDeleteOldTokenRatesDb = () => {
-  try {
-    indexedDB.deleteDatabase("TalismanTokenRates");
-  } catch {
-  }
+//#endregion
+//#region src/getDTaoTokenRates.ts
+/** TAO-per-alpha pool price fixed-point scale: 10^9 (TAO decimals) */
+const SCALED_ALPHA_PRICE_SCALE = 10 ** 9;
+/**
+* 24h change of an alpha token in a given currency, in percent: the pool price change (alpha vs
+* TAO) compounded with the TAO change in that currency. Unknown without the pool change.
+*/
+const getAlphaChange24h = (currency, taoChange24h, alphaPriceChange24h) => {
+	if (typeof alphaPriceChange24h !== "number" || !Number.isFinite(alphaPriceChange24h)) return void 0;
+	if (currency === "tao") return alphaPriceChange24h;
+	if (typeof taoChange24h !== "number" || !Number.isFinite(taoChange24h)) return void 0;
+	return ((1 + alphaPriceChange24h / 100) * (1 + taoChange24h / 100) - 1) * 100;
 };
-
-// src/TokenRates.ts
-var import_chaindata_provider = require("@talismn/chaindata-provider");
-
-// src/types.ts
-var SUPPORTED_CURRENCIES = {
-  btc: { name: "Bitcoin", symbol: "\u20BF" },
-  eth: { name: "Ethereum", symbol: "\u039E" },
-  dot: { name: "Polkadot", symbol: "D" },
-  tao: { name: "Bittensor", symbol: "\u03C4" },
-  usd: { name: "US Dollar", symbol: "$" },
-  cny: { name: "Chinese Yuan", symbol: "\xA5" },
-  eur: { name: "Euro", symbol: "\u20AC" },
-  gbp: { name: "British Pound", symbol: "\xA3" },
-  cad: { name: "Canadian Dollar", symbol: "C$" },
-  aud: { name: "Australian Dollar", symbol: "A$" },
-  nzd: { name: "New Zealand Dollar", symbol: "NZ$" },
-  jpy: { name: "Japanese Yen", symbol: "\xA5" },
-  rub: { name: "Russian Ruble", symbol: "\u20BD" },
-  krw: { name: "South Korean Won", symbol: "\u20A9" },
-  idr: { name: "Indonesian Rupiah", symbol: "Rp" },
-  php: { name: "Philippine Peso", symbol: "\u20B1" },
-  thb: { name: "Thai Baht", symbol: "\u0E3F" },
-  vnd: { name: "Vietnamese Dong", symbol: "\u20AB" },
-  inr: { name: "Indian Rupee", symbol: "\u20B9" },
-  try: { name: "Turkish Lira", symbol: "\u20BA" },
-  // hkd: { name: "Hong Kong Dollar", symbol: "HK$" },
-  sgd: { name: "Singapore Dollar", symbol: "S$" }
-  // twd: { name: "Taiwanese Dollar", symbol: "NT$" },
+/**
+* Rates of a bittensor dtao (subnet alpha) token, derived from its network's native TAO rates
+* scaled by the subnet pool price. To be used for tokens that don't have a coingecko id.
+*
+* @param token
+* @param tokenRates must contain the rates of the network's native (TAO) token
+* @param scaledAlphaPrice current TAO-per-alpha pool price, fixed-point scaled by 10^9 (rao)
+* @param alphaPriceChange24h 24h change of the pool price (alpha vs TAO) in percent, when known
+*/
+const getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice, alphaPriceChange24h) => {
+	try {
+		const taoTokenRates = tokenRates[(0, _talismn_chaindata_provider.subNativeTokenId)(token.networkId)];
+		if (!taoTokenRates) return null;
+		if (token.netuid === 0) return structuredClone(taoTokenRates);
+		const priceRatio = Number(BigInt(scaledAlphaPrice)) / SCALED_ALPHA_PRICE_SCALE;
+		const alphaRates = newTokenRates();
+		for (const [currency, taoRate] of Object.entries(taoTokenRates)) if (!taoRate) alphaRates[currency] = null;
+		else alphaRates[currency] = {
+			price: taoRate.price * priceRatio,
+			marketCap: taoRate.marketCap ? taoRate.marketCap * priceRatio : void 0,
+			change24h: getAlphaChange24h(currency, taoRate.change24h, alphaPriceChange24h)
+		};
+		return alphaRates;
+	} catch (err) {
+		log_default.error("Failed to compute dtao token rates", err);
+		return null;
+	}
 };
-var newTokenRates = () => ({
-  btc: null,
-  eth: null,
-  dot: null,
-  tao: null,
-  usd: null,
-  cny: null,
-  eur: null,
-  gbp: null,
-  cad: null,
-  aud: null,
-  nzd: null,
-  jpy: null,
-  rub: null,
-  krw: null,
-  idr: null,
-  php: null,
-  thb: null,
-  vnd: null,
-  inr: null,
-  try: null,
-  // hkd: null,
-  sgd: null
-  // twd: null,
-});
-
-// src/TokenRates.ts
-var TokenRatesError = class extends Error {
-  response;
-  constructor(message, response) {
-    super(message);
-    this.response = response;
-  }
+//#endregion
+//#region src/fetchDTaoTokenRates.ts
+const DEFAULT_BITTENSOR_NETWORK_ID = "bittensor";
+const DEFAULT_TAO_DATA_API_URL = "https://tda.talisman.xyz";
+const DEFAULT_TIMEOUT_MS = 1e4;
+const alphaPricesCodec = (0, scale_ts.Vector)((0, scale_ts.Struct)({
+	netuid: scale_ts.u16,
+	price: scale_ts.u64
+}));
+/** Current TAO-per-alpha pool price of every subnet, keyed by netuid, in the scaledAlphaPrice fixed-point format (rao) */
+const fetchScaledAlphaPricesByNetuid = async (connector, networkId) => {
+	const result = await connector.send(networkId, "state_call", ["SwapRuntimeApi_current_alpha_price_all", "0x"]);
+	return new Map(alphaPricesCodec.dec(result).map(({ netuid, price }) => [netuid, price]));
+};
+const ALPHA_PRICE_CHANGES_TTL = 5 * 6e4;
+const alphaPriceChangesCache = /* @__PURE__ */ new Map();
+/**
+* 24h percent change of every subnet pool price (alpha vs TAO) from the tao-data api — the
+* chain knows the current pool prices but not yesterday's. 5-min in-memory cache; failure is
+* non-fatal (stale cache when available, else no change24h on the computed rates).
+*/
+const getAlphaPriceChangesByNetuid = async (apiUrl, customFetch, timeoutMs) => {
+	const cached = alphaPriceChangesCache.get(apiUrl);
+	if (cached && performance.now() - cached.fetchedAt < ALPHA_PRICE_CHANGES_TTL) return cached.changes;
+	try {
+		const response = await customFetch(`${apiUrl}/pools`, { signal: AbortSignal.timeout(timeoutMs) });
+		if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+		const pools = await response.json();
+		const changes = new Map(pools.map((pool) => [pool.netuid, Number(pool.price_change_1_day)]).filter(([, change]) => Number.isFinite(change)));
+		alphaPriceChangesCache.set(apiUrl, {
+			fetchedAt: performance.now(),
+			changes
+		});
+		return changes;
+	} catch (err) {
+		log_default.warn("Failed to fetch alpha price 24h changes", err);
+		return cached?.changes ?? null;
+	}
 };
-var ALL_CURRENCY_IDS = Object.keys(SUPPORTED_CURRENCIES);
-var DEFAULT_COINSAPI_CONFIG = {
-  apiUrl: "https://coins.talisman.xyz"
+/**
+* Rates entries for the bittensor dtao (subnet alpha) tokens of `tokens`, priced from their
+* subnet pool combined with the TAO rates in `tokenRates`. On chain-fetch failure, falls
+* back to the token's entry in `previousRates` (keep-last). Never throws — a dtao pricing
+* failure must not discard the rates list it gets merged into.
+*
+* Hosts remain responsible for WHEN to call this (network enabled state, refresh cadence)
+* and for merging the result into their rates list/store.
+*/
+const fetchDTaoTokenRates = async ({ connector, networkId = DEFAULT_BITTENSOR_NETWORK_ID, tokens, tokenRates, previousRates, customFetch = fetch, taoDataApiUrl = DEFAULT_TAO_DATA_API_URL, timeoutMs = DEFAULT_TIMEOUT_MS }) => {
+	const dtaoTokens = Object.values(tokens).filter((token) => token.type === "substrate-dtao" && token.networkId === networkId && !token.coingeckoId);
+	if (!dtaoTokens.length) return {};
+	if (!tokenRates[(0, _talismn_chaindata_provider.subNativeTokenId)(networkId)]) return {};
+	const [prices, changes] = await Promise.all([Promise.race([fetchScaledAlphaPricesByNetuid(connector, networkId), (0, _talismn_util.throwAfter)(timeoutMs, `Timed out after ${timeoutMs}ms`)]).catch((err) => {
+		log_default.warn("Failed to fetch alpha prices, keeping previous dtao rates", err);
+		return null;
+	}), getAlphaPriceChangesByNetuid(taoDataApiUrl, customFetch, timeoutMs)]);
+	if (!prices) return Object.fromEntries(dtaoTokens.filter((token) => previousRates[token.id]).map((token) => [token.id, previousRates[token.id]]));
+	return Object.fromEntries(dtaoTokens.map((token) => {
+		const price = prices.get(token.netuid);
+		const rates = price ? getDTaoTokenRates(token, tokenRates, price, changes?.get(token.netuid)) : null;
+		return [token.id, rates ?? previousRates[token.id]];
+	}).filter(([, rates]) => !!rates));
 };
+//#endregion
+//#region src/TalismanTokenRatesDatabase.ts
+const tryToDeleteOldTokenRatesDb = () => {
+	try {
+		indexedDB.deleteDatabase("TalismanTokenRates");
+	} catch {}
+};
+//#endregion
+//#region src/TokenRates.ts
+var TokenRatesError = class extends Error {
+	response;
+	constructor(message, response) {
+		super(message);
+		this.response = response;
+	}
+};
+const ALL_CURRENCY_IDS = Object.keys(SUPPORTED_CURRENCIES);
+const DEFAULT_COINSAPI_CONFIG = { apiUrl: "https://coins.talisman.xyz" };
 async function fetchTokenRates(tokens, currencyIds = ALL_CURRENCY_IDS, config = DEFAULT_COINSAPI_CONFIG) {
-  const coingeckoIdToTokenIds = Object.values(tokens).flatMap((token) => {
-    if (token.type === "evm-uniswapv2") {
-      if (token.platform !== "ethereum") return [];
-      const getToken = (evmNetworkId, tokenAddress, coingeckoId) => ({
-        id: (0, import_chaindata_provider.evmErc20TokenId)(evmNetworkId, tokenAddress),
-        coingeckoId
-      });
-      const token0 = token.coingeckoId0 ? [getToken(token.networkId, token.tokenAddress0, token.coingeckoId0)] : [];
-      const token1 = token.coingeckoId1 ? [getToken(token.networkId, token.tokenAddress1, token.coingeckoId1)] : [];
-      return [...token0, ...token1];
-    }
-    if (!token.coingeckoId) return [];
-    return [{ id: token.id, coingeckoId: token.coingeckoId }];
-  }).reduce(
-    (coingeckoIdToTokenIds2, { id, coingeckoId }) => {
-      if (!coingeckoIdToTokenIds2[coingeckoId]) coingeckoIdToTokenIds2[coingeckoId] = [];
-      coingeckoIdToTokenIds2[coingeckoId].push(id);
-      return coingeckoIdToTokenIds2;
-    },
-    {}
-  );
-  const coingeckoIds = Object.keys(coingeckoIdToTokenIds).sort();
-  if (coingeckoIds.length < 1) return {};
-  const hasVsTao = currencyIds.includes("tao");
-  const [effectiveCoingeckoIds, effectiveCurrencyIds] = hasVsTao ? [
-    [...new Set(coingeckoIds).add("bittensor")],
-    [
-      ...new Set(
-        // don't request `tao` from coingecko (we calculate it from `usd`)
-        currencyIds.filter((c) => c !== "tao")
-      ).add("usd")
-    ]
-  ] : [coingeckoIds, currencyIds];
-  const response = await fetch(`${config.apiUrl}/token-rates`, {
-    method: "POST",
-    body: JSON.stringify({
-      coingeckoIds: effectiveCoingeckoIds,
-      currencyIds: effectiveCurrencyIds
-    })
-  });
-  const rawTokenRates = await response.json();
-  if (hasVsTao) {
-    const effectiveTaoIndex = effectiveCoingeckoIds.indexOf("bittensor");
-    const effectiveUsdIndex = effectiveCurrencyIds.indexOf("usd");
-    const taoUsdRate = rawTokenRates[effectiveTaoIndex]?.[effectiveUsdIndex]?.[0];
-    const taoUsdChange24h = rawTokenRates[effectiveTaoIndex]?.[effectiveUsdIndex]?.[2];
-    const taoIndex = currencyIds.indexOf("tao");
-    rawTokenRates.forEach((rates, i) => {
-      if (i === effectiveTaoIndex) {
-        rates?.splice(taoIndex, 0, [1, null, null]);
-        return;
-      }
-      const tokenUsdRate = rates?.[effectiveUsdIndex]?.[0];
-      const tokenTaoRate = typeof tokenUsdRate === "number" && typeof taoUsdRate === "number" && taoUsdRate !== 0 ? tokenUsdRate / taoUsdRate : null;
-      const tokenUsdChange24h = rates?.[effectiveUsdIndex]?.[2];
-      const tokenTaoChange24h = typeof taoUsdChange24h === "number" && typeof tokenUsdChange24h === "number" ? (1 + tokenUsdChange24h) / (1 + taoUsdChange24h) - 1 : null;
-      rates?.splice(taoIndex, 0, [tokenTaoRate, null, tokenTaoChange24h]);
-    });
-  }
-  const tokenRates = parseTokenRatesFromApi(rawTokenRates, coingeckoIds, currencyIds);
-  const ratesList = Object.fromEntries(
-    Object.entries(tokens).map(([tokenId, token]) => [
-      tokenId,
-      token.coingeckoId ? tokenRates[token.coingeckoId] ?? null : null
-    ])
-  );
-  return ratesList;
+	const coingeckoIdToTokenIds = Object.values(tokens).flatMap((token) => {
+		if (token.type === "evm-uniswapv2") {
+			if (token.platform !== "ethereum") return [];
+			const getToken = (evmNetworkId, tokenAddress, coingeckoId) => ({
+				id: (0, _talismn_chaindata_provider.evmErc20TokenId)(evmNetworkId, tokenAddress),
+				coingeckoId
+			});
+			const token0 = token.coingeckoId0 ? [getToken(token.networkId, token.tokenAddress0, token.coingeckoId0)] : [];
+			const token1 = token.coingeckoId1 ? [getToken(token.networkId, token.tokenAddress1, token.coingeckoId1)] : [];
+			return [...token0, ...token1];
+		}
+		if (!token.coingeckoId) return [];
+		return [{
+			id: token.id,
+			coingeckoId: token.coingeckoId
+		}];
+	}).reduce((coingeckoIdToTokenIds, { id, coingeckoId }) => {
+		if (!coingeckoIdToTokenIds[coingeckoId]) coingeckoIdToTokenIds[coingeckoId] = [];
+		coingeckoIdToTokenIds[coingeckoId].push(id);
+		return coingeckoIdToTokenIds;
+	}, {});
+	const coingeckoIds = Object.keys(coingeckoIdToTokenIds).sort();
+	if (coingeckoIds.length < 1) return {};
+	const hasVsTao = currencyIds.includes("tao");
+	const [effectiveCoingeckoIds, effectiveCurrencyIds] = hasVsTao ? [[...new Set(coingeckoIds).add("bittensor")], [...new Set(currencyIds.filter((c) => c !== "tao")).add("usd")]] : [coingeckoIds, currencyIds];
+	const rawTokenRates = await (await fetch(`${config.apiUrl}/token-rates`, {
+		method: "POST",
+		body: JSON.stringify({
+			coingeckoIds: effectiveCoingeckoIds,
+			currencyIds: effectiveCurrencyIds
+		})
+	})).json();
+	if (hasVsTao) {
+		const effectiveTaoIndex = effectiveCoingeckoIds.indexOf("bittensor");
+		const effectiveUsdIndex = effectiveCurrencyIds.indexOf("usd");
+		const taoUsdRate = rawTokenRates[effectiveTaoIndex]?.[effectiveUsdIndex]?.[0];
+		const taoUsdChange24h = rawTokenRates[effectiveTaoIndex]?.[effectiveUsdIndex]?.[2];
+		const taoIndex = currencyIds.indexOf("tao");
+		rawTokenRates.forEach((rates, i) => {
+			if (i === effectiveTaoIndex) {
+				rates?.splice(taoIndex, 0, [
+					1,
+					null,
+					null
+				]);
+				return;
+			}
+			const tokenUsdRate = rates?.[effectiveUsdIndex]?.[0];
+			const tokenTaoRate = typeof tokenUsdRate === "number" && typeof taoUsdRate === "number" && taoUsdRate !== 0 ? tokenUsdRate / taoUsdRate : null;
+			const tokenUsdChange24h = rates?.[effectiveUsdIndex]?.[2];
+			const tokenTaoChange24h = typeof taoUsdChange24h === "number" && typeof tokenUsdChange24h === "number" ? (1 + tokenUsdChange24h) / (1 + taoUsdChange24h) - 1 : null;
+			rates?.splice(taoIndex, 0, [
+				tokenTaoRate,
+				null,
+				tokenTaoChange24h
+			]);
+		});
+	}
+	const tokenRates = parseTokenRatesFromApi(rawTokenRates, coingeckoIds, currencyIds);
+	return Object.fromEntries(Object.entries(tokens).map(([tokenId, token]) => [tokenId, token.coingeckoId ? tokenRates[token.coingeckoId] ?? null : null]));
 }
-var parseTokenRatesFromApi = (rawTokenRates, coingeckoIds, currencyIds) => {
-  return Object.fromEntries(
-    coingeckoIds.map((coingeckoId, idx) => {
-      const rates = rawTokenRates[idx];
-      if (!rates) return [coingeckoId, null];
-      return [
-        coingeckoId,
-        Object.fromEntries(
-          currencyIds.map((currencyId, idx2) => {
-            const curRate = rates[idx2];
-            if (!curRate) return [currencyId, null];
-            const [price, marketCap, change24h] = rates[idx2];
-            return [currencyId, { price, marketCap, change24h }];
-          })
-        )
-      ];
-    })
-  );
+const parseTokenRatesFromApi = (rawTokenRates, coingeckoIds, currencyIds) => {
+	return Object.fromEntries(coingeckoIds.map((coingeckoId, idx) => {
+		const rates = rawTokenRates[idx];
+		if (!rates) return [coingeckoId, null];
+		return [coingeckoId, Object.fromEntries(currencyIds.map((currencyId, idx) => {
+			if (!rates[idx]) return [currencyId, null];
+			const [price, marketCap, change24h] = rates[idx];
+			return [currencyId, {
+				price,
+				marketCap,
+				change24h
+			}];
+		}))];
+	}));
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ALL_CURRENCY_IDS,
-  DEFAULT_COINSAPI_CONFIG,
-  SUPPORTED_CURRENCIES,
-  TokenRatesError,
-  fetchTokenRates,
-  newTokenRates,
-  tryToDeleteOldTokenRatesDb
-});
+//#endregion
+exports.ALL_CURRENCY_IDS = ALL_CURRENCY_IDS;
+exports.DEFAULT_COINSAPI_CONFIG = DEFAULT_COINSAPI_CONFIG;
+exports.SUPPORTED_CURRENCIES = SUPPORTED_CURRENCIES;
+exports.TokenRatesError = TokenRatesError;
+exports.fetchDTaoTokenRates = fetchDTaoTokenRates;
+exports.fetchTokenRates = fetchTokenRates;
+exports.getDTaoTokenRates = getDTaoTokenRates;
+exports.newTokenRates = newTokenRates;
+exports.tryToDeleteOldTokenRatesDb = tryToDeleteOldTokenRatesDb;
+
 //# sourceMappingURL=index.js.map