coingecko-tokens
Version:
Aggregated list of Token Lists from CoinGecko
957 lines (872 loc) • 26.1 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["geckoTokens"] = factory();
else
root["geckoTokens"] = factory();
})(self, () => {
return /******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 277:
/***/ (() => {
/* (ignored) */
/***/ }),
/***/ 358:
/***/ (() => {
;
/***/ }),
/***/ 363:
/***/ (() => {
/* (ignored) */
/***/ }),
/***/ 680:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
;
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ S: () => (/* binding */ ajv),
/* harmony export */ w: () => (/* binding */ Ajv)
/* harmony export */ });
/* harmony import */ var ajv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(363);
/* harmony import */ var ajv__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(ajv__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var ajv_formats__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(764);
/* harmony import */ var ajv_formats__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(ajv_formats__WEBPACK_IMPORTED_MODULE_1__);
const Ajv = globalThis?.Ajv || (() => {
const __Ajv = (ajv__WEBPACK_IMPORTED_MODULE_0___default());
__Ajv.addFormats = (ajv_formats__WEBPACK_IMPORTED_MODULE_1___default());
return __Ajv;
})();
const ajv = new Ajv({
allErrors: true,
allowUnionTypes: true
});
Ajv.addFormats(ajv);
/***/ }),
/***/ 745:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
;
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
uo: () => (/* binding */ ethers),
iM: () => (/* binding */ getTokenList),
Tr: () => (/* binding */ rebuildTokenList),
of: () => (/* binding */ tokenListValidator),
KM: () => (/* binding */ tokenValidator)
});
// EXTERNAL MODULE: ethers (ignored)
var ethers_ignored_ = __webpack_require__(277);
;// ./node_modules/@uniswap/token-lists/dist/token-lists.esm.js
var $schema = "http://json-schema.org/draft-07/schema#";
var $id = "https://uniswap.org/tokenlist.schema.json";
var title = "Uniswap Token List";
var description = "Schema for lists of tokens compatible with the Uniswap Interface";
var definitions = {
Version: {
type: "object",
description: "The version of the list, used in change detection",
examples: [
{
major: 1,
minor: 0,
patch: 0
}
],
additionalProperties: false,
properties: {
major: {
type: "integer",
description: "The major version of the list. Must be incremented when tokens are removed from the list or token addresses are changed.",
minimum: 0,
examples: [
1,
2
]
},
minor: {
type: "integer",
description: "The minor version of the list. Must be incremented when tokens are added to the list.",
minimum: 0,
examples: [
0,
1
]
},
patch: {
type: "integer",
description: "The patch version of the list. Must be incremented for any changes to the list.",
minimum: 0,
examples: [
0,
1
]
}
},
required: [
"major",
"minor",
"patch"
]
},
TagIdentifier: {
type: "string",
description: "The unique identifier of a tag",
minLength: 1,
maxLength: 10,
pattern: "^[\\w]+$",
examples: [
"compound",
"stablecoin"
]
},
ExtensionIdentifier: {
type: "string",
description: "The name of a token extension property",
minLength: 1,
maxLength: 40,
pattern: "^[\\w]+$",
examples: [
"color",
"is_fee_on_transfer",
"aliases"
]
},
ExtensionMap: {
type: "object",
description: "An object containing any arbitrary or vendor-specific token metadata",
maxProperties: 10,
propertyNames: {
$ref: "#/definitions/ExtensionIdentifier"
},
additionalProperties: {
$ref: "#/definitions/ExtensionValue"
},
examples: [
{
color: "#000000",
is_verified_by_me: true
},
{
"x-bridged-addresses-by-chain": {
"1": {
bridgeAddress: "0x4200000000000000000000000000000000000010",
tokenAddress: "0x4200000000000000000000000000000000000010"
}
}
}
]
},
ExtensionPrimitiveValue: {
anyOf: [
{
type: "string",
minLength: 1,
maxLength: 42,
examples: [
"#00000"
]
},
{
type: "boolean",
examples: [
true
]
},
{
type: "number",
examples: [
15
]
},
{
type: "null"
}
]
},
ExtensionValue: {
anyOf: [
{
$ref: "#/definitions/ExtensionPrimitiveValue"
},
{
type: "object",
maxProperties: 10,
propertyNames: {
$ref: "#/definitions/ExtensionIdentifier"
},
additionalProperties: {
$ref: "#/definitions/ExtensionValueInner0"
}
}
]
},
ExtensionValueInner0: {
anyOf: [
{
$ref: "#/definitions/ExtensionPrimitiveValue"
},
{
type: "object",
maxProperties: 10,
propertyNames: {
$ref: "#/definitions/ExtensionIdentifier"
},
additionalProperties: {
$ref: "#/definitions/ExtensionValueInner1"
}
}
]
},
ExtensionValueInner1: {
anyOf: [
{
$ref: "#/definitions/ExtensionPrimitiveValue"
}
]
},
TagDefinition: {
type: "object",
description: "Definition of a tag that can be associated with a token via its identifier",
additionalProperties: false,
properties: {
name: {
type: "string",
description: "The name of the tag",
pattern: "^[ \\w]+$",
minLength: 1,
maxLength: 20
},
description: {
type: "string",
description: "A user-friendly description of the tag",
pattern: "^[ \\w\\.,:]+$",
minLength: 1,
maxLength: 200
}
},
required: [
"name",
"description"
],
examples: [
{
name: "Stablecoin",
description: "A token with value pegged to another asset"
}
]
},
TokenInfo: {
type: "object",
description: "Metadata for a single token in a token list",
additionalProperties: false,
properties: {
chainId: {
type: "integer",
description: "The chain ID of the Ethereum network where this token is deployed",
minimum: 1,
examples: [
1,
42
]
},
address: {
type: "string",
description: "The checksummed address of the token on the specified chain ID",
pattern: "^0x[a-fA-F0-9]{40}$",
examples: [
"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
]
},
decimals: {
type: "integer",
description: "The number of decimals for the token balance",
minimum: 0,
maximum: 255,
examples: [
18
]
},
name: {
type: "string",
description: "The name of the token",
minLength: 0,
maxLength: 60,
anyOf: [
{
"const": ""
},
{
pattern: "^[ \\S+]+$"
}
],
examples: [
"USD Coin"
]
},
symbol: {
type: "string",
description: "The symbol for the token",
minLength: 0,
maxLength: 20,
anyOf: [
{
"const": ""
},
{
pattern: "^\\S+$"
}
],
examples: [
"USDC"
]
},
logoURI: {
type: "string",
description: "A URI to the token logo asset; if not set, interface will attempt to find a logo based on the token address; suggest SVG or PNG of size 64x64",
format: "uri",
examples: [
"ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"
]
},
tags: {
type: "array",
description: "An array of tag identifiers associated with the token; tags are defined at the list level",
items: {
$ref: "#/definitions/TagIdentifier"
},
maxItems: 10,
examples: [
"stablecoin",
"compound"
]
},
extensions: {
$ref: "#/definitions/ExtensionMap"
}
},
required: [
"chainId",
"address",
"decimals",
"name",
"symbol"
]
}
};
var type = "object";
var properties = {
name: {
type: "string",
description: "The name of the token list",
minLength: 1,
maxLength: 30,
pattern: "^[\\w ]+$",
examples: [
"My Token List"
]
},
timestamp: {
type: "string",
format: "date-time",
description: "The timestamp of this list version; i.e. when this immutable version of the list was created"
},
version: {
$ref: "#/definitions/Version"
},
tokens: {
type: "array",
description: "The list of tokens included in the list",
items: {
$ref: "#/definitions/TokenInfo"
},
minItems: 1,
maxItems: 10000
},
tokenMap: {
type: "object",
description: "A mapping of key 'chainId_tokenAddress' to its corresponding token object",
minProperties: 1,
maxProperties: 10000,
propertyNames: {
type: "string"
},
additionalProperties: {
$ref: "#/definitions/TokenInfo"
},
examples: [
{
"4_0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984": {
name: "Uniswap",
address: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984",
symbol: "UNI",
decimals: 18,
chainId: 4,
logoURI: "ipfs://QmXttGpZrECX5qCyXbBQiqgQNytVGeZW5Anewvh2jc4psg"
}
}
]
},
keywords: {
type: "array",
description: "Keywords associated with the contents of the list; may be used in list discoverability",
items: {
type: "string",
description: "A keyword to describe the contents of the list",
minLength: 1,
maxLength: 20,
pattern: "^[\\w ]+$",
examples: [
"compound",
"lending",
"personal tokens"
]
},
maxItems: 20,
uniqueItems: true
},
tags: {
type: "object",
description: "A mapping of tag identifiers to their name and description",
propertyNames: {
$ref: "#/definitions/TagIdentifier"
},
additionalProperties: {
$ref: "#/definitions/TagDefinition"
},
maxProperties: 20,
examples: [
{
stablecoin: {
name: "Stablecoin",
description: "A token with value pegged to another asset"
}
}
]
},
logoURI: {
type: "string",
description: "A URI for the logo of the token list; prefer SVG or PNG of size 256x256",
format: "uri",
examples: [
"ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"
]
}
};
var required = [
"name",
"timestamp",
"version",
"tokens"
];
var tokenlist_schema = {
$schema: $schema,
$id: $id,
title: title,
description: description,
definitions: definitions,
type: type,
properties: properties,
required: required
};
/**
* Comparator function that allows sorting version from lowest to highest
* @param versionA version A to compare
* @param versionB version B to compare
* @returns -1 if versionA comes before versionB, 0 if versionA is equal to version B, and 1 if version A comes after version B
*/
function versionComparator(versionA, versionB) {
if (versionA.major < versionB.major) {
return -1;
} else if (versionA.major > versionB.major) {
return 1;
} else if (versionA.minor < versionB.minor) {
return -1;
} else if (versionA.minor > versionB.minor) {
return 1;
} else if (versionA.patch < versionB.patch) {
return -1;
} else if (versionA.patch > versionB.patch) {
return 1;
} else {
return 0;
}
}
/**
* Returns true if versionB is an update over versionA
*/
function isVersionUpdate(base, update) {
return versionComparator(base, update) < 0;
}
var VersionUpgrade;
(function (VersionUpgrade) {
VersionUpgrade[VersionUpgrade["NONE"] = 0] = "NONE";
VersionUpgrade[VersionUpgrade["PATCH"] = 1] = "PATCH";
VersionUpgrade[VersionUpgrade["MINOR"] = 2] = "MINOR";
VersionUpgrade[VersionUpgrade["MAJOR"] = 3] = "MAJOR";
})(VersionUpgrade || (VersionUpgrade = {}));
/**
* Return the upgrade type from the base version to the update version.
* Note that downgrades and equivalent versions are both treated as `NONE`.
* @param base base list
* @param update update to the list
*/
function getVersionUpgrade(base, update) {
if (update.major > base.major) {
return VersionUpgrade.MAJOR;
}
if (update.major < base.major) {
return VersionUpgrade.NONE;
}
if (update.minor > base.minor) {
return VersionUpgrade.MINOR;
}
if (update.minor < base.minor) {
return VersionUpgrade.NONE;
}
return update.patch > base.patch ? VersionUpgrade.PATCH : VersionUpgrade.NONE;
}
/**
* compares two token info key values
* this subset of full deep equal functionality does not work on objects or object arrays
* @param a comparison item a
* @param b comparison item b
*/
function compareTokenInfoProperty(a, b) {
if (a === b) return true;
if (typeof a !== typeof b) return false;
if (Array.isArray(a) && Array.isArray(b)) {
return a.every(function (el, i) {
return b[i] === el;
});
}
return false;
}
/**
* Computes the diff of a token list where the first argument is the base and the second argument is the updated list.
* @param base base list
* @param update updated list
*/
function diffTokenLists(base, update) {
var indexedBase = base.reduce(function (memo, tokenInfo) {
if (!memo[tokenInfo.chainId]) memo[tokenInfo.chainId] = {};
memo[tokenInfo.chainId][tokenInfo.address] = tokenInfo;
return memo;
}, {});
var newListUpdates = update.reduce(function (memo, tokenInfo) {
var _indexedBase$tokenInf;
var baseToken = (_indexedBase$tokenInf = indexedBase[tokenInfo.chainId]) == null ? void 0 : _indexedBase$tokenInf[tokenInfo.address];
if (!baseToken) {
memo.added.push(tokenInfo);
} else {
var changes = Object.keys(tokenInfo).filter(function (s) {
return s !== 'address' && s !== 'chainId';
}).filter(function (s) {
return !compareTokenInfoProperty(tokenInfo[s], baseToken[s]);
});
if (changes.length > 0) {
if (!memo.changed[tokenInfo.chainId]) {
memo.changed[tokenInfo.chainId] = {};
}
memo.changed[tokenInfo.chainId][tokenInfo.address] = changes;
}
}
if (!memo.index[tokenInfo.chainId]) {
var _memo$index$tokenInfo;
memo.index[tokenInfo.chainId] = (_memo$index$tokenInfo = {}, _memo$index$tokenInfo[tokenInfo.address] = true, _memo$index$tokenInfo);
} else {
memo.index[tokenInfo.chainId][tokenInfo.address] = true;
}
return memo;
}, {
added: [],
changed: {},
index: {}
});
var removed = base.reduce(function (list, curr) {
if (!newListUpdates.index[curr.chainId] || !newListUpdates.index[curr.chainId][curr.address]) {
list.push(curr);
}
return list;
}, []);
return {
added: newListUpdates.added,
changed: newListUpdates.changed,
removed: removed
};
}
/**
* Returns the minimum version bump for the given list
* @param baseList the base list of tokens
* @param updatedList the updated list of tokens
*/
function minVersionBump(baseList, updatedList) {
var diff = diffTokenLists(baseList, updatedList);
if (diff.removed.length > 0) return VersionUpgrade.MAJOR;
if (diff.added.length > 0) return VersionUpgrade.MINOR;
if (Object.keys(diff.changed).length > 0) return VersionUpgrade.PATCH;
return VersionUpgrade.NONE;
}
/**
* Returns the next version of the list given a base version and the upgrade type
* @param base current version
* @param bump the upgrade type
*/
function nextVersion(base, bump) {
switch (bump) {
case VersionUpgrade.NONE:
return base;
case VersionUpgrade.MAJOR:
return {
major: base.major + 1,
minor: 0,
patch: 0
};
case VersionUpgrade.MINOR:
return {
major: base.major,
minor: base.minor + 1,
patch: 0
};
case VersionUpgrade.PATCH:
return {
major: base.major,
minor: base.minor,
patch: base.patch + 1
};
}
}
//# sourceMappingURL=token-lists.esm.js.map
// EXTERNAL MODULE: ./src/ajv.ts
var ajv = __webpack_require__(680);
;// ./src/getTokenList.ts
const ethers = globalThis?.ethers || ethers_ignored_.ethers;
const tokenListValidator = ajv/* ajv */.S.compile(tokenlist_schema);
const tokenValidator = (() => {
const tokenSchema = JSON.parse(JSON.stringify(tokenlist_schema));
delete tokenSchema.type;
delete tokenSchema.properties;
delete tokenSchema.required;
tokenSchema["$id"] = "Uniswap Token Schema";
tokenSchema["$ref"] = "#/definitions/TokenInfo";
return ajv/* ajv */.S.compile(tokenSchema);
})();
async function rebuildTokenList(url, tokenList) {
const newList = JSON.parse(JSON.stringify(tokenList));
if (newList.tokens.length > 1) {
newList.tokens.length = 1;
}
if (!tokenListValidator(newList)) {
throw new Error(`${url} validation failed: ${JSON.stringify(tokenListValidator.errors, null, 2)}`);
}
newList.tokens = tokenList.tokens.filter((token) => {
return tokenValidator(token);
}).map((token) => {
token.address = ethers.getAddress(token.address);
return token;
});
if (!tokenListValidator(newList)) {
throw new Error(`${url} validation failed: ${JSON.stringify(tokenListValidator.errors, null, 2)}`);
}
return newList;
}
async function getTokenList(url, fetchParams) {
const resp = await fetch(url, {
...fetchParams || {},
method: "GET",
signal: fetchParams?.signal || AbortSignal.timeout(60 * 1e3)
});
if (!resp.ok) {
throw new Error(resp.statusText);
}
const list = await resp.json();
if (fetchParams?.rebuildList) {
return rebuildTokenList(url, list);
}
if (!tokenListValidator(list)) {
throw new Error(`${url} validation failed: ${JSON.stringify(tokenListValidator.errors, null, 2)}`);
}
return list;
}
/***/ }),
/***/ 764:
/***/ (() => {
/* (ignored) */
/***/ }),
/***/ 844:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
;
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ $t: () => (/* binding */ UNISWAP_TOKEN_LIST),
/* harmony export */ M9: () => (/* binding */ getUniswapList),
/* harmony export */ _v: () => (/* binding */ COINGECKO_CHAINS),
/* harmony export */ a5: () => (/* binding */ COINGECKO_TOKEN_API),
/* harmony export */ tS: () => (/* binding */ getCoingekoLists)
/* harmony export */ });
/* harmony import */ var _getTokenList__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(745);
const UNISWAP_TOKEN_LIST = "https://tokens-uniswap-org.ipns.dweb.link";
const COINGECKO_TOKEN_API = "https://tokens.coingecko.com";
const COINGECKO_CHAINS = [
"uniswap",
"binance-smart-chain",
"arbitrum-one",
"optimistic-ethereum",
"polygon-pos",
"avalanche",
"xdai",
"base",
"unichain",
"ethereum-classic"
];
function getCoingekoLists(fetchParams) {
return Promise.all(
COINGECKO_CHAINS.map((chain) => {
return (0,_getTokenList__WEBPACK_IMPORTED_MODULE_0__/* .getTokenList */ .iM)(`${COINGECKO_TOKEN_API}/${chain}/all.json`, fetchParams);
})
);
}
function getUniswapList(fetchParams) {
return (0,_getTokenList__WEBPACK_IMPORTED_MODULE_0__/* .getTokenList */ .iM)(UNISWAP_TOKEN_LIST, fetchParams);
}
/***/ }),
/***/ 850:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
;
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ _: () => (/* binding */ COINGECKO_API),
/* harmony export */ q: () => (/* binding */ getTopTokens)
/* harmony export */ });
const COINGECKO_API = "https://api.coingecko.com/api/v3/coins/markets";
async function getTopTokens() {
const params = [];
for (let i = 1; i < 5; ++i) {
params.push(
new URLSearchParams({
vs_currency: "usd",
order: "market_cap_desc",
per_page: String(250),
page: String(i)
}).toString()
);
}
const topTokens = (await Promise.all(
params.map(async (param) => {
const resp = await fetch(`${COINGECKO_API}?${param}`, {
method: "GET",
signal: AbortSignal.timeout(60 * 1e3)
});
if (!resp.ok) {
throw new Error(resp.statusText);
}
return resp.json();
})
)).flat();
return {
topTokens,
topTokenSet: new Set(topTokens.map((l) => l.symbol?.toLowerCase() || "").flat())
};
}
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = (exports) => {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ })();
/******/
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
(() => {
;
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ Ajv: () => (/* reexport safe */ _ajv__WEBPACK_IMPORTED_MODULE_0__.w),
/* harmony export */ COINGECKO_API: () => (/* reexport safe */ _getTopTokens__WEBPACK_IMPORTED_MODULE_3__._),
/* harmony export */ COINGECKO_CHAINS: () => (/* reexport safe */ _getCoingeko__WEBPACK_IMPORTED_MODULE_1__._v),
/* harmony export */ COINGECKO_TOKEN_API: () => (/* reexport safe */ _getCoingeko__WEBPACK_IMPORTED_MODULE_1__.a5),
/* harmony export */ UNISWAP_TOKEN_LIST: () => (/* reexport safe */ _getCoingeko__WEBPACK_IMPORTED_MODULE_1__.$t),
/* harmony export */ ajv: () => (/* reexport safe */ _ajv__WEBPACK_IMPORTED_MODULE_0__.S),
/* harmony export */ ethers: () => (/* reexport safe */ _getTokenList__WEBPACK_IMPORTED_MODULE_2__.uo),
/* harmony export */ getCoingekoLists: () => (/* reexport safe */ _getCoingeko__WEBPACK_IMPORTED_MODULE_1__.tS),
/* harmony export */ getTokenList: () => (/* reexport safe */ _getTokenList__WEBPACK_IMPORTED_MODULE_2__.iM),
/* harmony export */ getTopTokens: () => (/* reexport safe */ _getTopTokens__WEBPACK_IMPORTED_MODULE_3__.q),
/* harmony export */ getUniswapList: () => (/* reexport safe */ _getCoingeko__WEBPACK_IMPORTED_MODULE_1__.M9),
/* harmony export */ rebuildTokenList: () => (/* reexport safe */ _getTokenList__WEBPACK_IMPORTED_MODULE_2__.Tr),
/* harmony export */ tokenListValidator: () => (/* reexport safe */ _getTokenList__WEBPACK_IMPORTED_MODULE_2__.of),
/* harmony export */ tokenValidator: () => (/* reexport safe */ _getTokenList__WEBPACK_IMPORTED_MODULE_2__.KM)
/* harmony export */ });
/* harmony import */ var _ajv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(680);
/* harmony import */ var _getCoingeko__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(844);
/* harmony import */ var _getTokenList__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(745);
/* harmony import */ var _getTopTokens__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(850);
/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(358);
/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_types__WEBPACK_IMPORTED_MODULE_4__);
/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};
/* harmony reexport (unknown) */ for(const __WEBPACK_IMPORT_KEY__ in _types__WEBPACK_IMPORTED_MODULE_4__) if(["default","Ajv","ajv","COINGECKO_CHAINS","COINGECKO_TOKEN_API","UNISWAP_TOKEN_LIST","getCoingekoLists","getUniswapList","ethers","getTokenList","rebuildTokenList","tokenListValidator","tokenValidator","COINGECKO_API","getTopTokens"].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = () => _types__WEBPACK_IMPORTED_MODULE_4__[__WEBPACK_IMPORT_KEY__]
/* harmony reexport (unknown) */ __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
})();
/******/ return __webpack_exports__;
/******/ })()
;
});