@pancakeswap/token-lists 0.0.14 → 0.0.16

package/dist/react.mjs

@@ -1,8 +1,7 @@
-import { getVersionUpgrade } from './chunk-COROHIJN.mjs';
-import { __spreadProps, __spreadValues, __async } from './chunk-2L3ZO4UM.mjs';
-import { createAction, createReducer, nanoid } from '@reduxjs/toolkit';
+import { __async, __spreadProps, __spreadValues, getVersionUpgrade } from './chunk-DC45HQOL.mjs';
+import { createAction, nanoid, createReducer } from '@reduxjs/toolkit';
 import { atom, useAtom, useAtomValue } from 'jotai';
-import { atomWithStorage, loadable } from 'jotai/utils';
+import { atomWithStorage, loadable, atomFamily } from 'jotai/utils';
 import localForage from 'localforage';
 import { useCallback } from 'react';
 
@@ -19,7 +18,560 @@ var acceptListUpdate = createAction("lists/acceptListUpdate");
 var rejectVersionUpdate = createAction("lists/rejectVersionUpdate");
 var updateListVersion = createAction("lists/updateListVersion");
 
-// react/reducer.ts
+// ../utils/uriToHttp.ts
+function uriToHttp(uri) {
+  var _a, _b;
+  const protocol = uri.split(":")[0].toLowerCase();
+  switch (protocol) {
+    case "https":
+      return [uri];
+    case "http":
+      return [`https${uri.substring(4)}`, uri];
+    case "ipfs":
+      const hash = (_a = uri.match(/^ipfs:(\/\/)?(.*)$/i)) == null ? void 0 : _a[2];
+      return [`https://cloudflare-ipfs.com/ipfs/${hash}/`, `https://ipfs.io/ipfs/${hash}/`];
+    case "ipns":
+      const name = (_b = uri.match(/^ipns:(\/\/)?(.*)$/i)) == null ? void 0 : _b[2];
+      return [`https://cloudflare-ipfs.com/ipns/${name}/`, `https://ipfs.io/ipns/${name}/`];
+    default:
+      return [];
+  }
+}
+
+// schema/pancakeswap.json
+var pancakeswap_default = {
+  $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.'+\\-%/\xC0-\xD6\xD8-\xF6\xF8-\xFF:&\\[\\]\\(\\)]+$",
+          examples: ["USD Coin"]
+        },
+        symbol: {
+          type: "string",
+          description: "The symbol for the token; must be alphanumeric",
+          pattern: "^[a-zA-Z0-9+\\-%/$.\\s]+$",
+          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.'+\\-%/\xC0-\xD6\xD8-\xF6\xF8-\xFF:&\\[\\]\\(\\)]+$",
+          examples: ["USD Coin"]
+        },
+        symbol: {
+          type: "string",
+          description: "The symbol for the token; must be alphanumeric",
+          pattern: "^[a-zA-Z0-9+\\-%/$.]+$",
+          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: 1e4
+    },
+    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: 1e4
+      }
+    }
+  },
+  else: {
+    properties: {
+      tokens: {
+        items: {
+          $ref: "#/definitions/TokenInfo"
+        },
+        type: "array",
+        description: "The list of tokens included in the list",
+        minItems: 1,
+        maxItems: 1e4
+      }
+    }
+  },
+  required: ["name", "timestamp", "version", "tokens"]
+};
+
+// react/getTokenList.ts
+function getTokenList(listUrl) {
+  return __async(this, null, function* () {
+    const urls = uriToHttp(listUrl);
+    const { default: Ajv } = yield import('ajv');
+    const validator = new Ajv({ allErrors: true }).compile(pancakeswap_default);
+    for (const [i, url] of urls.entries()) {
+      try {
+        const json = yield fetchJson(url);
+        if (!validator(json)) {
+          const preFilterErrors = validator.errors;
+          json.tokens = json.tokens.filter((token) => validator(__spreadProps(__spreadValues({}, json), { tokens: [token] })));
+          if (!validator(json)) {
+            const errors = validator.errors;
+            throw new Error(`Validation failed after filtering: ${JSON.stringify(errors)}`);
+          }
+          console.warn(`Pre-filter validation errors: ${JSON.stringify(preFilterErrors)}`);
+        }
+        return json;
+      } catch (error) {
+        return void 0;
+      }
+    }
+    throw new Error("Unrecognized list URL protocol.");
+  });
+}
+function fetchJson(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 = {
+  getItem: () => Promise.resolve(noop()),
+  setItem: () => Promise.resolve(noop()),
+  removeItem: () => Promise.resolve(noop())
+};
+var EMPTY = Symbol();
+function findTokenByAddress(state, chainId, address) {
+  var _a, _b;
+  const urls = (_a = state.activeListUrls) != null ? _a : Object.keys(state.byUrl);
+  for (const url of urls) {
+    const list = (_b = state.byUrl[url]) == null ? void 0 : _b.current;
+    const token = list == null ? void 0 : list.tokens.find((t) => t.chainId === chainId && t.address.toLowerCase() === address.toLowerCase());
+    if (token)
+      return token;
+  }
+  return void 0;
+}
+function findTokenBySymbol(state, chainId, symbol) {
+  var _a, _b;
+  const urls = (_a = state.activeListUrls) != null ? _a : Object.keys(state.byUrl);
+  for (const url of urls) {
+    const list = (_b = state.byUrl[url]) == null ? void 0 : _b.current;
+    const token = list == null ? void 0 : list.tokens.find((t) => t.chainId === chainId && t.symbol.toLowerCase() === symbol.toLowerCase());
+    if (token)
+      return token;
+  }
+  return void 0;
+}
+var createListsAtom = (storeName, reducer, initialState) => {
+  function IndexedDBStorage(dbName) {
+    if (typeof window !== "undefined") {
+      const db = localForage.createInstance({
+        name: dbName,
+        storeName
+      });
+      return {
+        getItem: (key) => __async(this, null, function* () {
+          const value = yield db.getItem(key);
+          if (value) {
+            return value;
+          }
+          return initialState;
+        }),
+        setItem: (k, v) => __async(this, null, function* () {
+          if (v === EMPTY)
+            return;
+          yield db.setItem(k, v);
+        }),
+        removeItem: db.removeItem
+      };
+    }
+    return noopStorage;
+  }
+  const listsStorageAtom = atomWithStorage("lists", EMPTY, IndexedDBStorage("lists"));
+  const defaultStateAtom = atom(
+    (get) => {
+      const value = get(loadable(listsStorageAtom));
+      if (value.state === "hasData" && value.data !== EMPTY) {
+        return value.data;
+      }
+      return initialState;
+    },
+    (get, set, action) => __async(void 0, null, function* () {
+      set(listsStorageAtom, reducer(yield get(defaultStateAtom), action));
+    })
+  );
+  const isReadyAtom = loadable(listsStorageAtom);
+  const tokenAtom = atomFamily(
+    (key) => atom((get) => findTokenByAddress(get(defaultStateAtom), key.chainId, key.address))
+  );
+  const tokenBySymbolAtom = atomFamily(
+    (key) => atom((get) => findTokenBySymbol(get(defaultStateAtom), key.chainId, key.symbol))
+  );
+  const fetchListAtom = atom(null, (get, set, url) => __async(void 0, null, function* () {
+    const state = get(defaultStateAtom);
+    const listState = state.byUrl[url];
+    if ((listState == null ? void 0 : listState.current) || (listState == null ? void 0 : listState.loadingRequestId)) {
+      return;
+    }
+    const requestId = nanoid();
+    set(defaultStateAtom, fetchTokenList.pending({ url, requestId }));
+    try {
+      const tokenList = yield getTokenList(url);
+      set(defaultStateAtom, fetchTokenList.fulfilled({ url, tokenList, requestId }));
+    } catch (error) {
+      set(defaultStateAtom, fetchTokenList.rejected({ url, requestId, errorMessage: error.message }));
+    }
+  }));
+  function useListState() {
+    return useAtom(defaultStateAtom);
+  }
+  function useListStateReady() {
+    const value = useAtomValue(isReadyAtom);
+    return value.state === "hasData" && value.data !== EMPTY;
+  }
+  return {
+    listsAtom: defaultStateAtom,
+    tokenAtom,
+    tokenBySymbolAtom,
+    fetchListAtom,
+    useListStateReady,
+    useListState
+  };
+};
 var NEW_LIST_STATE = {
   error: null,
   current: null,
@@ -143,66 +695,6 @@ var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIV
     }
   })
 );
