@pancakeswap/token-lists 0.0.2

package/react/reducer.ts

@@ -0,0 +1,186 @@
+import { createReducer } from '@reduxjs/toolkit'
+
+import {
+  acceptListUpdate,
+  addList,
+  fetchTokenList,
+  removeList,
+  enableList,
+  disableList,
+  updateListVersion,
+} from './actions'
+import { getVersionUpgrade, VersionUpgrade, TokenList } from '../src'
+
+export interface ListsState {
+  readonly byUrl: {
+    readonly [url: string]: {
+      readonly current: TokenList | null
+      readonly pendingUpdate: TokenList | null
+      readonly loadingRequestId: string | null
+      readonly error: string | null
+    }
+  }
+  // this contains the default list of lists from the last time the updateVersion was called, i.e. the app was reloaded
+  readonly lastInitializedDefaultListOfLists?: string[]
+
+  // currently active lists
+  readonly activeListUrls: string[] | undefined
+}
+
+type ListByUrlState = ListsState['byUrl'][string]
+
+export const NEW_LIST_STATE: ListByUrlState = {
+  error: null,
+  current: null,
+  loadingRequestId: null,
+  pendingUpdate: null,
+}
+
+export const createTokenListReducer = (
+  initialState: ListsState,
+  DEFAULT_LIST_OF_LISTS: string[],
+  DEFAULT_ACTIVE_LIST_URLS: string[],
+) =>
+  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,
+        }
+      })
+      .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?.push(url)
+          }
+
+          state.byUrl[url] = {
+            ...state.byUrl[url],
+            loadingRequestId: null,
+            error: null,
+            current: tokenList,
+            pendingUpdate: null,
+          }
+        }
+      })
+      .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,
+        }
+      })
+      .addCase(addList, (state, { payload: url }) => {
+        if (!state.byUrl[url]) {
+          state.byUrl[url] = NEW_LIST_STATE
+        }
+      })
+      .addCase(removeList, (state, { payload: url }) => {
+        if (state.byUrl[url]) {
+          delete state.byUrl[url]
+        }
+        // remove list from active urls if needed
+        if (state.activeListUrls && state.activeListUrls.includes(url)) {
+          state.activeListUrls = state.activeListUrls.filter((u) => u !== url)
+        }
+      })
+      .addCase(enableList, (state, { payload: url }) => {
+        if (!state.byUrl[url]) {
+          state.byUrl[url] = NEW_LIST_STATE
+        }
+
+        if (state.activeListUrls && !state.activeListUrls.includes(url)) {
+          state.activeListUrls.push(url)
+        }
+
+        if (!state.activeListUrls) {
+          state.activeListUrls = [url]
+        }
+      })
+      .addCase(disableList, (state, { payload: url }) => {
+        if (state.activeListUrls && state.activeListUrls.includes(url)) {
+          state.activeListUrls = state.activeListUrls.filter((u) => u !== url)
+        }
+      })
+      .addCase(acceptListUpdate, (state, { payload: url }) => {
+        if (!state.byUrl[url]?.pendingUpdate) {
+          throw new Error('accept list update called without pending update')
+        }
+        state.byUrl[url] = {
+          ...state.byUrl[url],
+          pendingUpdate: null,
+          current: state.byUrl[url].pendingUpdate,
+        }
+      })
+      .addCase(updateListVersion, (state) => {
+        // state loaded from localStorage, but new lists have never been initialized
+        if (!state.lastInitializedDefaultListOfLists) {
+          state.byUrl = initialState.byUrl
+          state.activeListUrls = initialState.activeListUrls
+        } else if (state.lastInitializedDefaultListOfLists) {
+          const lastInitializedSet = state.lastInitializedDefaultListOfLists.reduce<Set<string>>(
+            (s, l) => s.add(l),
+            new Set(),
+          )
+          const newListOfListsSet = DEFAULT_LIST_OF_LISTS.reduce<Set<string>>((s, l) => s.add(l), new Set())
+
+          DEFAULT_LIST_OF_LISTS.forEach((listUrl) => {
+            if (!lastInitializedSet.has(listUrl)) {
+              state.byUrl[listUrl] = NEW_LIST_STATE
+            }
+          })
+
+          state.lastInitializedDefaultListOfLists.forEach((listUrl) => {
+            if (!newListOfListsSet.has(listUrl)) {
+              delete state.byUrl[listUrl]
+            }
+          })
+        }
+
+        state.lastInitializedDefaultListOfLists = DEFAULT_LIST_OF_LISTS
+
+        // if no active lists, activate defaults
+        if (!state.activeListUrls) {
+          state.activeListUrls = DEFAULT_ACTIVE_LIST_URLS
+
+          // for each list on default list, initialize if needed
+          DEFAULT_ACTIVE_LIST_URLS.forEach((listUrl: string) => {
+            if (!state.byUrl[listUrl]) {
+              state.byUrl[listUrl] = NEW_LIST_STATE
+            }
+            return true
+          })
+        }
+      }),
+  )

