@pancakeswap/token-lists 0.1.0 → 0.1.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pancakeswap/token-lists@0.1.0 build /home/runner/work/pancake-frontend/pancake-frontend/packages/token-lists
+> @pancakeswap/token-lists@0.1.1 build /home/runner/work/pancake-frontend/pancake-frontend/packages/token-lists
 > tsup
 
 CLI Building entry: {"index":"./src/index.ts","react":"./react/index.ts"}
@@ -10,15 +10,15 @@ CLI Target: es6
 ESM Build start
 CJS Build start
 CJS dist/chunk-Y2NTTLTJ.js 2.30 KB
-CJS dist/index.js          2.32 KB
-CJS dist/react.js          29.55 KB
-CJS ⚡️ Build success in 1506ms
+CJS dist/index.js          2.68 KB
+CJS dist/react.js          33.13 KB
+CJS ⚡️ Build success in 3052ms
 ESM dist/chunk-UUVLERWJ.mjs 2.18 KB
-ESM dist/react.mjs          28.31 KB
-ESM dist/index.mjs          1.95 KB
-ESM ⚡️ Build success in 1506ms
+ESM dist/index.mjs          2.28 KB
+ESM dist/react.mjs          31.72 KB
+ESM ⚡️ Build success in 3052ms
 DTS Build start
-DTS ⚡️ Build success in 14735ms
-DTS dist/index.d.ts          1.68 KB
-DTS dist/react.d.ts          4.21 KB
-DTS dist/types-92a8b029.d.ts 1.06 KB
+DTS ⚡️ Build success in 32179ms
+DTS dist/index.d.ts          3.23 KB
+DTS dist/react.d.ts          5.01 KB
+DTS dist/types-dcc7ec4a.d.ts 1.11 KB

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @pancakeswap/token-lists
 