-function noop() {
-}
-var noopStorage = {
-  getItem: () => Promise.resolve(noop()),
-  setItem: () => Promise.resolve(noop()),
-  removeItem: () => Promise.resolve(noop())
-};
-var EMPTY = Symbol();
-var createListsAtom = (storeName, reducer, initialState) => {
-  function IndexedDBStorage(dbName) {
-    if (typeof window !== "undefined") {
-      const db = localForage.createInstance({
-        name: dbName,
-        storeName
-      });
-      return {
-        getItem: (key) => __async(this, null, function* () {
-          const value = yield db.getItem(key);
-          if (value) {
-            return value;
-          }
-          return initialState;
-        }),
-        setItem: (k, v) => __async(this, null, function* () {
-          if (v === EMPTY)
-            return;
-          yield db.setItem(k, v);
-        }),
-        removeItem: db.removeItem
-      };
-    }
-    return noopStorage;
-  }
-  const listsStorageAtom = atomWithStorage("lists", EMPTY, IndexedDBStorage("lists"));
-  const defaultStateAtom = atom(
-    (get) => {
-      const value = get(loadable(listsStorageAtom));
-      if (value.state === "hasData" && value.data !== EMPTY) {
-        return value.data;
-      }
-      return initialState;
-    },
-    (get, set, action) => __async(void 0, null, function* () {
-      set(listsStorageAtom, reducer(yield get(defaultStateAtom), action));
-    })
-  );
-  const isReadyAtom = loadable(listsStorageAtom);
-  function useListState() {
-    return useAtom(defaultStateAtom);
-  }
-  function useListStateReady() {
-    const value = useAtomValue(isReadyAtom);
-    return value.state === "hasData" && value.data !== EMPTY;
-  }
-  return {
-    listsAtom: defaultStateAtom,
-    useListStateReady,
-    useListState
-  };
-};
 function useFetchListCallback(dispatch) {
   return useCallback(
     (listUrl, sendDispatch = true) => __async(this, null, function* () {
@@ -210,8 +702,10 @@ function useFetchListCallback(dispatch) {
       if (sendDispatch) {
         dispatch(fetchTokenList.pending({ requestId, url: listUrl }));
       }
-      const getTokenList = (yield import('./getTokenList-PEH2JP67.mjs')).default;
       return getTokenList(listUrl).then((tokenList) => {
+        if (!tokenList) {
+          throw new Error("Token list not found");
+        }
         if (sendDispatch) {
           dispatch(fetchTokenList.fulfilled({ url: listUrl, tokenList, requestId }));
         }
@@ -229,4 +723,4 @@ function useFetchListCallback(dispatch) {
 }
 var useFetchListCallback_default = useFetchListCallback;
 
-export { NEW_LIST_STATE, acceptListUpdate, addList, createListsAtom, createTokenListReducer, disableList, enableList, fetchTokenList, rejectVersionUpdate, removeList, updateListVersion, useFetchListCallback_default as useFetchListCallback };
+export { NEW_LIST_STATE, acceptListUpdate, addList, createListsAtom, createTokenListReducer, disableList, enableList, fetchTokenList, findTokenByAddress, findTokenBySymbol, getTokenList, rejectVersionUpdate, removeList, updateListVersion, useFetchListCallback_default as useFetchListCallback };

package/package.json

@@ -1,28 +1,28 @@
 {
   "name": "@pancakeswap/token-lists",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "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.3.0"
+    "@pancakeswap/swap-sdk-core": "1.5.0"
   },
   "peerDependencies": {
     "@reduxjs/toolkit": "^1.9.1",
-    "jotai": "^2.4.3",
+    "jotai": "2.12.5",
     "localforage": "^1.10.0",
     "react": "^18.2.0"
   },
   "devDependencies": {
     "@reduxjs/toolkit": "^1.9.1",
     "@types/react": "^18.2.21",
-    "jotai": "^2.4.3",
+    "jotai": "2.12.5",
     "localforage": "^1.10.0",
     "react": "^18.2.0",
     "tsup": "^6.7.0",
-    "@pancakeswap/utils": "6.0.9"
+    "@pancakeswap/utils": "8.0.0"
   },
   "exports": {
     ".": {