package/react/useFetchListCallback.ts

@@ -0,0 +1,37 @@
+import { nanoid } from '@reduxjs/toolkit'
+import { useCallback } from 'react'
+import { fetchTokenList } from './actions'
+import { TokenList } from '../src/types'
+
+function useFetchListCallback(
+  dispatch: (action?: unknown) => void,
+): (listUrl: string, sendDispatch?: boolean) => Promise<TokenList> {
+  // note: prevent dispatch if using for list search or unsupported list
+  return useCallback(
+    async (listUrl: string, sendDispatch = true) => {
+      const requestId = nanoid()
+      if (sendDispatch) {
+        dispatch(fetchTokenList.pending({ requestId, url: listUrl }))
+      }
+      // lazy load avj and token list schema
+      const getTokenList = (await import('./getTokenList')).default
+      return getTokenList(listUrl)
+        .then((tokenList) => {
+          if (sendDispatch) {
+            dispatch(fetchTokenList.fulfilled({ url: listUrl, tokenList, requestId }))
+          }
+          return tokenList
+        })
+        .catch((error) => {
+          console.error(`Failed to get list at url ${listUrl}`, error)
+          if (sendDispatch) {
+            dispatch(fetchTokenList.rejected({ url: listUrl, requestId, errorMessage: error.message }))
+          }
+          throw error
+        })
+    },
+    [dispatch],
+  )
+}
+
+export default useFetchListCallback

package/schema/pancakeswap.json

