@pancakeswap/token-lists 0.0.17 → 0.1.1

package/dist/react.js

@@ -1,15 +1,17 @@
 'use strict';
 
-var chunkYOAEDKQH_js = require('./chunk-YOAEDKQH.js');
+var chunkY2NTTLTJ_js = require('./chunk-Y2NTTLTJ.js');
 var toolkit = require('@reduxjs/toolkit');
 var jotai = require('jotai');
 var utils = require('jotai/utils');
 var localForage = require('localforage');
+var debounce = require('lodash/debounce');
 var react = require('react');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var localForage__default = /*#__PURE__*/_interopDefault(localForage);
+var debounce__default = /*#__PURE__*/_interopDefault(debounce);
 
 var fetchTokenList = {
   pending: toolkit.createAction("lists/fetchTokenList/pending"),
@@ -23,6 +25,11 @@ var disableList = toolkit.createAction("lists/disableList");
 var acceptListUpdate = toolkit.createAction("lists/acceptListUpdate");
 var rejectVersionUpdate = toolkit.createAction("lists/rejectVersionUpdate");
 var updateListVersion = toolkit.createAction("lists/updateListVersion");
+var batchFetchTokenListPending = toolkit.createAction(
+  "lists/batchFetchTokenList/pending"
+);
+var batchFetchTokenListFulfilled = toolkit.createAction("lists/batchFetchTokenList/fulfilled");
+var batchFetchTokenListRejected = toolkit.createAction("lists/batchFetchTokenList/rejected");
 
 // ../utils/uriToHttp.ts
 function uriToHttp(uri) {
@@ -58,7 +65,7 @@ var pancakeswap_default = {
         {
           major: 1,
           minor: 0,
-          patch: 0
+          patch: 1
         }
       ],
       additionalProperties: false,
@@ -243,17 +250,17 @@ var pancakeswap_default = {
           type: "string",
           description: "The name of the token",
           minLength: 1,
-          maxLength: 40,
-          pattern: "^[ \\w.'+\\-%/\xC0-\xD6\xD8-\xF6\xF8-\xFF:&\\[\\]\\(\\)]+$",
-          examples: ["USD Coin"]
+          maxLength: 60,
+          pattern: "^[ \\w.'+\\-%/,\\$\xC0-\xD6\xD8-\xF6\xF8-\xFF:&\\[\\]\\(\\)\\u4e00-\\u9fa5]+$",
+          examples: ["USD Coin", "\u5E01\u5B89\u5E01"]
         },
         symbol: {
           type: "string",
           description: "The symbol for the token; must be alphanumeric",
-          pattern: "^[a-zA-Z0-9+\\-%/$.\\s]+$",
+          pattern: "^[a-zA-Z0-9+\\-%/$.\\s_\\u4e00-\\u9fa5]+$",
           minLength: 1,
           maxLength: 20,
-          examples: ["USDC"]
+          examples: ["USDC", "\u5E01\u5B89"]
         },
         logoURI: {
           type: "string",
@@ -303,14 +310,14 @@ var pancakeswap_default = {
           type: "string",
           description: "The name of the token",
           minLength: 1,
-          maxLength: 40,
-          pattern: "^[ \\w.'+\\-%/\xC0-\xD6\xD8-\xF6\xF8-\xFF:&\\[\\]\\(\\)]+$",
+          maxLength: 60,
+          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+\\-%/$.]+$",
+          pattern: "^[a-zA-Z0-9+\\-%/$._]+$",
           minLength: 1,
           maxLength: 20,
           examples: ["USDC"]
@@ -403,6 +410,15 @@ var pancakeswap_default = {
       description: "A URI for the logo of the token list; prefer SVG or PNG of size 256x256",
       format: "uri",
       examples: ["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]
+    },
+    extensions: {
+      type: "object",
+      description: "An object containing arbitrary or vendor-specific token list metadata",
+      propertyNames: {
+        $ref: "#/definitions/ExtensionIdentifier"
+      },
+      additionalProperties: true,
+      maxProperties: 10
     }
   },
   if: {
@@ -440,7 +456,7 @@ var pancakeswap_default = {
 
 // react/getTokenList.ts
 function getTokenList(listUrl) {
-  return chunkYOAEDKQH_js.__async(this, null, function* () {
+  return chunkY2NTTLTJ_js.__async(this, null, function* () {
     const urls = uriToHttp(listUrl);
     const { default: Ajv } = yield import('ajv');
     const validator = new Ajv({ allErrors: true }).compile(pancakeswap_default);
@@ -448,16 +464,15 @@ function getTokenList(listUrl) {
       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] })));
+          json.tokens = json.tokens.filter((token) => validator(chunkY2NTTLTJ_js.__spreadProps(chunkY2NTTLTJ_js.__spreadValues({}, json), { tokens: [token] })));
           if (!validator(json)) {
-            const errors = validator.errors;
+            const { errors } = validator;
             throw new Error(`Validation failed after filtering: ${JSON.stringify(errors)}`);
           }
-          console.warn(`Pre-filter validation errors: ${JSON.stringify(preFilterErrors)}`);
         }
         return json;
       } catch (error) {
+        console.warn(`Failed to download or validate list from ${url}:`, error);
         return void 0;
       }
     }
@@ -465,7 +480,48 @@ function getTokenList(listUrl) {
   });
 }
 function fetchJson(url) {
-  return chunkYOAEDKQH_js.__async(this, null, function* () {
+  return chunkY2NTTLTJ_js.__async(this, null, function* () {
+    const res = yield fetch(url);
+    if (!res.ok)
+      throw new Error(`Failed to fetch: ${url}`);
+    return res.json();
+  });
+}
+function normalizeTokenAddress(address) {
+  return address.startsWith("0x") ? address.toLowerCase() : address;
+}
+function getGeoBlockTokenKey(token) {
+  return `${token.chainId}:${normalizeTokenAddress(token.address)}`;
+}
+function normalizeTokenKey(key) {
+  const separatorIndex = key.indexOf(":");
+  if (separatorIndex < 0)
+    return key;
+  const chainId = key.slice(0, separatorIndex);
+  const address = key.slice(separatorIndex + 1);
+  return `${chainId}:${normalizeTokenAddress(address)}`;
+}
+function getGeoBlockedTokenKeys(geoBlockList, countryCode) {
+  const blockedTokenKeys = /* @__PURE__ */ new Set();
+  if (!countryCode || !(geoBlockList == null ? void 0 : geoBlockList.rules) || !geoBlockList.tokens) {
+    return blockedTokenKeys;
+  }
+  const country = countryCode.toUpperCase();
+  const blockedRuleIds = new Set(
+    Object.entries(geoBlockList.rules).filter(([, countries]) => countries.includes(country)).map(([ruleId]) => ruleId)
+  );
+  Object.entries(geoBlockList.tokens).forEach(([tokenKey, ruleIds]) => {
+    if (ruleIds.some((ruleId) => blockedRuleIds.has(ruleId))) {
+      blockedTokenKeys.add(normalizeTokenKey(tokenKey));
+    }
+  });
+  return blockedTokenKeys;
+}
+function isGeoBlockedToken(token, geoBlockList, countryCode) {
+  return getGeoBlockedTokenKeys(geoBlockList, countryCode).has(getGeoBlockTokenKey(token));
+}
+function fetchJson2(url) {
+  return chunkY2NTTLTJ_js.__async(this, null, function* () {
     const res = yield fetch(url);
     if (!res.ok)
       throw new Error(`Failed to fetch: ${url}`);
@@ -502,82 +558,278 @@ function findTokenBySymbol(state, chainId, symbol) {
   }
   return void 0;
 }
-var createListsAtom = (storeName, reducer, initialState) => {
+var createListsAtom = (storeName, reducer, initialState, options = {}) => {
   function IndexedDBStorage(dbName) {
     if (typeof window !== "undefined") {
       const db = localForage__default.default.createInstance({
         name: dbName,
         storeName
       });
+      const mem = /* @__PURE__ */ new Map();
+      const debouncedSetItem = debounce__default.default((k, v) => chunkY2NTTLTJ_js.__async(this, null, function* () {
+        db.setItem(k, v);
+      }), 300);
       return {
-        getItem: (key) => chunkYOAEDKQH_js.__async(this, null, function* () {
+        getItem: (key) => chunkY2NTTLTJ_js.__async(this, null, function* () {
+          if (mem.has(key)) {
+            return mem.get(key);
+          }
           const value = yield db.getItem(key);
           if (value) {
             return value;
           }
-          return initialState;
+          return void 0;
         }),
-        setItem: (k, v) => chunkYOAEDKQH_js.__async(this, null, function* () {
+        setItem: (k, v) => chunkY2NTTLTJ_js.__async(this, null, function* () {
           if (v === EMPTY)
             return;
-          yield db.setItem(k, v);
+          mem.set(k, v);
+          debouncedSetItem(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 tokenListsStorageAtom = utils.atomWithStorage(
+    "tokenLists",
+    EMPTY,
+    IndexedDBStorage("tokenLists"),
+    { getOnInit: true }
   );
-  const isReadyAtom = utils.loadable(listsStorageAtom);
+  const geoBlockListStorageAtom = utils.atomWithStorage(
+    "geoBlockList",
+    EMPTY,
+    IndexedDBStorage("geoBlockList")
+  );
+  const geoBlockListAtom = jotai.atom((get) => {
+    const value = get(utils.loadable(geoBlockListStorageAtom));
+    if (value.state === "hasData" && value.data && value.data !== EMPTY) {
+      return value.data;
+    }
+    return void 0;
+  });
+  const fetchGeoBlockListAtom = jotai.atom(null, (_get, set) => chunkY2NTTLTJ_js.__async(void 0, null, function* () {
+    if (!options.geoBlockListUrl) {
+      return;
+    }
+    try {
+      set(geoBlockListStorageAtom, yield fetchJson2(options.geoBlockListUrl));
+    } catch (error) {
+      console.warn(`Failed to download geo block list from ${options.geoBlockListUrl}:`, error);
+    }
+  }));
+  const memoryStateAtom = jotai.atom(initialState);
+  const mergeStoredData = (baseState, storedData) => {
+    var _a;
+    const storedTokenLists = (_a = storedData.byUrl) != null ? _a : storedData;
+    const storedActiveListUrls = Array.isArray(storedData.activeListUrls) ? storedData.activeListUrls : void 0;
+    const mergedState = chunkY2NTTLTJ_js.__spreadValues({}, baseState);
+    const updatedByUrl = chunkY2NTTLTJ_js.__spreadValues({}, mergedState.byUrl);
+    Object.keys(storedTokenLists).forEach((url) => {
+      if (storedTokenLists[url]) {
+        updatedByUrl[url] = chunkY2NTTLTJ_js.__spreadProps(chunkY2NTTLTJ_js.__spreadValues({}, updatedByUrl[url]), {
+          current: storedTokenLists[url]
+          // Keep existing memory state for loading, error, pendingUpdate
+        });
+      }
+    });
+    mergedState.byUrl = updatedByUrl;
+    if (storedActiveListUrls) {
+      mergedState.activeListUrls = storedActiveListUrls;
+    }
+    return mergedState;
+  };
+  const listStateAtom = jotai.atom((get) => {
+    const memoryState = get(memoryStateAtom);
+    const value = get(utils.loadable(tokenListsStorageAtom));
+    if (value.state === "hasData" && value.data && value.data !== EMPTY) {
+      return mergeStoredData(memoryState, value.data);
+    }
+    return memoryState;
+  });
+  let hasHydratedActiveListUrls = false;
+  const updateListStateAtom = jotai.atom(null, (get, set, action) => chunkY2NTTLTJ_js.__async(void 0, null, function* () {
+    const baseState = get(memoryStateAtom);
+    if (!hasHydratedActiveListUrls) {
+      const storageValue = get(utils.loadable(tokenListsStorageAtom));
+      if (storageValue.state !== "hasData") {
+        const optimisticState = reducer(baseState, action);
+        set(memoryStateAtom, chunkY2NTTLTJ_js.__spreadValues({}, optimisticState));
+        return;
+      }
+      if (storageValue.data && storageValue.data !== EMPTY) {
+        set(memoryStateAtom, mergeStoredData(baseState, storageValue.data));
+      }
+      hasHydratedActiveListUrls = true;
+    }
+    const currentState = get(memoryStateAtom);
+    const newState = reducer(currentState, action);
+    set(memoryStateAtom, chunkY2NTTLTJ_js.__spreadValues({}, newState));
+    const tokenListsToStore = {};
+    Object.keys(newState.byUrl).forEach((url) => {
+      var _a;
+      if ((_a = newState.byUrl[url]) == null ? void 0 : _a.current) {
+        tokenListsToStore[url] = newState.byUrl[url].current;
+      }
+    });
+    set(tokenListsStorageAtom, { byUrl: tokenListsToStore, activeListUrls: newState.activeListUrls });
+  }));
+  const isReadyAtom = utils.loadable(tokenListsStorageAtom);
   const tokenAtom = utils.atomFamily(
-    (key) => jotai.atom((get) => findTokenByAddress(get(defaultStateAtom), key.chainId, key.address))
+    (key) => jotai.atom((get) => findTokenByAddress(get(listStateAtom), key.chainId, key.address))
   );
   const tokenBySymbolAtom = utils.atomFamily(
-    (key) => jotai.atom((get) => findTokenBySymbol(get(defaultStateAtom), key.chainId, key.symbol))
+    (key) => jotai.atom((get) => findTokenBySymbol(get(listStateAtom), key.chainId, key.symbol))
   );
-  const fetchListAtom = jotai.atom(null, (get, set, url) => chunkYOAEDKQH_js.__async(void 0, null, function* () {
-    const state = get(defaultStateAtom);
+  const fetchListAtom = jotai.atom(null, (get, set, url) => chunkY2NTTLTJ_js.__async(void 0, null, function* () {
+    const state = get(listStateAtom);
     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 }));
+    set(updateListStateAtom, fetchTokenList.pending({ url, requestId }));
     try {
       const tokenList = yield getTokenList(url);
-      set(defaultStateAtom, fetchTokenList.fulfilled({ url, tokenList, requestId }));
+      set(updateListStateAtom, fetchTokenList.fulfilled({ url, tokenList, requestId }));
     } catch (error) {
-      set(defaultStateAtom, fetchTokenList.rejected({ url, requestId, errorMessage: error.message }));
+      set(updateListStateAtom, fetchTokenList.rejected({ url, requestId, errorMessage: error.message }));
+    }
+  }));
+  const fetchListBatchAtom = jotai.atom(null, (get, set, urls) => chunkY2NTTLTJ_js.__async(void 0, null, function* () {
+    const state = get(listStateAtom);
+    const urlsToFetch = urls.filter((url) => {
+      const listState = state.byUrl[url];
+      return !(listState == null ? void 0 : listState.current) && !(listState == null ? void 0 : listState.loadingRequestId);
+    });
+    if (urlsToFetch.length === 0) {
+      return;
+    }
+    const requestId = toolkit.nanoid();
+    set(updateListStateAtom, batchFetchTokenListPending({ urls: urlsToFetch, requestId }));
+    try {
+      const results = yield Promise.allSettled(
+        urlsToFetch.map((url) => chunkY2NTTLTJ_js.__async(void 0, null, function* () {
+          const tokenList = yield getTokenList(url);
+          return { url, tokenList, requestId };
+        }))
+      );
+      const fulfilled = [];
+      const rejected = [];
+      results.forEach((result, index) => {
+        var _a;
+        const url = urlsToFetch[index];
+        if (result.status === "fulfilled") {
+          fulfilled.push(result.value);
+        } else {
+          rejected.push({
+            url,
+            errorMessage: ((_a = result.reason) == null ? void 0 : _a.message) || "Unknown error",
+            requestId
+          });
+        }
+      });
+      if (fulfilled.length > 0) {
+        set(updateListStateAtom, batchFetchTokenListFulfilled({ results: fulfilled }));
+      }
+      if (rejected.length > 0) {
+        set(updateListStateAtom, batchFetchTokenListRejected({ errors: rejected }));
+      }
+    } catch (error) {
+      const errors = urlsToFetch.map((url) => ({
+        url,
+        errorMessage: error.message,
+        requestId
+      }));
+      set(updateListStateAtom, batchFetchTokenListRejected({ errors }));
     }
   }));
   function useListState() {
-    return jotai.useAtom(defaultStateAtom);
+    return jotai.useAtom(listStateAtom);
   }
   function useListStateReady() {
     const value = jotai.useAtomValue(isReadyAtom);
-    return value.state === "hasData" && value.data !== EMPTY;
+    return value.state === "hasData";
   }
   return {
-    listsAtom: defaultStateAtom,
+    listsAtom: listStateAtom,
+    updateListStateAtom,
     tokenAtom,
     tokenBySymbolAtom,
+    geoBlockListAtom,
+    fetchGeoBlockListAtom,
     fetchListAtom,
+    fetchListBatchAtom,
     useListStateReady,
     useListState
   };
 };
+
+// react/reducerHelpers.ts
+var setPendingTokenList = (state, url, requestId) => {
+  var _a, _b, _c, _d;
+  const current = (_b = (_a = state.byUrl[url]) == null ? void 0 : _a.current) != null ? _b : null;
+  const pendingUpdate = (_d = (_c = state.byUrl[url]) == null ? void 0 : _c.pendingUpdate) != null ? _d : null;
+  state.byUrl[url] = {
+    current,
+    pendingUpdate,
+    loadingRequestId: requestId,
+    error: null
+  };
+};
+var setFulfilledTokenList = (state, url, tokenList, requestId, DEFAULT_ACTIVE_LIST_URLS) => {
+  var _a, _b;
+  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 = chunkY2NTTLTJ_js.getVersionUpgrade(current.version, tokenList.version);
+    if (upgradeType === 0 /* NONE */)
+      return false;
+    if (loadingRequestId === null || loadingRequestId === requestId) {
+      state.byUrl[url] = chunkY2NTTLTJ_js.__spreadProps(chunkY2NTTLTJ_js.__spreadValues({}, state.byUrl[url]), {
+        loadingRequestId: null,
+        error: null,
+        current,
+        pendingUpdate: tokenList
+      });
+    }
+    return false;
+  }
+  if (DEFAULT_ACTIVE_LIST_URLS.includes(url) && state.activeListUrls && !state.activeListUrls.includes(url)) {
+    state.activeListUrls.push(url);
+  }
+  state.byUrl[url] = chunkY2NTTLTJ_js.__spreadProps(chunkY2NTTLTJ_js.__spreadValues({}, state.byUrl[url]), {
+    loadingRequestId: null,
+    error: null,
+    current: tokenList,
+    pendingUpdate: null
+  });
+  return true;
+};
+var setRejectedTokenList = (state, url, requestId, errorMessage) => {
+  var _a;
+  if (((_a = state.byUrl[url]) == null ? void 0 : _a.loadingRequestId) !== requestId) {
+    return;
+  }
+  state.byUrl[url] = chunkY2NTTLTJ_js.__spreadProps(chunkY2NTTLTJ_js.__spreadValues({}, state.byUrl[url]), {
+    loadingRequestId: null,
+    error: errorMessage,
+    current: null,
+    pendingUpdate: null
+  });
+};
+var batchActivateUrls = (state, urls) => {
+  if (urls.length > 0 && state.activeListUrls) {
+    urls.forEach((url) => {
+      if (!state.activeListUrls.includes(url)) {
+        state.activeListUrls.push(url);
+      }
+    });
+  }
+};
+
+// react/reducer.ts
 var NEW_LIST_STATE = {
   error: null,
   current: null,
@@ -587,53 +839,11 @@ var NEW_LIST_STATE = {
 var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIVE_LIST_URLS) => toolkit.createReducer(
   initialState,
   (builder) => builder.addCase(fetchTokenList.pending, (state, { payload: { requestId, url } }) => {
-    var _a, _b, _c, _d;
-    const current = (_b = (_a = state.byUrl[url]) == null ? void 0 : _a.current) != null ? _b : null;
-    const pendingUpdate = (_d = (_c = state.byUrl[url]) == null ? void 0 : _c.pendingUpdate) != null ? _d : null;
-    state.byUrl[url] = {
-      current,
-      pendingUpdate,
-      loadingRequestId: requestId,
-      error: null
-    };
+    setPendingTokenList(state, url, requestId);
   }).addCase(fetchTokenList.fulfilled, (state, { payload: { requestId, tokenList, url } }) => {
-    var _a, _b;
-    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 = chunkYOAEDKQH_js.getVersionUpgrade(current.version, tokenList.version);
-      if (upgradeType === 0 /* NONE */)
-        return;
-      if (loadingRequestId === null || loadingRequestId === requestId) {
-        state.byUrl[url] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
-          loadingRequestId: null,
-          error: null,
-          current,
-          pendingUpdate: tokenList
-        });
-      }
-    } else {
-      if (DEFAULT_ACTIVE_LIST_URLS.includes(url) && state.activeListUrls && !state.activeListUrls.includes(url)) {
-        state.activeListUrls.push(url);
-      }
-      state.byUrl[url] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
-        loadingRequestId: null,
-        error: null,
-        current: tokenList,
-        pendingUpdate: null
-      });
-    }
+    setFulfilledTokenList(state, url, tokenList, requestId, DEFAULT_ACTIVE_LIST_URLS);
   }).addCase(fetchTokenList.rejected, (state, { payload: { url, requestId, errorMessage } }) => {
-    var _a;
-    if (((_a = state.byUrl[url]) == null ? void 0 : _a.loadingRequestId) !== requestId) {
-      return;
-    }
-    state.byUrl[url] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
-      loadingRequestId: null,
-      error: errorMessage,
-      current: null,
-      pendingUpdate: null
-    });
+    setRejectedTokenList(state, url, requestId, errorMessage);
   }).addCase(addList, (state, { payload: url }) => {
     if (!state.byUrl[url]) {
       state.byUrl[url] = NEW_LIST_STATE;
@@ -664,7 +874,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] = chunkYOAEDKQH_js.__spreadProps(chunkYOAEDKQH_js.__spreadValues({}, state.byUrl[url]), {
+    state.byUrl[url] = chunkY2NTTLTJ_js.__spreadProps(chunkY2NTTLTJ_js.__spreadValues({}, state.byUrl[url]), {
       pendingUpdate: null,
       current: state.byUrl[url].pendingUpdate
     });
@@ -699,11 +909,28 @@ var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIV
         return true;
       });
     }
+  }).addCase(batchFetchTokenListPending, (state, { payload: { urls, requestId } }) => {
+    urls.forEach((url) => {
+      setPendingTokenList(state, url, requestId);
+    });
+  }).addCase(batchFetchTokenListFulfilled, (state, { payload: { results } }) => {
+    const urlsToActivate = [];
+    results.forEach(({ url, tokenList, requestId }) => {
+      const isNewList = setFulfilledTokenList(state, url, tokenList, requestId, DEFAULT_ACTIVE_LIST_URLS);
+      if (isNewList && DEFAULT_ACTIVE_LIST_URLS.includes(url)) {
+        urlsToActivate.push(url);
+      }
+    });
+    batchActivateUrls(state, urlsToActivate);
+  }).addCase(batchFetchTokenListRejected, (state, { payload: { errors } }) => {
+    errors.forEach(({ url, requestId, errorMessage }) => {
+      setRejectedTokenList(state, url, requestId, errorMessage);
+    });
   })
 );
 function useFetchListCallback(dispatch) {
   return react.useCallback(
-    (listUrl, sendDispatch = true) => chunkYOAEDKQH_js.__async(this, null, function* () {
+    (listUrl, sendDispatch = true) => chunkY2NTTLTJ_js.__async(this, null, function* () {
       const requestId = toolkit.nanoid();
       if (sendDispatch) {
         dispatch(fetchTokenList.pending({ requestId, url: listUrl }));
@@ -717,7 +944,7 @@ function useFetchListCallback(dispatch) {
         }
         return tokenList;
       }).catch((error) => {
-        console.error(`Failed to get list at url ${listUrl}`, error);
+        console.warn(`Failed to get list at url ${listUrl}`, error);
         if (sendDispatch) {
           dispatch(fetchTokenList.rejected({ url: listUrl, requestId, errorMessage: error.message }));
         }
@@ -732,6 +959,9 @@ var useFetchListCallback_default = useFetchListCallback;
 exports.NEW_LIST_STATE = NEW_LIST_STATE;
 exports.acceptListUpdate = acceptListUpdate;
 exports.addList = addList;
+exports.batchFetchTokenListFulfilled = batchFetchTokenListFulfilled;
+exports.batchFetchTokenListPending = batchFetchTokenListPending;
+exports.batchFetchTokenListRejected = batchFetchTokenListRejected;
 exports.createListsAtom = createListsAtom;
 exports.createTokenListReducer = createTokenListReducer;
 exports.disableList = disableList;
@@ -739,7 +969,10 @@ exports.enableList = enableList;
 exports.fetchTokenList = fetchTokenList;
 exports.findTokenByAddress = findTokenByAddress;
 exports.findTokenBySymbol = findTokenBySymbol;
+exports.getGeoBlockTokenKey = getGeoBlockTokenKey;
+exports.getGeoBlockedTokenKeys = getGeoBlockedTokenKeys;
 exports.getTokenList = getTokenList;
+exports.isGeoBlockedToken = isGeoBlockedToken;
 exports.rejectVersionUpdate = rejectVersionUpdate;
 exports.removeList = removeList;
 exports.updateListVersion = updateListVersion;