@pancakeswap/token-lists 0.0.17 → 0.1.1

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,19 +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.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 as TokenList
     } catch (error) {
       // if (i === urls.length - 1) {
       // throw new Error(`Failed to download list ${listUrl}`)
       // }
+      console.warn(`Failed to download or validate list from ${url}:`, error)
 
       return undefined
     }

package/react/index.test.ts

@@ -12,7 +12,13 @@ test('exports', () => {
       "acceptListUpdate",
       "rejectVersionUpdate",
       "updateListVersion",
+      "batchFetchTokenListPending",
+      "batchFetchTokenListFulfilled",
+      "batchFetchTokenListRejected",
       "getTokenList",
+      "getGeoBlockTokenKey",
+      "getGeoBlockedTokenKeys",
+      "isGeoBlockedToken",
       "findTokenByAddress",
       "findTokenBySymbol",
       "createListsAtom",

package/react/lists.ts

@@ -3,10 +3,85 @@ import { atom, useAtom, useAtomValue } from 'jotai'
 import { atomFamily, atomWithStorage, loadable } from 'jotai/utils'
 import { type AsyncStorage } from 'jotai/vanilla/utils/atomWithStorage'
 import localForage from 'localforage'
-import { fetchTokenList } from './actions'
+import debounce from 'lodash/debounce'
+import {
+  fetchTokenList,
+  batchFetchTokenListPending,
+  batchFetchTokenListFulfilled,
+  batchFetchTokenListRejected,
+} 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() {}
 
@@ -39,9 +114,14 @@ 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 you redux state using IndexedDB
+   * Persist only token lists using IndexedDB - optimized storage format
    * @param {string} dbName - IndexedDB database name
    */
   function IndexedDBStorage<Value>(dbName: string): AsyncStorage<Value> {
@@ -50,17 +130,27 @@ export const createListsAtom = (storeName: string, reducer: any, initialState: a
         name: dbName,
         storeName,
       })
+      const mem = new Map<string, any>()
+
+      const debouncedSetItem = debounce(async (k: string, v: any) => {
+        db.setItem(k, v)
+      }, 300)
+
       return {
         getItem: async (key: string) => {
+          if (mem.has(key)) {
+            return mem.get(key)
+          }
           const value = await db.getItem(key)
           if (value) {
             return value
           }
-          return initialState
+          return undefined as any
         },
         setItem: async (k: string, v: any) => {
           if (v === EMPTY) return
-          await db.setItem(k, v)
+          mem.set(k, v)
+          debouncedSetItem(k, v)
         },
         removeItem: db.removeItem,
       }
@@ -68,63 +158,253 @@ export const createListsAtom = (storeName: string, reducer: any, initialState: a
     return noopStorage
   }
 
-  const listsStorageAtom = atomWithStorage<ListsState | typeof EMPTY>('lists', EMPTY, IndexedDBStorage('lists'))
+  // 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 defaultStateAtom = atom<ListsState, any, void>(
-    (get) => {
-      const value = get(loadable(listsStorageAtom))
-      if (value.state === 'hasData' && value.data !== EMPTY) {
-        return value.data
-      }
-      return initialState
-    },
-    async (get, set, action) => {
-      set(listsStorageAtom, reducer(await get(defaultStateAtom), action))
-    },
+  const geoBlockListStorageAtom = atomWithStorage<GeoBlockList | typeof EMPTY>(
+    'geoBlockList',
+    EMPTY,
+    IndexedDBStorage('geoBlockList'),
   )
 
-  const isReadyAtom = loadable(listsStorageAtom)
+  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) {
+      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 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 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) {
+        tokenListsToStore[url] = newState.byUrl[url].current
+      }
+    })
+
+    set(tokenListsStorageAtom, { byUrl: tokenListsToStore, activeListUrls: newState.activeListUrls })
+  })
+
+  const isReadyAtom = loadable(tokenListsStorageAtom)
 
   const tokenAtom = atomFamily((key: { chainId: number; address: string }) =>
-    atom((get) => findTokenByAddress(get(defaultStateAtom), key.chainId, key.address)),
+    atom((get) => findTokenByAddress(get(listStateAtom), key.chainId, key.address)),
   )
 
   const tokenBySymbolAtom = atomFamily((key: { chainId: number; symbol: string }) =>
-    atom((get) => findTokenBySymbol(get(defaultStateAtom), key.chainId, key.symbol)),
+    atom((get) => findTokenBySymbol(get(listStateAtom), key.chainId, key.symbol)),
   )
 
   const fetchListAtom = atom<null, [string], Promise<void>>(null, async (get, set, url) => {
-    const state = get(defaultStateAtom)
+    const state = get(listStateAtom)
     const listState = state.byUrl[url]
     if (listState?.current || listState?.loadingRequestId) {
       return
     }
 
     const requestId = nanoid()
-    set(defaultStateAtom, fetchTokenList.pending({ url, requestId }))
+    set(updateListStateAtom, fetchTokenList.pending({ url, requestId }))
 
     try {
       const tokenList = await getTokenList(url)
-      set(defaultStateAtom, fetchTokenList.fulfilled({ url, tokenList: tokenList!, requestId }))
+      set(updateListStateAtom, fetchTokenList.fulfilled({ url, tokenList: tokenList!, requestId }))
+    } catch (error: any) {
+      set(updateListStateAtom, fetchTokenList.rejected({ url, requestId, errorMessage: error.message }))
+    }
+  })
+
+  const fetchListBatchAtom = atom<null, [string[]], Promise<void>>(null, async (get, set, urls) => {
+    const state = get(listStateAtom)
+
+    // Filter out URLs that are already loaded or loading
+    const urlsToFetch = urls.filter((url) => {
+      const listState = state.byUrl[url]
+      return !listState?.current && !listState?.loadingRequestId
+    })
+
+    if (urlsToFetch.length === 0) {
+      return
+    }
+
+    const requestId = nanoid()
+    set(updateListStateAtom, batchFetchTokenListPending({ urls: urlsToFetch, requestId }))
+
+    try {
+      // Fetch all token lists in parallel
+      const results = await Promise.allSettled(
+        urlsToFetch.map(async (url) => {
+          const tokenList = await getTokenList(url)
+          return { url, tokenList: tokenList!, requestId }
+        }),
+      )
+
+      // Separate successful and failed results
+      const fulfilled: Array<{ url: string; tokenList: any; requestId: string }> = []
+      const rejected: Array<{ url: string; errorMessage: string; requestId: string }> = []
+
+      results.forEach((result, index) => {
+        const url = urlsToFetch[index]
+        if (result.status === 'fulfilled') {
+          fulfilled.push(result.value)
+        } else {
+          rejected.push({
+            url,
+            errorMessage: result.reason?.message || 'Unknown error',
+            requestId,
+          })
+        }
+      })
+
+      // Dispatch batch actions
+      if (fulfilled.length > 0) {
+        set(updateListStateAtom, batchFetchTokenListFulfilled({ results: fulfilled }))
+      }
+      if (rejected.length > 0) {
+        set(updateListStateAtom, batchFetchTokenListRejected({ errors: rejected }))
+      }
     } catch (error: any) {
-      set(defaultStateAtom, fetchTokenList.rejected({ url, requestId, errorMessage: error.message }))
+      // Fallback to individual rejections if batch processing fails
+      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,
   }

package/react/reducer.ts

@@ -8,8 +8,12 @@ import {
   enableList,
   disableList,
   updateListVersion,
+  batchFetchTokenListPending,
+  batchFetchTokenListFulfilled,
+  batchFetchTokenListRejected,
 } from './actions'
-import { getVersionUpgrade, VersionUpgrade, TokenList } from '../src'
+import { TokenList } from '../src/types'
+import { setPendingTokenList, setFulfilledTokenList, setRejectedTokenList, batchActivateUrls } from './reducerHelpers'
 
 export interface ListsState {
   readonly byUrl: {
@@ -44,62 +48,13 @@ export const createTokenListReducer = (
   createReducer(initialState, (builder) =>
     builder
       .addCase(fetchTokenList.pending, (state, { payload: { requestId, url } }) => {
-        const current = state.byUrl[url]?.current ?? null
-        const pendingUpdate = state.byUrl[url]?.pendingUpdate ?? null
-
-        state.byUrl[url] = {
-          current,
-          pendingUpdate,
-          loadingRequestId: requestId,
-          error: null,
-        }
+        setPendingTokenList(state, url, requestId)
       })
       .addCase(fetchTokenList.fulfilled, (state, { payload: { requestId, tokenList, url } }) => {
-        const current = state.byUrl[url]?.current
-        const loadingRequestId = state.byUrl[url]?.loadingRequestId
-
-        // no-op if update does nothing
-        if (current) {
-          const upgradeType = getVersionUpgrade(current.version, tokenList.version)
-
-          if (upgradeType === VersionUpgrade.NONE) return
-          if (loadingRequestId === null || loadingRequestId === requestId) {
-            state.byUrl[url] = {
-              ...state.byUrl[url],
-              loadingRequestId: null,
-              error: null,
-              current,
-              pendingUpdate: tokenList,
-            }
-          }
-        } else {
-          // activate if on default active
-          if (DEFAULT_ACTIVE_LIST_URLS.includes(url) && state.activeListUrls && !state.activeListUrls.includes(url)) {
-            state.activeListUrls.push(url)
-          }
-
-          state.byUrl[url] = {
-            ...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 } }) => {
-        if (state.byUrl[url]?.loadingRequestId !== requestId) {
-          // no-op since it's not the latest request
-          return
-        }
-
-        state.byUrl[url] = {
-          ...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]) {
@@ -182,5 +137,31 @@ export const createTokenListReducer = (
             return true
           })
         }
+      })
+      .addCase(batchFetchTokenListPending, (state, { payload: { urls, requestId } }) => {
+        // Batch update multiple lists to pending state in a single update cycle
+        urls.forEach((url) => {
+          setPendingTokenList(state, url, requestId)
+        })
+      })
+      .addCase(batchFetchTokenListFulfilled, (state, { payload: { results } }) => {
+        // Batch update multiple lists to fulfilled state in a single update cycle
+        const urlsToActivate: string[] = []
+
+        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)
+          }
+        })
+
+        // Batch activate URLs if needed
+        batchActivateUrls(state, urlsToActivate)
+      })
+      .addCase(batchFetchTokenListRejected, (state, { payload: { errors } }) => {
+        // Batch update multiple lists to rejected state in a single update cycle
+        errors.forEach(({ url, requestId, errorMessage }) => {
+          setRejectedTokenList(state, url, requestId, errorMessage)
+        })
       }),
   )