@@ -0,0 +1,392 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "pancakeswap",
+  "title": "PancakeSwap Token List",
+  "description": "Schema for lists of tokens compatible with the PancakeSwap Interface, including Uniswap standard and PancakeSwap Aptos",
+  "definitions": {
+    "Version": {
+      "type": "object",
+      "description": "The version of the list, used in change detection",
+      "examples": [
+        {
+          "major": 1,
+          "minor": 0,
+          "patch": 0
+        }
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "major": {
+          "type": "integer",
+          "description": "The major version of the list. Must be incremented when tokens are removed from the list or token addresses are changed.",
+          "minimum": 0,
+          "examples": [1, 2]
+        },
+        "minor": {
+          "type": "integer",
+          "description": "The minor version of the list. Must be incremented when tokens are added to the list.",
+          "minimum": 0,
+          "examples": [0, 1]
+        },
+        "patch": {
+          "type": "integer",
+          "description": "The patch version of the list. Must be incremented for any changes to the list.",
+          "minimum": 0,
+          "examples": [0, 1]
+        }
+      },
+      "required": ["major", "minor", "patch"]
+    },
+    "TagIdentifier": {
+      "type": "string",
+      "description": "The unique identifier of a tag",
+      "minLength": 1,
+      "maxLength": 10,
+      "pattern": "^[\\w]+$",
+      "examples": ["compound", "stablecoin"]
+    },
+    "ExtensionIdentifier": {
+      "type": "string",
+      "description": "The name of a token extension property",
+      "minLength": 1,
+      "maxLength": 40,
+      "pattern": "^[\\w]+$",
+      "examples": ["color", "is_fee_on_transfer", "aliases"]
+    },
+    "ExtensionMap": {
+      "type": "object",
+      "description": "An object containing any arbitrary or vendor-specific token metadata",
+      "maxProperties": 10,
+      "propertyNames": {
+        "$ref": "#/definitions/ExtensionIdentifier"
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/ExtensionValue"
+      },
+      "examples": [
+        {
+          "color": "#000000",
+          "is_verified_by_me": true
+        },
+        {
+          "x-bridged-addresses-by-chain": {
+            "1": {
+              "bridgeAddress": "0x4200000000000000000000000000000000000010",
+              "tokenAddress": "0x4200000000000000000000000000000000000010"
+            }
+          }
+        }
+      ]
+    },
+    "ExtensionPrimitiveValue": {
+      "anyOf": [
+        {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 42,
+          "examples": ["#00000"]
+        },
+        {
+          "type": "boolean",
+          "examples": [true]
+        },
+        {
+          "type": "number",
+          "examples": [15]
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "ExtensionValue": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/ExtensionPrimitiveValue"
+        },
+        {
+          "type": "object",
+          "maxProperties": 10,
+          "propertyNames": {
+            "$ref": "#/definitions/ExtensionIdentifier"
+          },
+          "additionalProperties": {
+            "$ref": "#/definitions/ExtensionValueInner0"
+          }
+        }
+      ]
+    },
+    "ExtensionValueInner0": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/ExtensionPrimitiveValue"
+        },
+        {
+          "type": "object",
+          "maxProperties": 10,
+          "propertyNames": {
+            "$ref": "#/definitions/ExtensionIdentifier"
+          },
+          "additionalProperties": {
+            "$ref": "#/definitions/ExtensionValueInner1"
+          }
+        }
+      ]
+    },
+    "ExtensionValueInner1": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/ExtensionPrimitiveValue"
+        }
+      ]
+    },
+    "TagDefinition": {
+      "type": "object",
+      "description": "Definition of a tag that can be associated with a token via its identifier",
+      "additionalProperties": false,
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The name of the tag",
+          "pattern": "^[ \\w]+$",
+          "minLength": 1,
+          "maxLength": 20
+        },
+        "description": {
+          "type": "string",
+          "description": "A user-friendly description of the tag",
+          "pattern": "^[ \\w\\.,:]+$",
+          "minLength": 1,
+          "maxLength": 200
+        }
+      },
+      "required": ["name", "description"],
+      "examples": [
+        {
+          "name": "Stablecoin",
+          "description": "A token with value pegged to another asset"
+        }
+      ]
+    },
+    "TokenInfo": {
+      "type": "object",
+      "description": "Metadata for a single token in a token list",
+      "additionalProperties": false,
+      "properties": {
+        "chainId": {
+          "type": "integer",
+          "description": "The chain ID of the Ethereum network where this token is deployed",
+          "minimum": 1,
+          "examples": [1, 42]
+        },
+        "address": {
+          "type": "string",
+          "description": "The checksummed address of the token on the specified chain ID",
+          "pattern": "^0x[a-fA-F0-9]{40}$",
+          "examples": ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]
+        },
+        "decimals": {
+          "type": "integer",
+          "description": "The number of decimals for the token balance",
+          "minimum": 0,
+          "maximum": 255,
+          "examples": [18]
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the token",
+          "minLength": 1,
+          "maxLength": 40,
+          "pattern": "^[ \\w.'+\\-%/À-ÖØ-öø-ÿ:&\\[\\]\\(\\)]+$",
+          "examples": ["USD Coin"]
+        },
+        "symbol": {
+          "type": "string",
+          "description": "The symbol for the token; must be alphanumeric",
+          "pattern": "^[a-zA-Z0-9+\\-%/$.]+$",
+          "minLength": 1,
+          "maxLength": 20,
+          "examples": ["USDC"]
+        },
+        "logoURI": {
+          "type": "string",
+          "description": "A URI to the token logo asset; if not set, interface will attempt to find a logo based on the token address; suggest SVG or PNG of size 64x64",
+          "format": "uri",
+          "examples": ["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]
+        },
+        "tags": {
+          "type": "array",
+          "description": "An array of tag identifiers associated with the token; tags are defined at the list level",
+          "items": {
+            "$ref": "#/definitions/TagIdentifier"
+          },
+          "maxItems": 10,
+          "examples": ["stablecoin", "compound"]
+        },
+        "extensions": {
+          "$ref": "#/definitions/ExtensionMap"
+        }
+      },
+      "required": ["chainId", "address", "decimals", "name", "symbol"]
+    },
+    "AptosTokenInfo": {
+      "type": "object",
+      "description": "Metadata for a single token in a token list",
+      "additionalProperties": false,
+      "properties": {
+        "chainId": {
+          "type": "integer",
+          "description": "The chain ID of the Aptos network where this token is deployed, 0 is devent",
+          "minimum": 0,
+          "examples": [1, 42]
+        },
+        "address": {
+          "type": "string",
+          "description": "The address of the coin on the specified chain ID",
+          "examples": ["0x1::aptos_coin::AptosCoin"]
+        },
+        "decimals": {
+          "type": "integer",
+          "description": "The number of decimals for the token balance",
+          "minimum": 0,
+          "maximum": 255,
+          "examples": [18]
+        },
+        "name": {
+          "type": "string",
+          "description": "The name of the token",
+          "minLength": 1,
+          "maxLength": 40,
+          "pattern": "^[ \\w.'+\\-%/À-ÖØ-öø-ÿ:&\\[\\]\\(\\)]+$",
+          "examples": ["USD Coin"]
+        },
+        "symbol": {
+          "type": "string",
+          "description": "The symbol for the token; must be alphanumeric",
+          "pattern": "^[a-zA-Z0-9+\\-%/$.]+$",
+          "minLength": 1,
+          "maxLength": 20,
+          "examples": ["USDC"]
+        },
+        "logoURI": {
+          "type": "string",
+          "description": "A URI to the token logo asset; if not set, interface will attempt to find a logo based on the token address; suggest SVG or PNG of size 64x64",
+          "format": "uri",
+          "examples": ["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]
+        },
+        "tags": {
+          "type": "array",
+          "description": "An array of tag identifiers associated with the token; tags are defined at the list level",
+          "items": {
+            "$ref": "#/definitions/TagIdentifier"
+          },
+          "maxItems": 10,
+          "examples": ["stablecoin", "compound"]
+        },
+        "extensions": {
+          "$ref": "#/definitions/ExtensionMap"
+        }
+      },
+      "required": ["chainId", "address", "decimals", "name", "symbol"]
+    }
+  },
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the token list",
+      "minLength": 1,
+      "maxLength": 30,
+      "pattern": "^[\\w ]+$",
+      "examples": ["My Token List"]
+    },
+    "timestamp": {
+      "type": "string",
+      "format": "date-time",
+      "description": "The timestamp of this list version; i.e. when this immutable version of the list was created"
+    },
+    "schema": {
+      "type": "string"
+    },
+    "version": {
+      "$ref": "#/definitions/Version"
+    },
+    "tokens": {
+      "type": "array",
+      "description": "The list of tokens included in the list",
+      "minItems": 1,
+      "maxItems": 10000
+    },
+    "keywords": {
+      "type": "array",
+      "description": "Keywords associated with the contents of the list; may be used in list discoverability",
+      "items": {
+        "type": "string",
+        "description": "A keyword to describe the contents of the list",
+        "minLength": 1,
+        "maxLength": 20,
+        "pattern": "^[\\w ]+$",
+        "examples": ["compound", "lending", "personal tokens"]
+      },
+      "maxItems": 20,
+      "uniqueItems": true
+    },
+    "tags": {
+      "type": "object",
+      "description": "A mapping of tag identifiers to their name and description",
+      "propertyNames": {
+        "$ref": "#/definitions/TagIdentifier"
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/TagDefinition"
+      },
+      "maxProperties": 20,
+      "examples": [
+        {
+          "stablecoin": {
+            "name": "Stablecoin",
+            "description": "A token with value pegged to another asset"
+          }
+        }
+      ]
+    },
+    "logoURI": {
+      "type": "string",
+      "description": "A URI for the logo of the token list; prefer SVG or PNG of size 256x256",
+      "format": "uri",
+      "examples": ["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]
+    }
+  },
+  "if": {
+    "properties": { "schema": { "const": "aptos" } },
+    "required": ["name", "timestamp", "version", "tokens", "schema"]
+  },
+  "then": {
+    "properties": {
+      "tokens": {
+        "items": {
+          "$ref": "#/definitions/AptosTokenInfo"
+        },
+        "type": "array",
+        "description": "The list of tokens included in the list",
+        "minItems": 1,
+        "maxItems": 10000
+      }
+    }
+  },
+  "else": {
+    "properties": {
+      "tokens": {
+        "items": {
+          "$ref": "#/definitions/TokenInfo"
+        },
+        "type": "array",
+        "description": "The list of tokens included in the list",
+        "minItems": 1,
+        "maxItems": 10000
+      }
+    }
+  },
+  "required": ["name", "timestamp", "version", "tokens"]
+}