+## 0.1.1
+
+### Patch Changes
+
+- Updated dependencies [851a494]
+  - @pancakeswap/swap-sdk-core@1.6.1
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { SerializedToken, Token } from '@pancakeswap/swap-sdk-core';
-import { T as TokenInfo, a as TokenList, V as Version } from './types-92a8b029.js';
-export { b as Tags } from './types-92a8b029.js';
+import { T as TokenInfo, a as TokenList, V as Version } from './types-dcc7ec4a.js';
+export { b as Tags } from './types-dcc7ec4a.js';
 
 interface SerializedWrappedToken extends SerializedToken {
     chainId: number;
@@ -16,6 +16,12 @@ interface SerializedWrappedToken extends SerializedToken {
  */
 declare class WrappedTokenInfo extends Token {
     readonly logoURI: string | undefined;
+    /**
+     * Preserves the token-list `extensions` bag (curator-set metadata like
+     * `bridgeInfo`, `scaledUIAmount.enabled`, etc.). Stored as a readonly reference;
+     * not serialised back out of the class (kept in-memory only).
+     */
+    readonly extensions: TokenInfo['extensions'];
     constructor(tokenInfo: TokenInfo);
     get serialize(): SerializedWrappedToken;
 }
@@ -49,4 +55,30 @@ declare function getVersionUpgrade(base: Version, update: Version): VersionUpgra
 
 declare function createFilterToken<T extends TokenInfo | Token>(search: string, isAddress: (address: string) => boolean): (token: T) => boolean;
 
-export { SerializedWrappedToken, TokenAddressMap, TokenInfo, TokenList, Version, VersionUpgrade, WrappedTokenInfo, createFilterToken, deserializeToken, getVersionUpgrade };
+/**
+ * Static metadata identifying an ERC-8056 (Scaled UI Amount) token in a token list.
+ * `enabled: true` is the only field FE consumes for routing decisions; everything
+ * else is hint/snapshot data refreshed live from chain.
+ */
+interface ScaledUIAmountExtension {
+    /** Set to `true` for tokens that implement ERC-8056. The load-bearing FE check. */
+    enabled: boolean;
+    /** Optional snapshot of the live multiplier at the time of indexing (18-decimal fixed). */
+    multiplier?: string;
+    /** Optional human-readable multiplier (e.g. `"2.0"`). Display hint only. */
+    multiplierFormatted?: string;
+    /** ERC-165 interface IDs the contract claims to support. */
+    interfaceIds?: string[];
+}
+/**
+ * Returns true if a token-list entry is flagged as ERC-8056 enabled by the indexer.
+ * Tokens lacking the extension or with `enabled: false` are treated as standard ERC-20s
+ * (identity multiplier `1.0×`); the FE never falls into ScaledUI math for these.
+ *
+ * Note: the load-bearing decision lives here, not on the `Token` class. Token
+ * instances stay pure identity objects per the architectural decision in the
+ * implementation doc.
+ */
+declare function isScaledUIAmountToken(token: Pick<TokenInfo, 'extensions'>): boolean;
+
+export { ScaledUIAmountExtension, SerializedWrappedToken, TokenAddressMap, TokenInfo, TokenList, Version, VersionUpgrade, WrappedTokenInfo, createFilterToken, deserializeToken, getVersionUpgrade, isScaledUIAmountToken };

package/dist/index.js

@@ -7,6 +7,7 @@ var WrappedTokenInfo = class extends swapSdkCore.Token {
   constructor(tokenInfo) {
     super(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
     this.logoURI = tokenInfo.logoURI;
+    this.extensions = tokenInfo.extensions;
   }
   get serialize() {
     return {
@@ -61,6 +62,15 @@ function createFilterToken(search, isAddress) {
   };
 }
 
+// src/scaledUIAmount.ts
+function isScaledUIAmountToken(token) {
+  var _a;
+  const ext = (_a = token.extensions) == null ? void 0 : _a.scaledUIAmount;
+  if (!ext || typeof ext !== "object" || Array.isArray(ext))
+    return false;
+  return ext.enabled === true;
+}
+
 Object.defineProperty(exports, 'VersionUpgrade', {
   enumerable: true,
   get: function () { return chunkY2NTTLTJ_js.VersionUpgrade; }
@@ -72,3 +82,4 @@ Object.defineProperty(exports, 'getVersionUpgrade', {
 exports.WrappedTokenInfo = WrappedTokenInfo;
 exports.createFilterToken = createFilterToken;
 exports.deserializeToken = deserializeToken;
+exports.isScaledUIAmountToken = isScaledUIAmountToken;

package/dist/index.mjs

@@ -5,6 +5,7 @@ var WrappedTokenInfo = class extends Token {
   constructor(tokenInfo) {
     super(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
     this.logoURI = tokenInfo.logoURI;
+    this.extensions = tokenInfo.extensions;
   }
   get serialize() {
     return {
@@ -59,4 +60,13 @@ function createFilterToken(search, isAddress) {
   };
 }
 
-export { WrappedTokenInfo, createFilterToken, deserializeToken };
+// src/scaledUIAmount.ts
+function isScaledUIAmountToken(token) {
+  var _a;
+  const ext = (_a = token.extensions) == null ? void 0 : _a.scaledUIAmount;
+  if (!ext || typeof ext !== "object" || Array.isArray(ext))
+    return false;
+  return ext.enabled === true;
+}
+
+export { WrappedTokenInfo, createFilterToken, deserializeToken, isScaledUIAmountToken };

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import * as _reduxjs_toolkit from '@reduxjs/toolkit';
 import { ActionCreatorWithPayload } from '@reduxjs/toolkit';
-import { a as TokenList, V as Version, T as TokenInfo } from './types-92a8b029.js';
+import { a as TokenList, V as Version, T as TokenInfo } from './types-dcc7ec4a.js';
 import * as jotai_vanilla_utils_atomFamily from 'jotai/vanilla/utils/atomFamily';
 import * as jotai from 'jotai';
 import * as _reduxjs_toolkit_dist_createReducer from '@reduxjs/toolkit/dist/createReducer';
@@ -69,9 +69,23 @@ type ListByUrlState = ListsState['byUrl'][string];
 declare const NEW_LIST_STATE: ListByUrlState;
 declare const createTokenListReducer: (initialState: ListsState, DEFAULT_LIST_OF_LISTS: string[], DEFAULT_ACTIVE_LIST_URLS: string[]) => _reduxjs_toolkit_dist_createReducer.ReducerWithInitialState<ListsState>;
 
+type GeoBlockList = {
+    rules?: Record<string, string[]>;
+    tokens?: Record<string, string[]>;
+};
+type CreateListsAtomOptions = {
+    geoBlockListUrl?: string;
+};
+type TokenKeyLike = {
+    chainId: number;
+    address: string;
+};
+declare function getGeoBlockTokenKey(token: TokenKeyLike): string;
+declare function getGeoBlockedTokenKeys(geoBlockList?: GeoBlockList, countryCode?: string): Set<string>;
+declare function isGeoBlockedToken(token: TokenKeyLike, geoBlockList?: GeoBlockList, countryCode?: string): boolean;
 declare function findTokenByAddress(state: ListsState, chainId: number, address: string): TokenInfo | undefined;
 declare function findTokenBySymbol(state: ListsState, chainId: number, symbol: string): TokenInfo | undefined;
-declare const createListsAtom: (storeName: string, reducer: any, initialState: any) => {
+declare const createListsAtom: (storeName: string, reducer: any, initialState: any, options?: CreateListsAtomOptions) => {
     listsAtom: jotai.Atom<ListsState>;
     updateListStateAtom: jotai.WritableAtom<null, any, void> & {
         init: null;
@@ -84,6 +98,10 @@ declare const createListsAtom: (storeName: string, reducer: any, initialState: a
         chainId: number;
         symbol: string;
     }, jotai.Atom<TokenInfo | undefined>>;
+    geoBlockListAtom: jotai.Atom<GeoBlockList | undefined>;
+    fetchGeoBlockListAtom: jotai.WritableAtom<null, [], Promise<void>> & {
+        init: null;
+    };
     fetchListAtom: jotai.WritableAtom<null, [string], Promise<void>> & {
         init: null;
     };
@@ -96,4 +114,4 @@ declare const createListsAtom: (storeName: string, reducer: any, initialState: a
 
 declare function useFetchListCallback(dispatch: (action?: unknown) => void): (listUrl: string, sendDispatch?: boolean) => Promise<TokenList>;
 
-export { ListByUrlState, ListsState, NEW_LIST_STATE, acceptListUpdate, addList, batchFetchTokenListFulfilled, batchFetchTokenListPending, batchFetchTokenListRejected, createListsAtom, createTokenListReducer, disableList, enableList, fetchTokenList, findTokenByAddress, findTokenBySymbol, getTokenList, rejectVersionUpdate, removeList, updateListVersion, useFetchListCallback };
+export { CreateListsAtomOptions, GeoBlockList, ListByUrlState, ListsState, NEW_LIST_STATE, acceptListUpdate, addList, batchFetchTokenListFulfilled, batchFetchTokenListPending, batchFetchTokenListRejected, createListsAtom, createTokenListReducer, disableList, enableList, fetchTokenList, findTokenByAddress, findTokenBySymbol, getGeoBlockTokenKey, getGeoBlockedTokenKeys, getTokenList, isGeoBlockedToken, rejectVersionUpdate, removeList, updateListVersion, useFetchListCallback };

package/dist/react.js

@@ -410,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: {
@@ -455,17 +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(chunkY2NTTLTJ_js.__spreadProps(chunkY2NTTLTJ_js.__spreadValues({}, json), { tokens: [token] })));
           if (!validator(json)) {
             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.error(`Failed to download or validate list from ${url}:`, error);
+        console.warn(`Failed to download or validate list from ${url}:`, error);
         return void 0;
       }
     }
@@ -480,6 +487,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 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 noop() {
 }
 var noopStorage = {
@@ -510,7 +558,7 @@ 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({
@@ -546,32 +594,77 @@ var createListsAtom = (storeName, reducer, initialState) => {
   const tokenListsStorageAtom = utils.atomWithStorage(
     "tokenLists",
     EMPTY,
-    IndexedDBStorage("tokenLists")
+    IndexedDBStorage("tokenLists"),
+    { getOnInit: true }
   );
+  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) {
-      const storedTokenLists = value.data;
-      const reconstructedState = chunkY2NTTLTJ_js.__spreadValues({}, memoryState);
-      const updatedByUrl = chunkY2NTTLTJ_js.__spreadValues({}, reconstructedState.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
-          });
-        }
-      });
-      reconstructedState.byUrl = updatedByUrl;
-      return reconstructedState;
+      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 currentMemoryState = get(memoryStateAtom);
-    const newState = reducer(currentMemoryState, action);
+    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) => {
@@ -580,7 +673,7 @@ var createListsAtom = (storeName, reducer, initialState) => {
         tokenListsToStore[url] = newState.byUrl[url].current;
       }
     });
-    set(tokenListsStorageAtom, tokenListsToStore);
+    set(tokenListsStorageAtom, { byUrl: tokenListsToStore, activeListUrls: newState.activeListUrls });
   }));
   const isReadyAtom = utils.loadable(tokenListsStorageAtom);
   const tokenAtom = utils.atomFamily(
@@ -664,6 +757,8 @@ var createListsAtom = (storeName, reducer, initialState) => {
     updateListStateAtom,
     tokenAtom,
     tokenBySymbolAtom,
+    geoBlockListAtom,
+    fetchGeoBlockListAtom,
     fetchListAtom,
     fetchListBatchAtom,
     useListStateReady,
@@ -849,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 }));
         }
@@ -874,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;

package/dist/react.mjs

@@ -403,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: {
@@ -448,17 +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;
             throw new Error(`Validation failed after filtering: ${JSON.stringify(errors)}`);
           }
-          console.warn(`Pre-filter validation errors: ${JSON.stringify(preFilterErrors)}`);
         }
         return json;
       } catch (error) {
-        console.error(`Failed to download or validate list from ${url}:`, error);
+        console.warn(`Failed to download or validate list from ${url}:`, error);
         return void 0;
       }
     }
@@ -473,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 = {
@@ -503,7 +551,7 @@ 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({
@@ -539,32 +587,77 @@ var createListsAtom = (storeName, reducer, initialState) => {
   const tokenListsStorageAtom = atomWithStorage(
     "tokenLists",
     EMPTY,
-    IndexedDBStorage("tokenLists")
+    IndexedDBStorage("tokenLists"),
+    { getOnInit: true }
   );
+  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) {
-      const storedTokenLists = value.data;
-      const reconstructedState = __spreadValues({}, memoryState);
-      const updatedByUrl = __spreadValues({}, reconstructedState.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
-          });
-        }
-      });
-      reconstructedState.byUrl = updatedByUrl;
-      return reconstructedState;
+      return mergeStoredData(memoryState, value.data);
     }
     return memoryState;
   });
+  let hasHydratedActiveListUrls = false;
   const updateListStateAtom = atom(null, (get, set, action) => __async(void 0, null, function* () {
-    const currentMemoryState = get(memoryStateAtom);
-    const newState = reducer(currentMemoryState, action);
+    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) => {
@@ -573,7 +666,7 @@ var createListsAtom = (storeName, reducer, initialState) => {
         tokenListsToStore[url] = newState.byUrl[url].current;
       }
     });
-    set(tokenListsStorageAtom, tokenListsToStore);
+    set(tokenListsStorageAtom, { byUrl: tokenListsToStore, activeListUrls: newState.activeListUrls });
   }));
   const isReadyAtom = loadable(tokenListsStorageAtom);
   const tokenAtom = atomFamily(
@@ -657,6 +750,8 @@ var createListsAtom = (storeName, reducer, initialState) => {
     updateListStateAtom,
     tokenAtom,
     tokenBySymbolAtom,
+    geoBlockListAtom,
+    fetchGeoBlockListAtom,
     fetchListAtom,
     fetchListBatchAtom,
     useListStateReady,
@@ -842,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 }));
         }
