@pancakeswap/token-lists 0.0.16 → 0.1.0

package/react/lists.ts

@@ -3,10 +3,15 @@ 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'
-
 // eslint-disable-next-line @typescript-eslint/no-empty-function
 function noop() {}
 
@@ -41,7 +46,7 @@ export function findTokenBySymbol(state: ListsState, chainId: number, symbol: st
 
 export const createListsAtom = (storeName: string, reducer: any, initialState: any) => {
   /**
-   * 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 +55,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 +83,166 @@ 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 only - optimized format: { [url]: TokenList }
+  const tokenListsStorageAtom = atomWithStorage<Record<string, any> | typeof EMPTY>(
+    'tokenLists',
+    EMPTY,
+    IndexedDBStorage('tokenLists'),
+  )
 
-  const defaultStateAtom = atom<ListsState, any, void>(
-    (get) => {
-      const value = get(loadable(listsStorageAtom))
-      if (value.state === 'hasData' && value.data !== EMPTY) {
-        return value.data
+  // Memory state atom that holds the full ListsState
+  const memoryStateAtom = atom<ListsState>(initialState as ListsState)
+
+  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 memoryState
+  })
+
+  const updateListStateAtom = atom<null, any, void>(null, async (get, set, action) => {
+    const currentMemoryState = get(memoryStateAtom)
+    const newState = reducer(currentMemoryState, action)
+
+    // Update memory state
+    set(memoryStateAtom, { ...newState })
+
+    // Extract only current token lists for storage
+    const tokenListsToStore: Record<string, any> = {}
+    Object.keys(newState.byUrl).forEach((url) => {
+      if (newState.byUrl[url]?.current) {
+        tokenListsToStore[url] = newState.byUrl[url].current
       }
-      return initialState
-    },
-    async (get, set, action) => {
-      set(listsStorageAtom, reducer(await get(defaultStateAtom), action))
-    },
-  )
+    })
+
+    // Store only the token lists, not the full state
+    set(tokenListsStorageAtom, tokenListsToStore)
+  })
 
-  const isReadyAtom = loadable(listsStorageAtom)
+  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,
     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)
+        })
       }),
   )

package/react/reducerHelpers.ts

@@ -0,0 +1,111 @@
+import { getVersionUpgrade, VersionUpgrade } from '../src/getVersionUpgrade'
+import { TokenList } from '../src/types'
+
+// Mutable state type for reducer operations
+type MutableListsState = {
+  byUrl: {
+    [url: string]: {
+      current: TokenList | null
+      pendingUpdate: TokenList | null
+      loadingRequestId: string | null
+      error: string | null
+    }
+  }
+  lastInitializedDefaultListOfLists?: string[]
+  activeListUrls: string[] | undefined
+}
+
+/**
+ * Core function to set a single list to pending state
+ */
+export const setPendingTokenList = (state: MutableListsState, url: string, requestId: string): void => {
+  const current = state.byUrl[url]?.current ?? null
+  const pendingUpdate = state.byUrl[url]?.pendingUpdate ?? null
+
+  state.byUrl[url] = {
+    current,
+    pendingUpdate,
+    loadingRequestId: requestId,
+    error: null,
+  }
+}
+
+/**
+ * Core function to set a single list to fulfilled state
+ */
+export const setFulfilledTokenList = (
+  state: MutableListsState,
+  url: string,
+  tokenList: TokenList,
+  requestId: string,
+  DEFAULT_ACTIVE_LIST_URLS: string[],
+): boolean => {
+  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 false
+    if (loadingRequestId === null || loadingRequestId === requestId) {
+      state.byUrl[url] = {
+        ...state.byUrl[url],
+        loadingRequestId: null,
+        error: null,
+        current,
+        pendingUpdate: tokenList,
+      }
+    }
+    return false // not a new list, so no activation needed
+  }
+  // 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,
+  }
+  return true // new list, might need activation
+}
+
+/**
+ * Core function to set a single list to rejected state
+ */
+export const setRejectedTokenList = (
+  state: MutableListsState,
+  url: string,
+  requestId: string,
+  errorMessage: string,
+): void => {
+  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,
+  }
+}
+
+/**
+ * Batch activate URLs if needed
+ */
+export const batchActivateUrls = (state: MutableListsState, urls: string[]): void => {
+  if (urls.length > 0 && state.activeListUrls) {
+    urls.forEach((url) => {
+      if (!state.activeListUrls!.includes(url)) {
+        state.activeListUrls!.push(url)
+      }
+    })
+  }
+}

package/schema/pancakeswap.json

@@ -11,7 +11,7 @@
         {
           "major": 1,
           "minor": 0,
-          "patch": 0
+          "patch": 1
         }
       ],
       "additionalProperties": false,
@@ -196,17 +196,17 @@
           "type": "string",
           "description": "The name of the token",
           "minLength": 1,
-          "maxLength": 40,
-          "pattern": "^[ \\w.'+\\-%/À-ÖØ-öø-ÿ:&\\[\\]\\(\\)]+$",
-          "examples": ["USD Coin"]
+          "maxLength": 60,
+          "pattern": "^[ \\w.'+\\-%/,\\$À-ÖØ-öø-ÿ:&\\[\\]\\(\\)\\u4e00-\\u9fa5]+$",
+          "examples": ["USD Coin", "币安币"]
         },
         "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", "币安"]
         },
         "logoURI": {
           "type": "string",
@@ -256,14 +256,14 @@
           "type": "string",
           "description": "The name of the token",
           "minLength": 1,
-          "maxLength": 40,
-          "pattern": "^[ \\w.'+\\-%/À-ÖØ-öø-ÿ:&\\[\\]\\(\\)]+$",
+          "maxLength": 60,
+          "pattern": "^[ \\w.'+\\-%/,\\$À-ÖØ-öø-ÿ:&\\[\\]\\(\\)]+$",
           "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"]

package/src/types.ts

@@ -7,6 +7,7 @@ export interface TokenInfo {
   readonly decimals: number
   readonly symbol: string
   readonly logoURI?: string
+  readonly programId?: string
   readonly tags?: string[]
   readonly extensions?: {
     readonly [key: string]: