@pancakeswap/token-lists 0.0.17 → 0.1.1

package/dist/react.mjs

@@ -1,8 +1,9 @@
-import { __async, __spreadProps, __spreadValues, getVersionUpgrade } from './chunk-DC45HQOL.mjs';
+import { __async, __spreadProps, __spreadValues, getVersionUpgrade } from './chunk-UUVLERWJ.mjs';
 import { createAction, nanoid, createReducer } from '@reduxjs/toolkit';
 import { atom, useAtom, useAtomValue } from 'jotai';
 import { atomWithStorage, loadable, atomFamily } from 'jotai/utils';
 import localForage from 'localforage';
+import debounce from 'lodash/debounce';
 import { useCallback } from 'react';
 
 var fetchTokenList = {
@@ -17,6 +18,11 @@ var disableList = createAction("lists/disableList");
 var acceptListUpdate = createAction("lists/acceptListUpdate");
 var rejectVersionUpdate = createAction("lists/rejectVersionUpdate");
 var updateListVersion = createAction("lists/updateListVersion");
+var batchFetchTokenListPending = createAction(
+  "lists/batchFetchTokenList/pending"
+);
+var batchFetchTokenListFulfilled = createAction("lists/batchFetchTokenList/fulfilled");
+var batchFetchTokenListRejected = createAction("lists/batchFetchTokenList/rejected");
 
 // ../utils/uriToHttp.ts
 function uriToHttp(uri) {
@@ -52,7 +58,7 @@ var pancakeswap_default = {
         {
           major: 1,
           minor: 0,
-          patch: 0
+          patch: 1
         }
       ],
       additionalProperties: false,
@@ -237,17 +243,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",
@@ -297,14 +303,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"]
@@ -397,6 +403,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: {
@@ -442,16 +457,15 @@ function getTokenList(listUrl) {
       try {
         const json = yield fetchJson(url);
         if (!validator(json)) {
-          const preFilterErrors = validator.errors;
           json.tokens = json.tokens.filter((token) => validator(__spreadProps(__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;
       }
     }
@@ -466,6 +480,47 @@ function fetchJson(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 __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 = {
@@ -496,82 +551,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.createInstance({
         name: dbName,
         storeName
       });
+      const mem = /* @__PURE__ */ new Map();
+      const debouncedSetItem = debounce((k, v) => __async(this, null, function* () {
+        db.setItem(k, v);
+      }), 300);
       return {
         getItem: (key) => __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) => __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 = atomWithStorage("lists", EMPTY, IndexedDBStorage("lists"));
-  const defaultStateAtom = atom(
-    (get) => {
-      const value = get(loadable(listsStorageAtom));
-      if (value.state === "hasData" && value.data !== EMPTY) {
-        return value.data;
-      }
-      return initialState;
-    },
-    (get, set, action) => __async(void 0, null, function* () {
-      set(listsStorageAtom, reducer(yield get(defaultStateAtom), action));
-    })
+  const tokenListsStorageAtom = atomWithStorage(
+    "tokenLists",
+    EMPTY,
+    IndexedDBStorage("tokenLists"),
+    { getOnInit: true }
   );
-  const isReadyAtom = loadable(listsStorageAtom);
+  const geoBlockListStorageAtom = atomWithStorage(
+    "geoBlockList",
+    EMPTY,
+    IndexedDBStorage("geoBlockList")
+  );
+  const geoBlockListAtom = atom((get) => {
+    const value = get(loadable(geoBlockListStorageAtom));
+    if (value.state === "hasData" && value.data && value.data !== EMPTY) {
+      return value.data;
+    }
+    return void 0;
+  });
+  const fetchGeoBlockListAtom = atom(null, (_get, set) => __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 = 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 = __spreadValues({}, baseState);
+    const updatedByUrl = __spreadValues({}, mergedState.byUrl);
+    Object.keys(storedTokenLists).forEach((url) => {
+      if (storedTokenLists[url]) {
+        updatedByUrl[url] = __spreadProps(__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 = atom((get) => {
+    const memoryState = get(memoryStateAtom);
+    const value = get(loadable(tokenListsStorageAtom));
+    if (value.state === "hasData" && value.data && value.data !== EMPTY) {
+      return mergeStoredData(memoryState, value.data);
+    }
+    return memoryState;
+  });
+  let hasHydratedActiveListUrls = false;
+  const updateListStateAtom = atom(null, (get, set, action) => __async(void 0, null, function* () {
+    const baseState = get(memoryStateAtom);
+    if (!hasHydratedActiveListUrls) {
+      const storageValue = get(loadable(tokenListsStorageAtom));
+      if (storageValue.state !== "hasData") {
+        const optimisticState = reducer(baseState, action);
+        set(memoryStateAtom, __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, __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 = loadable(tokenListsStorageAtom);
   const tokenAtom = atomFamily(
-    (key) => atom((get) => findTokenByAddress(get(defaultStateAtom), key.chainId, key.address))
+    (key) => atom((get) => findTokenByAddress(get(listStateAtom), key.chainId, key.address))
   );
   const tokenBySymbolAtom = atomFamily(
-    (key) => atom((get) => findTokenBySymbol(get(defaultStateAtom), key.chainId, key.symbol))
+    (key) => atom((get) => findTokenBySymbol(get(listStateAtom), key.chainId, key.symbol))
   );
   const fetchListAtom = atom(null, (get, set, url) => __async(void 0, null, function* () {
-    const state = get(defaultStateAtom);
+    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 = 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 = atom(null, (get, set, urls) => __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 = nanoid();
+    set(updateListStateAtom, batchFetchTokenListPending({ urls: urlsToFetch, requestId }));
+    try {
+      const results = yield Promise.allSettled(
+        urlsToFetch.map((url) => __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 useAtom(defaultStateAtom);
+    return useAtom(listStateAtom);
   }
   function useListStateReady() {
     const value = 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 = getVersionUpgrade(current.version, tokenList.version);
+    if (upgradeType === 0 /* NONE */)
+      return false;
+    if (loadingRequestId === null || loadingRequestId === requestId) {
+      state.byUrl[url] = __spreadProps(__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] = __spreadProps(__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] = __spreadProps(__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,
@@ -581,53 +832,11 @@ var NEW_LIST_STATE = {
 var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIVE_LIST_URLS) => 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 = getVersionUpgrade(current.version, tokenList.version);
-      if (upgradeType === 0 /* NONE */)
-        return;
-      if (loadingRequestId === null || loadingRequestId === requestId) {
-        state.byUrl[url] = __spreadProps(__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] = __spreadProps(__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] = __spreadProps(__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;
@@ -693,6 +902,23 @@ 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) {
@@ -711,7 +937,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 }));
         }
@@ -723,4 +949,4 @@ function useFetchListCallback(dispatch) {
 }
 var useFetchListCallback_default = useFetchListCallback;
 
-export { NEW_LIST_STATE, acceptListUpdate, addList, createListsAtom, createTokenListReducer, disableList, enableList, fetchTokenList, findTokenByAddress, findTokenBySymbol, getTokenList, rejectVersionUpdate, removeList, updateListVersion, useFetchListCallback_default as useFetchListCallback };
+export { NEW_LIST_STATE, acceptListUpdate, addList, batchFetchTokenListFulfilled, batchFetchTokenListPending, batchFetchTokenListRejected, createListsAtom, createTokenListReducer, disableList, enableList, fetchTokenList, findTokenByAddress, findTokenBySymbol, getGeoBlockTokenKey, getGeoBlockedTokenKeys, getTokenList, isGeoBlockedToken, rejectVersionUpdate, removeList, updateListVersion, useFetchListCallback_default as useFetchListCallback };

package/dist/{types-92a8b029.d.ts → types-dcc7ec4a.d.ts}

@@ -35,6 +35,7 @@ interface TokenList {
     readonly keywords?: string[];
     readonly tags?: Tags;
     readonly logoURI?: string;
+    readonly extensions?: Record<string, unknown>;
 }
 
 export { TokenInfo as T, Version as V, TokenList as a, Tags as b };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@pancakeswap/token-lists",
-  "version": "0.0.17",
+  "version": "0.1.1",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "dependencies": {
     "ajv": "^6.12.3",
     "lodash": "^4.17.21",
-    "@pancakeswap/swap-sdk-core": "1.5.1"
+    "@pancakeswap/swap-sdk-core": "1.6.1"
   },
   "peerDependencies": {
     "@reduxjs/toolkit": "^1.9.1",
@@ -22,7 +22,8 @@
     "localforage": "^1.10.0",
     "react": "^18.2.0",
     "tsup": "^6.7.0",
-    "@pancakeswap/utils": "8.0.1"
+    "@types/lodash": "^4.14.182",
+    "@pancakeswap/utils": "8.0.3"
   },
   "exports": {
     ".": {

package/react/actions.ts

@@ -23,3 +23,14 @@ export const acceptListUpdate = createAction<string>('lists/acceptListUpdate')
 export const rejectVersionUpdate = createAction<Version>('lists/rejectVersionUpdate')
 
 export const updateListVersion = createAction('lists/updateListVersion')
+
+// Batch actions for reducing update cycles
+export const batchFetchTokenListPending = createAction<{ urls: string[]; requestId: string }>(
+  'lists/batchFetchTokenList/pending',
+)
+export const batchFetchTokenListFulfilled = createAction<{
+  results: Array<{ url: string; tokenList: TokenList; requestId: string }>
+}>('lists/batchFetchTokenList/fulfilled')
+export const batchFetchTokenListRejected = createAction<{
+  errors: Array<{ url: string; errorMessage: string; requestId: string }>
+}>('lists/batchFetchTokenList/rejected')

package/react/geoBlock.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest'
+import { getGeoBlockedTokenKeys, getGeoBlockTokenKey, isGeoBlockedToken } from './lists'
+
+const GEO_BLOCK_LIST = {
+  rules: {
+    A: ['US'],
+    B: ['SG'],
+  },
+  tokens: {
+    '56:0xa0Fe4e0aEca5479705ce996615B2EACB6b6a10Fb': ['A'],
+    '8000001001:Xsc9qvGR1efVDFGLrVsmkzv3qi45LTBjeUKSPmx9qEh': ['A'],
+    '56:0x0000000000000000000000000000000000000001': ['B'],
+  },
+}
+
+describe('geo block helpers', () => {
+  it('normalizes EVM addresses and preserves non-EVM addresses', () => {
+    expect(
+      getGeoBlockTokenKey({
+        chainId: 56,
+        address: '0xa0Fe4e0aEca5479705ce996615B2EACB6b6a10Fb',
+      }),
+    ).toBe('56:0xa0fe4e0aeca5479705ce996615b2eacb6b6a10fb')
+
+    expect(
+      getGeoBlockTokenKey({
+        chainId: 8000001001,
+        address: 'Xsc9qvGR1efVDFGLrVsmkzv3qi45LTBjeUKSPmx9qEh',
+      }),
+    ).toBe('8000001001:Xsc9qvGR1efVDFGLrVsmkzv3qi45LTBjeUKSPmx9qEh')
+  })
+
+  it('returns blocked token keys for the active country', () => {
+    expect([...getGeoBlockedTokenKeys(GEO_BLOCK_LIST, 'US')].sort()).toEqual([
+      '56:0xa0fe4e0aeca5479705ce996615b2eacb6b6a10fb',
+      '8000001001:Xsc9qvGR1efVDFGLrVsmkzv3qi45LTBjeUKSPmx9qEh',
+    ])
+  })
+
+  it('fails open without country or geo block list', () => {
+    expect(getGeoBlockedTokenKeys(GEO_BLOCK_LIST).size).toBe(0)
+    expect(getGeoBlockedTokenKeys(undefined, 'US').size).toBe(0)
+  })
+
+  it('checks whether a token is geo blocked', () => {
+    expect(
+      isGeoBlockedToken(
+        {
+          chainId: 56,
+          address: '0xa0Fe4e0aEca5479705ce996615B2EACB6b6a10Fb',
+        },
+        GEO_BLOCK_LIST,
+        'US',
+      ),
+    ).toBe(true)
+
+    expect(
+      isGeoBlockedToken(
+        {
+          chainId: 56,
+          address: '0xa0Fe4e0aEca5479705ce996615B2EACB6b6a10Fb',
+        },
+        GEO_BLOCK_LIST,
+        'SG',
+      ),
+    ).toBe(false)
+  })
+})