@@ -854,4 +949,4 @@ function useFetchListCallback(dispatch) {
 }
 var useFetchListCallback_default = useFetchListCallback;
 
-export { NEW_LIST_STATE, acceptListUpdate, addList, batchFetchTokenListFulfilled, batchFetchTokenListPending, batchFetchTokenListRejected, 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.1.0",
+  "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.6.0"
+    "@pancakeswap/swap-sdk-core": "1.6.1"
   },
   "peerDependencies": {
     "@reduxjs/toolkit": "^1.9.1",
@@ -23,7 +23,7 @@
     "react": "^18.2.0",
     "tsup": "^6.7.0",
     "@types/lodash": "^4.14.182",
-    "@pancakeswap/utils": "8.0.2"
+    "@pancakeswap/utils": "8.0.3"
   },
   "exports": {
     ".": {

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)
+  })
+})

package/react/getTokenList.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { getTokenList } from './getTokenList'
+
+const validList = {
+  name: 'Test List',
+  timestamp: '2026-04-29T00:00:00.000Z',
+  version: {
+    major: 1,
+    minor: 0,
+    patch: 0,
+  },
+  tokens: [
+    {
+      chainId: 56,
+      address: '0x0000000000000000000000000000000000000001',
+      decimals: 18,
+      name: 'Valid Token',
+      symbol: 'VALID',
+    },
+  ],
+}
+
+describe('getTokenList', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('filters invalid tokens without warning when the list is recoverable', async () => {
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        ...validList,
+        tokens: [
+          ...validList.tokens,
+          {
+            chainId: 56,
+            address: '0x0000000000000000000000000000000000000002',
+            decimals: 18,
+            name: 'Broken Token',
+            symbol: 'BROKEN🚨',
+          },
+        ],
+      }),
+    } as Response)
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const list = await getTokenList('https://tokens.example.com/list.json')
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1)
+    expect(list?.tokens).toHaveLength(1)
+    expect(list?.tokens[0]?.symbol).toBe('VALID')
+    expect(warnSpy).not.toHaveBeenCalled()
+  })
+})

