@pancakeswap/token-lists 0.0.14 → 0.0.16

package/dist/react.js

@@ -1,7 +1,6 @@
 'use strict';
 
-var chunkOGWZ2K32_js = require('./chunk-OGWZ2K32.js');
-var chunk4TPCCB4K_js = require('./chunk-4TPCCB4K.js');
+var chunkYOAEDKQH_js = require('./chunk-YOAEDKQH.js');
 var toolkit = require('@reduxjs/toolkit');
 var jotai = require('jotai');
 var utils = require('jotai/utils');
@@ -25,7 +24,560 @@ var acceptListUpdate = toolkit.createAction("lists/acceptListUpdate");
 var rejectVersionUpdate = toolkit.createAction("lists/rejectVersionUpdate");
 var updateListVersion = toolkit.createAction("lists/updateListVersion");
 
-// react/reducer.ts
+// ../utils/uriToHttp.ts
+function uriToHttp(uri) {
+  var _a, _b;
+  const protocol = uri.split(":")[0].toLowerCase();
+  switch (protocol) {
+    case "https":
+      return [uri];
+    case "http":
+      return [`https${uri.substring(4)}`, uri];
+    case "ipfs":
+      const hash = (_a = uri.match(/^ipfs:(\/\/)?(.*)$/i)) == null ? void 0 : _a[2];
+      return [`https://cloudflare-ipfs.com/ipfs/${hash}/`, `https://ipfs.io/ipfs/${hash}/`];
+    case "ipns":
+      const name = (_b = uri.match(/^ipns:(\/\/)?(.*)$/i)) == null ? void 0 : _b[2];
+      return [`https://cloudflare-ipfs.com/ipns/${name}/`, `https://ipfs.io/ipns/${name}/`];
+    default:
+      return [];
+  }
+}
+
+// schema/pancakeswap.json
+var pancakeswap_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "pancakeswap",
+  title: "PancakeSwap Token List",
+  description: "Schema for lists of tokens compatible with the PancakeSwap Interface, including Uniswap standard and PancakeSwap Aptos",
+  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: 1,
+          maxLength: 40,
+          pattern: "^[ \\w.'+\\-%/\xC0-\xD6\xD8-\xF6\xF8-\xFF:&\\[\\]\\(\\)]+$",
+          examples: ["USD Coin"]
+        },
+        symbol: {
+          type: "string",
+          description: "The symbol for the token; must be alphanumeric",
+          pattern: "^[a-zA-Z0-9+\\-%/$.\\s]+$",
+          minLength: 1,
+          maxLength: 20,
+          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"]
+    },
+    AptosTokenInfo: {
+      type: "object",
+      description: "Metadata for a single token in a token list",
+      additionalProperties: false,
+      properties: {
+        chainId: {
+          type: "integer",
+          description: "The chain ID of the Aptos network where this token is deployed, 0 is devent",
+          minimum: 0,
+          examples: [1, 42]
+        },
+        address: {
+          type: "string",
+          description: "The address of the coin on the specified chain ID",
+          examples: ["0x1::aptos_coin::AptosCoin"]
+        },
+        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: 1,
+          maxLength: 40,
+          pattern: "^[ \\w.'+\\-%/\xC0-\xD6\xD8-\xF6\xF8-\xFF:&\\[\\]\\(\\)]+$",
+          examples: ["USD Coin"]
+        },
+        symbol: {
+          type: "string",
+          description: "The symbol for the token; must be alphanumeric",
+          pattern: "^[a-zA-Z0-9+\\-%/$.]+$",
+          minLength: 1,
+          maxLength: 20,
+          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"]
+    }
+  },
+  type: "object",
+  additionalProperties: false,
+  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"
+    },
+    schema: {
+      type: "string"
+    },
+    version: {
+      $ref: "#/definitions/Version"
+    },
+    tokens: {
+      type: "array",
+      description: "The list of tokens included in the list",
+      minItems: 1,
+      maxItems: 1e4
+    },
+    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"]
+    }
+  },
+  if: {
+    properties: { schema: { const: "aptos" } },
+    required: ["name", "timestamp", "version", "tokens", "schema"]
+  },
+  then: {
+    properties: {
+      tokens: {
+        items: {
+          $ref: "#/definitions/AptosTokenInfo"
+        },
+        type: "array",
+        description: "The list of tokens included in the list",
+        minItems: 1,
+        maxItems: 1e4
+      }
+    }
+  },
+  else: {
+    properties: {
+      tokens: {
+        items: {
+          $ref: "#/definitions/TokenInfo"
+        },
+        type: "array",
+        description: "The list of tokens included in the list",
+        minItems: 1,
+        maxItems: 1e4
+      }
+    }
+  },
+  required: ["name", "timestamp", "version", "tokens"]
+};
+
+// react/getTokenList.ts
+function getTokenList(listUrl) {
+  return chunkYOAEDKQH_js.__async(this, null, function* () {
+    const urls = uriToHttp(listUrl);
+    const { default: Ajv } = yield import('ajv');
+    const validator = new Ajv({ allErrors: true }).compile(pancakeswap_default);
+    for (const [i, url] of urls.entries()) {
+      try {
+        const json = yield fetchJson(url);
+        if (!validator(json)) {
+          const preFilterErrors = validator.errors;
+          json.tokens = json.tokens.filter((token) => validator(chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, json), { tokens: [token] })));
+          if (!validator(json)) {
+            const errors = validator.errors;
+            throw new Error(`Validation failed after filtering: ${JSON.stringify(errors)}`);
+          }
+          console.warn(`Pre-filter validation errors: ${JSON.stringify(preFilterErrors)}`);
+        }
+        return json;
+      } catch (error) {
+        return void 0;
+      }
+    }
+    throw new Error("Unrecognized list URL protocol.");
+  });
+}
+function fetchJson(url) {
+  return chunkYOAEDKQH_js.__async(this, null, function* () {
+    const res = yield fetch(url);
+    if (!res.ok)
+      throw new Error(`Failed to fetch: ${url}`);
+    return res.json();
+  });
+}
+function noop() {
+}
+var noopStorage = {
+  getItem: () => Promise.resolve(noop()),
+  setItem: () => Promise.resolve(noop()),
+  removeItem: () => Promise.resolve(noop())
+};
+var EMPTY = Symbol();
+function findTokenByAddress(state, chainId, address) {
+  var _a, _b;
+  const urls = (_a = state.activeListUrls) != null ? _a : Object.keys(state.byUrl);
+  for (const url of urls) {
+    const list = (_b = state.byUrl[url]) == null ? void 0 : _b.current;
+    const token = list == null ? void 0 : list.tokens.find((t) => t.chainId === chainId && t.address.toLowerCase() === address.toLowerCase());
+    if (token)
+      return token;
+  }
+  return void 0;
+}
+function findTokenBySymbol(state, chainId, symbol) {
+  var _a, _b;
+  const urls = (_a = state.activeListUrls) != null ? _a : Object.keys(state.byUrl);
+  for (const url of urls) {
+    const list = (_b = state.byUrl[url]) == null ? void 0 : _b.current;
+    const token = list == null ? void 0 : list.tokens.find((t) => t.chainId === chainId && t.symbol.toLowerCase() === symbol.toLowerCase());
+    if (token)
+      return token;
+  }
+  return void 0;
+}
+var createListsAtom = (storeName, reducer, initialState) => {
+  function IndexedDBStorage(dbName) {
+    if (typeof window !== "undefined") {
+      const db = localForage__default.default.createInstance({
+        name: dbName,
+        storeName
+      });
+      return {
+        getItem: (key) => chunkYOAEDKQH_js.__async(this, null, function* () {
+          const value = yield db.getItem(key);
+          if (value) {
+            return value;
+          }
+          return initialState;
+        }),
+        setItem: (k, v) => chunkYOAEDKQH_js.__async(this, null, function* () {
+          if (v === EMPTY)
+            return;
+          yield db.setItem(k, v);
+        }),
+        removeItem: db.removeItem
+      };
+    }
+    return noopStorage;
+  }
+  const listsStorageAtom = utils.atomWithStorage("lists", EMPTY, IndexedDBStorage("lists"));
+  const defaultStateAtom = jotai.atom(
+    (get) => {
+      const value = get(utils.loadable(listsStorageAtom));
+      if (value.state === "hasData" && value.data !== EMPTY) {
+        return value.data;
+      }
+      return initialState;
+    },
+    (get, set, action) => chunkYOAEDKQH_js.__async(void 0, null, function* () {
+      set(listsStorageAtom, reducer(yield get(defaultStateAtom), action));
+    })
+  );
+  const isReadyAtom = utils.loadable(listsStorageAtom);
+  const tokenAtom = utils.atomFamily(
+    (key) => jotai.atom((get) => findTokenByAddress(get(defaultStateAtom), key.chainId, key.address))
+  );
+  const tokenBySymbolAtom = utils.atomFamily(
+    (key) => jotai.atom((get) => findTokenBySymbol(get(defaultStateAtom), key.chainId, key.symbol))
+  );
+  const fetchListAtom = jotai.atom(null, (get, set, url) => chunkYOAEDKQH_js.__async(void 0, null, function* () {
+    const state = get(defaultStateAtom);
+    const listState = state.byUrl[url];
+    if ((listState == null ? void 0 : listState.current) || (listState == null ? void 0 : listState.loadingRequestId)) {
+      return;
+    }
+    const requestId = toolkit.nanoid();
+    set(defaultStateAtom, fetchTokenList.pending({ url, requestId }));
+    try {
+      const tokenList = yield getTokenList(url);
+      set(defaultStateAtom, fetchTokenList.fulfilled({ url, tokenList, requestId }));
+    } catch (error) {
+      set(defaultStateAtom, fetchTokenList.rejected({ url, requestId, errorMessage: error.message }));
+    }
+  }));
+  function useListState() {
+    return jotai.useAtom(defaultStateAtom);
+  }
+  function useListStateReady() {
+    const value = jotai.useAtomValue(isReadyAtom);
+    return value.state === "hasData" && value.data !== EMPTY;
+  }
+  return {
+    listsAtom: defaultStateAtom,
+    tokenAtom,
+    tokenBySymbolAtom,
+    fetchListAtom,
+    useListStateReady,
+    useListState
+  };
+};
 var NEW_LIST_STATE = {
   error: null,
   current: null,
@@ -49,11 +601,11 @@ var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIV
     const current = (_a = state.byUrl[url]) == null ? void 0 : _a.current;
     const loadingRequestId = (_b = state.byUrl[url]) == null ? void 0 : _b.loadingRequestId;
     if (current) {
-      const upgradeType = chunkOGWZ2K32_js.getVersionUpgrade(current.version, tokenList.version);
+      const upgradeType = chunkYOAEDKQH_js.getVersionUpgrade(current.version, tokenList.version);
       if (upgradeType === 0 /* NONE */)
         return;
       if (loadingRequestId === null || loadingRequestId === requestId) {
-        state.byUrl[url] = chunk4TPCCB4K_js.__spreadProps(chunk4TPCCB4K_js.__spreadValues({}, state.byUrl[url]), {
+        state.byUrl[url] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
           loadingRequestId: null,
           error: null,
           current,
@@ -64,7 +616,7 @@ var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIV
       if (DEFAULT_ACTIVE_LIST_URLS.includes(url) && state.activeListUrls && !state.activeListUrls.includes(url)) {
         state.activeListUrls.push(url);
       }
-      state.byUrl[url] = chunk4TPCCB4K_js.__spreadProps(chunk4TPCCB4K_js.__spreadValues({}, state.byUrl[url]), {
+      state.byUrl[url] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
         loadingRequestId: null,
         error: null,
         current: tokenList,
@@ -76,7 +628,7 @@ var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIV
     if (((_a = state.byUrl[url]) == null ? void 0 : _a.loadingRequestId) !== requestId) {
       return;
     }
-    state.byUrl[url] = chunk4TPCCB4K_js.__spreadProps(chunk4TPCCB4K_js.__spreadValues({}, state.byUrl[url]), {
+    state.byUrl[url] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
       loadingRequestId: null,
       error: errorMessage,
       current: null,
@@ -112,7 +664,7 @@ var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIV
     if (!((_a = state.byUrl[url]) == null ? void 0 : _a.pendingUpdate)) {
       throw new Error("accept list update called without pending update");
     }
-    state.byUrl[url] = chunk4TPCCB4K_js.__spreadProps(chunk4TPCCB4K_js.__spreadValues({}, state.byUrl[url]), {
+    state.byUrl[url] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
       pendingUpdate: null,
       current: state.byUrl[url].pendingUpdate
     });
@@ -149,75 +701,17 @@ var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIV
     }
   })
 );
-function noop() {
-}
-var noopStorage = {
-  getItem: () => Promise.resolve(noop()),
-  setItem: () => Promise.resolve(noop()),
-  removeItem: () => Promise.resolve(noop())
-};
-var EMPTY = Symbol();
-var createListsAtom = (storeName, reducer, initialState) => {
-  function IndexedDBStorage(dbName) {
-    if (typeof window !== "undefined") {
-      const db = localForage__default.default.createInstance({
-        name: dbName,
-        storeName
-      });
-      return {
-        getItem: (key) => chunk4TPCCB4K_js.__async(this, null, function* () {
-          const value = yield db.getItem(key);
-          if (value) {
-            return value;
-          }
-          return initialState;
-        }),
-        setItem: (k, v) => chunk4TPCCB4K_js.__async(this, null, function* () {
-          if (v === EMPTY)
-            return;
-          yield db.setItem(k, v);
-        }),
-        removeItem: db.removeItem
-      };
-    }
-    return noopStorage;
-  }
-  const listsStorageAtom = utils.atomWithStorage("lists", EMPTY, IndexedDBStorage("lists"));
-  const defaultStateAtom = jotai.atom(
-    (get) => {
-      const value = get(utils.loadable(listsStorageAtom));
-      if (value.state === "hasData" && value.data !== EMPTY) {
-        return value.data;
-      }
-      return initialState;
-    },
-    (get, set, action) => chunk4TPCCB4K_js.__async(void 0, null, function* () {
-      set(listsStorageAtom, reducer(yield get(defaultStateAtom), action));
-    })
-  );
-  const isReadyAtom = utils.loadable(listsStorageAtom);
-  function useListState() {
-    return jotai.useAtom(defaultStateAtom);
-  }
-  function useListStateReady() {
-    const value = jotai.useAtomValue(isReadyAtom);
-    return value.state === "hasData" && value.data !== EMPTY;
-  }
-  return {
-    listsAtom: defaultStateAtom,
-    useListStateReady,
-    useListState
-  };
-};
 function useFetchListCallback(dispatch) {
   return react.useCallback(
-    (listUrl, sendDispatch = true) => chunk4TPCCB4K_js.__async(this, null, function* () {
+    (listUrl, sendDispatch = true) => chunkYOAEDKQH_js.__async(this, null, function* () {
       const requestId = toolkit.nanoid();
       if (sendDispatch) {
         dispatch(fetchTokenList.pending({ requestId, url: listUrl }));
       }
-      const getTokenList = (yield import('./getTokenList-A3DXVBCD.js')).default;
       return getTokenList(listUrl).then((tokenList) => {
+        if (!tokenList) {
+          throw new Error("Token list not found");
+        }
         if (sendDispatch) {
           dispatch(fetchTokenList.fulfilled({ url: listUrl, tokenList, requestId }));
         }
@@ -243,6 +737,9 @@ exports.createTokenListReducer = createTokenListReducer;
 exports.disableList = disableList;
 exports.enableList = enableList;
 exports.fetchTokenList = fetchTokenList;
+exports.findTokenByAddress = findTokenByAddress;
+exports.findTokenBySymbol = findTokenBySymbol;
+exports.getTokenList = getTokenList;
 exports.rejectVersionUpdate = rejectVersionUpdate;
 exports.removeList = removeList;
 exports.updateListVersion = updateListVersion;