package/react/getTokenList.ts

@@ -17,20 +17,18 @@ export async function getTokenList(listUrl: string): Promise<TokenList | undefin
     try {
       const json = await fetchJson(url)
       if (!validator(json)) {
-        const preFilterErrors = validator.errors
         json.tokens = json.tokens.filter((token: any) => validator({ ...json, tokens: [token] }))
         if (!validator(json)) {
           const { errors } = validator
           throw new Error(`Validation failed after filtering: ${JSON.stringify(errors)}`)
         }
-        console.warn(`Pre-filter validation errors: ${JSON.stringify(preFilterErrors)}`)
       }
       return json as TokenList
     } catch (error) {
       // if (i === urls.length - 1) {
       // throw new Error(`Failed to download list ${listUrl}`)
       // }
-      console.error(`Failed to download or validate list from ${url}:`, error)
+      console.warn(`Failed to download or validate list from ${url}:`, error)
 
       return undefined
     }

package/react/index.test.ts

@@ -16,6 +16,9 @@ test('exports', () => {
       "batchFetchTokenListFulfilled",
       "batchFetchTokenListRejected",
       "getTokenList",
+      "getGeoBlockTokenKey",
+      "getGeoBlockedTokenKeys",
+      "isGeoBlockedToken",
       "findTokenByAddress",
       "findTokenBySymbol",
       "createListsAtom",

package/react/lists.ts

@@ -12,6 +12,76 @@ import {
 } from './actions'
 import { getTokenList } from './getTokenList'
 import { ListsState } from './reducer'
+
+export type GeoBlockList = {
+  rules?: Record<string, string[]>
+  tokens?: Record<string, string[]>
+}
+
+export type CreateListsAtomOptions = {
+  geoBlockListUrl?: string
+}
+
+// Persisted payload shape. `activeListUrls` was added later - existing IndexedDB
+// entries only have the flat `{ [url]: TokenList }` shape and must still be read.
+type StoredListsPayload = {
+  byUrl: Record<string, any>
+  activeListUrls?: string[]
+}
+
+type TokenKeyLike = {
+  chainId: number
+  address: string
+}
+
+function normalizeTokenAddress(address: string) {
+  return address.startsWith('0x') ? address.toLowerCase() : address
+}
+
+export function getGeoBlockTokenKey(token: TokenKeyLike) {
+  return `${token.chainId}:${normalizeTokenAddress(token.address)}`
+}
+
+function normalizeTokenKey(key: string) {
+  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)}`
+}
+
+export function getGeoBlockedTokenKeys(geoBlockList?: GeoBlockList, countryCode?: string) {
+  const blockedTokenKeys = new Set<string>()
+
+  if (!countryCode || !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
+}
+
+export function isGeoBlockedToken(token: TokenKeyLike, geoBlockList?: GeoBlockList, countryCode?: string) {
+  return getGeoBlockedTokenKeys(geoBlockList, countryCode).has(getGeoBlockTokenKey(token))
+}
+
+async function fetchJson(url: string): Promise<any> {
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`Failed to fetch: ${url}`)
+  return res.json()
+}
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 function noop() {}
 
@@ -44,7 +114,12 @@ export function findTokenBySymbol(state: ListsState, chainId: number, symbol: st
   return undefined
 }
 
-export const createListsAtom = (storeName: string, reducer: any, initialState: any) => {
+export const createListsAtom = (
+  storeName: string,
+  reducer: any,
+  initialState: any,
+  options: CreateListsAtomOptions = {},
+) => {
   /**
    * Persist only token lists using IndexedDB - optimized storage format
    * @param {string} dbName - IndexedDB database name
@@ -83,51 +158,137 @@ export const createListsAtom = (storeName: string, reducer: any, initialState: a
     return noopStorage
   }
 
-  // Storage for token lists only - optimized format: { [url]: TokenList }
-  const tokenListsStorageAtom = atomWithStorage<Record<string, any> | typeof EMPTY>(
+  // Storage for token lists and the user's enabled/disabled list selection.
+  // `getOnInit: true` starts the IndexedDB read as soon as this atom is created (module load)
+  // instead of waiting for the first component subscribe - by the time a consumer like the
+  // Manage Tokens modal actually mounts, the read has usually already resolved, avoiding a
+  // visible flash of the (all-enabled) default state before the persisted selection applies.
+  const tokenListsStorageAtom = atomWithStorage<StoredListsPayload | typeof EMPTY>(
     'tokenLists',
     EMPTY,
     IndexedDBStorage('tokenLists'),
+    { getOnInit: true },
+  )
+
+  const geoBlockListStorageAtom = atomWithStorage<GeoBlockList | typeof EMPTY>(
+    'geoBlockList',
+    EMPTY,
+    IndexedDBStorage('geoBlockList'),
   )
 
+  const geoBlockListAtom = atom<GeoBlockList | undefined>((get) => {
+    const value = get(loadable(geoBlockListStorageAtom))
+    if (value.state === 'hasData' && value.data && value.data !== EMPTY) {
+      return value.data as GeoBlockList
+    }
+    return undefined
+  })
+
+  const fetchGeoBlockListAtom = atom<null, [], Promise<void>>(null, async (_get, set) => {
+    if (!options.geoBlockListUrl) {
+      return
+    }
+
+    try {
+      set(geoBlockListStorageAtom, await fetchJson(options.geoBlockListUrl))
+    } catch (error) {
+      console.warn(`Failed to download geo block list from ${options.geoBlockListUrl}:`, error)
+    }
+  })
+
   // Memory state atom that holds the full ListsState
   const memoryStateAtom = atom<ListsState>(initialState as ListsState)
 
+  // Merges a resolved storage payload's token list content and active-list selection onto a
+  // base ListsState. Shared by `listStateAtom` (read-time overlay, for display before the first
+  // dispatch has hydrated memory) and `updateListStateAtom` (one-time hydration into memory, so
+  // reducer calls - e.g. "this list's content was already fetched" - see accurate `byUrl.current`
+  // and don't treat an already-cached-but-disabled list as newly discovered and re-activate it).
+  const mergeStoredData = (baseState: ListsState, storedData: StoredListsPayload | Record<string, any>) => {
+    // Backward compat: pre-existing IndexedDB entries are a flat { [url]: TokenList } map with
+    // no `byUrl`/`activeListUrls` wrapper.
+    const storedTokenLists: Record<string, any> = storedData.byUrl ?? storedData
+    const storedActiveListUrls = Array.isArray((storedData as StoredListsPayload).activeListUrls)
+      ? (storedData as StoredListsPayload).activeListUrls
+      : undefined
+
+    const mergedState = { ...baseState }
+
+    const updatedByUrl = { ...mergedState.byUrl }
+    Object.keys(storedTokenLists).forEach((url) => {
+      if (storedTokenLists[url]) {
+        updatedByUrl[url] = {
+          ...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<ListsState>((get) => {
     // Separate this(mem/storage) is a prepare for refactor of the list part
     const memoryState = get(memoryStateAtom)
     const value = get(loadable(tokenListsStorageAtom))
 
     if (value.state === 'hasData' && value.data && value.data !== EMPTY) {
-      const storedTokenLists = value.data as Record<string, any>
-      const reconstructedState = { ...memoryState }
-
-      const updatedByUrl = { ...reconstructedState.byUrl }
-      Object.keys(storedTokenLists).forEach((url) => {
-        if (storedTokenLists[url]) {
-          updatedByUrl[url] = {
-            ...updatedByUrl[url],
-            current: storedTokenLists[url],
-            // Keep existing memory state for loading, error, pendingUpdate
-          }
-        }
-      })
-      reconstructedState.byUrl = updatedByUrl
-
-      return reconstructedState
+      return mergeStoredData(memoryState, value.data as StoredListsPayload | Record<string, any>)
     }
 
     return memoryState
   })
 
+  // Set once the persisted storage read has resolved (whether it held data or was genuinely
+  // empty) and been merged into `memoryStateAtom` (both `byUrl.current` and `activeListUrls`).
+  // Two things depend on this:
+  // 1. Every reducer call after hydration bases itself on `memoryStateAtom` alone - a single,
+  //    synchronously-consistent source of truth - instead of re-reading the async, loadable
+  //    wrapped storage atom on every dispatch, which could otherwise let one action's write race
+  //    another action's read of a not-yet-updated storage snapshot.
+  // 2. Until hydration completes, writes are NOT persisted (see below) - otherwise the very first
+  //    action dispatched on boot (typically `updateListVersion`, fired as soon as the app
+  //    considers storage "ready") can itself run before the storage read has resolved, compute a
+  //    default-only state, and persist it - permanently clobbering the real persisted value the
+  //    read just hadn't returned yet. Hydrating `byUrl.current` too (not just `activeListUrls`)
+  //    matters because `setFulfilledTokenList` treats a null `current` as "list never loaded
+  //    before" and auto re-activates it if it's in the default set - without this, refetching an
+  //    already-cached-but-user-disabled list on boot would silently re-enable it.
+  let hasHydratedActiveListUrls = false
+
   const updateListStateAtom = atom<null, any, void>(null, async (get, set, action) => {
-    const currentMemoryState = get(memoryStateAtom)
-    const newState = reducer(currentMemoryState, action)
+    const baseState = get(memoryStateAtom)
+
+    if (!hasHydratedActiveListUrls) {
+      const storageValue = get(loadable(tokenListsStorageAtom))
+
+      if (storageValue.state !== 'hasData') {
+        // Storage hasn't resolved yet - update memory optimistically so the UI stays responsive,
+        // but skip persisting until we know what (if anything) was already stored.
+        const optimisticState = reducer(baseState, action)
+        set(memoryStateAtom, { ...optimisticState })
+        return
+      }
+
+      if (storageValue.data && storageValue.data !== EMPTY) {
+        set(memoryStateAtom, mergeStoredData(baseState, storageValue.data as StoredListsPayload | Record<string, any>))
+      }
+      hasHydratedActiveListUrls = true
+    }
+
+    const currentState = get(memoryStateAtom)
+    const newState = reducer(currentState, action)
 
     // Update memory state
     set(memoryStateAtom, { ...newState })
 
-    // Extract only current token lists for storage
+    // Extract current token lists and the active list selection for storage
     const tokenListsToStore: Record<string, any> = {}
     Object.keys(newState.byUrl).forEach((url) => {
       if (newState.byUrl[url]?.current) {
@@ -135,8 +296,7 @@ export const createListsAtom = (storeName: string, reducer: any, initialState: a
       }
     })
 
-    // Store only the token lists, not the full state
-    set(tokenListsStorageAtom, tokenListsToStore)
+    set(tokenListsStorageAtom, { byUrl: tokenListsToStore, activeListUrls: newState.activeListUrls })
   })
 
   const isReadyAtom = loadable(tokenListsStorageAtom)
@@ -241,6 +401,8 @@ export const createListsAtom = (storeName: string, reducer: any, initialState: a
     updateListStateAtom,
     tokenAtom,
     tokenBySymbolAtom,
+    geoBlockListAtom,
+    fetchGeoBlockListAtom,
     fetchListAtom,
     fetchListBatchAtom,
     useListStateReady,

package/react/useFetchListCallback.ts

@@ -26,7 +26,7 @@ function useFetchListCallback(
           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 }))
           }

package/schema/pancakeswap.json

@@ -356,6 +356,15 @@
       "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": {

package/src/index.test.ts

@@ -9,6 +9,7 @@ test('exports', () => {
       "VersionUpgrade",
       "getVersionUpgrade",
       "createFilterToken",
+      "isScaledUIAmountToken",
     ]
   `)
 })

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './wrappedTokenInfo'
 export * from './types'
 export * from './getVersionUpgrade'
 export * from './filtering'
+export * from './scaledUIAmount'

package/src/scaledUIAmount.ts

@@ -0,0 +1,41 @@
+// Token-list `extensions.scaledUIAmount` metadata for ERC-8056 (Scaled UI Amount) tokens.
+//
+// Curated by the indexer/CMS at ingestion time. The boolean `enabled` flag is the
+// load-bearing FE-side check; other fields are snapshots / hints (the live multiplier
+// is always re-read from chain via the `useScaledUIAmountMetadata` hook).
+//
+// See BNB Chain partner integration doc v1.0 (8 Apr 2026) §8.2.4 for the upstream
+// shape this is modeled after.
+
+import type { TokenInfo } from './types'
+
+/**
+ * Static metadata identifying an ERC-8056 (Scaled UI Amount) token in a token list.
+ * `enabled: true` is the only field FE consumes for routing decisions; everything
+ * else is hint/snapshot data refreshed live from chain.
+ */
+export interface ScaledUIAmountExtension {
+  /** Set to `true` for tokens that implement ERC-8056. The load-bearing FE check. */
+  enabled: boolean
+  /** Optional snapshot of the live multiplier at the time of indexing (18-decimal fixed). */
+  multiplier?: string
+  /** Optional human-readable multiplier (e.g. `"2.0"`). Display hint only. */
+  multiplierFormatted?: string
+  /** ERC-165 interface IDs the contract claims to support. */
+  interfaceIds?: string[]
+}
+
+/**
+ * Returns true if a token-list entry is flagged as ERC-8056 enabled by the indexer.
+ * Tokens lacking the extension or with `enabled: false` are treated as standard ERC-20s
+ * (identity multiplier `1.0×`); the FE never falls into ScaledUI math for these.
+ *
+ * Note: the load-bearing decision lives here, not on the `Token` class. Token
+ * instances stay pure identity objects per the architectural decision in the
+ * implementation doc.
+ */
+export function isScaledUIAmountToken(token: Pick<TokenInfo, 'extensions'>): boolean {
+  const ext = token.extensions?.scaledUIAmount
+  if (!ext || typeof ext !== 'object' || Array.isArray(ext)) return false
+  return (ext as { enabled?: unknown }).enabled === true
+}

package/src/types.ts

@@ -43,4 +43,5 @@ export interface TokenList {
   readonly keywords?: string[]
   readonly tags?: Tags
   readonly logoURI?: string
+  readonly extensions?: Record<string, unknown>
 }

package/src/wrappedTokenInfo.ts

@@ -17,9 +17,17 @@ export interface SerializedWrappedToken extends SerializedToken {
 export class WrappedTokenInfo extends Token {
   public readonly logoURI: string | undefined
 
+  /**
+   * Preserves the token-list `extensions` bag (curator-set metadata like
+   * `bridgeInfo`, `scaledUIAmount.enabled`, etc.). Stored as a readonly reference;
+   * not serialised back out of the class (kept in-memory only).
+   */
+  public readonly extensions: TokenInfo['extensions']
+
   constructor(tokenInfo: TokenInfo) {
     super(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name)
     this.logoURI = tokenInfo.logoURI
+    this.extensions = tokenInfo.extensions
   }
 
   public get serialize(): SerializedWrappedToken {