@pancakeswap/token-lists 0.0.6 → 0.0.8

package/dist/chunk-4TPCCB4K.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+exports.__async = __async;
+exports.__spreadProps = __spreadProps;
+exports.__spreadValues = __spreadValues;

package/dist/{chunk-YBVZDUCZ.mjs → chunk-COROHIJN.mjs}

@@ -1,5 +1,6 @@
+import { Token } from '@pancakeswap/swap-sdk-core';
+
 // src/wrappedTokenInfo.ts
-import { Token } from "@pancakeswap/swap-sdk-core";
 var WrappedTokenInfo = class extends Token {
   constructor(tokenInfo) {
     super(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
@@ -62,9 +63,24 @@ function getVersionUpgrade(base, update) {
   return update.patch > base.patch ? 1 /* PATCH */ : 0 /* NONE */;
 }
 
-export {
-  WrappedTokenInfo,
-  deserializeToken,
-  VersionUpgrade,
-  getVersionUpgrade
-};
+// src/filtering.ts
+function createFilterToken(search, isAddress) {
+  if (isAddress(search)) {
+    const address = search.toLowerCase();
+    return (t) => "address" in t && address === t.address.toLowerCase();
+  }
+  const lowerSearchParts = search.toLowerCase().split(/\s+/).filter((s) => s.length > 0);
+  if (lowerSearchParts.length === 0) {
+    return () => true;
+  }
+  const matchesSearch = (s) => {
+    const sParts = s.toLowerCase().split(/\s+/).filter((s_) => s_.length > 0);
+    return lowerSearchParts.every((p) => p.length === 0 || sParts.some((sp) => sp.startsWith(p) || sp.endsWith(p)));
+  };
+  return (token) => {
+    const { symbol, name } = token;
+    return Boolean(symbol && matchesSearch(symbol) || name && matchesSearch(name));
+  };
+}
+
+export { VersionUpgrade, WrappedTokenInfo, createFilterToken, deserializeToken, getVersionUpgrade };

package/dist/chunk-OGWZ2K32.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var swapSdkCore = require('@pancakeswap/swap-sdk-core');
+
+// src/wrappedTokenInfo.ts
+var WrappedTokenInfo = class extends swapSdkCore.Token {
+  constructor(tokenInfo) {
+    super(tokenInfo.chainId, tokenInfo.address, tokenInfo.decimals, tokenInfo.symbol, tokenInfo.name);
+    this.logoURI = tokenInfo.logoURI;
+  }
+  get serialize() {
+    return {
+      address: this.address,
+      chainId: this.chainId,
+      decimals: this.decimals,
+      symbol: this.symbol,
+      name: this.name,
+      projectLink: this.projectLink,
+      logoURI: this.logoURI
+    };
+  }
+};
+function deserializeToken(serializedToken) {
+  if (serializedToken.logoURI) {
+    return new WrappedTokenInfo({
+      chainId: serializedToken.chainId,
+      address: serializedToken.address,
+      decimals: serializedToken.decimals,
+      symbol: serializedToken.symbol || "Unknown",
+      name: serializedToken.name || "Unknown",
+      logoURI: serializedToken.logoURI
+    });
+  }
+  return new swapSdkCore.Token(
+    serializedToken.chainId,
+    serializedToken.address,
+    serializedToken.decimals,
+    serializedToken.symbol,
+    serializedToken.name,
+    serializedToken.projectLink
+  );
+}
+
+// src/getVersionUpgrade.ts
+var VersionUpgrade = /* @__PURE__ */ ((VersionUpgrade2) => {
+  VersionUpgrade2[VersionUpgrade2["NONE"] = 0] = "NONE";
+  VersionUpgrade2[VersionUpgrade2["PATCH"] = 1] = "PATCH";
+  VersionUpgrade2[VersionUpgrade2["MINOR"] = 2] = "MINOR";
+  VersionUpgrade2[VersionUpgrade2["MAJOR"] = 3] = "MAJOR";
+  return VersionUpgrade2;
+})(VersionUpgrade || {});
+function getVersionUpgrade(base, update) {
+  if (update.major > base.major) {
+    return 3 /* MAJOR */;
+  }
+  if (update.major < base.major) {
+    return 0 /* NONE */;
+  }
+  if (update.minor > base.minor) {
+    return 2 /* MINOR */;
+  }
+  if (update.minor < base.minor) {
+    return 0 /* NONE */;
+  }
+  return update.patch > base.patch ? 1 /* PATCH */ : 0 /* NONE */;
+}
+
+// src/filtering.ts
+function createFilterToken(search, isAddress) {
+  if (isAddress(search)) {
+    const address = search.toLowerCase();
+    return (t) => "address" in t && address === t.address.toLowerCase();
+  }
+  const lowerSearchParts = search.toLowerCase().split(/\s+/).filter((s) => s.length > 0);
+  if (lowerSearchParts.length === 0) {
+    return () => true;
+  }
+  const matchesSearch = (s) => {
+    const sParts = s.toLowerCase().split(/\s+/).filter((s_) => s_.length > 0);
+    return lowerSearchParts.every((p) => p.length === 0 || sParts.some((sp) => sp.startsWith(p) || sp.endsWith(p)));
+  };
+  return (token) => {
+    const { symbol, name } = token;
+    return Boolean(symbol && matchesSearch(symbol) || name && matchesSearch(name));
+  };
+}
+
+exports.VersionUpgrade = VersionUpgrade;
+exports.WrappedTokenInfo = WrappedTokenInfo;
+exports.createFilterToken = createFilterToken;
+exports.deserializeToken = deserializeToken;
+exports.getVersionUpgrade = getVersionUpgrade;

package/dist/getTokenList-2FAKUE6D.mjs

@@ -1,6 +1,6 @@
-import {
-  __async
-} from "./chunk-2L3ZO4UM.mjs";
+import { __async } from './chunk-2L3ZO4UM.mjs';
+import remove from 'lodash/remove';
+import Ajv from 'ajv';
 
 // ../utils/uriToHttp.ts
 function uriToHttp(uri) {
@@ -22,10 +22,6 @@ function uriToHttp(uri) {
   }
 }
 
-// react/getTokenList.ts
-import remove from "lodash/remove";
-import Ajv from "ajv";
-
 // schema/pancakeswap.json
 var pancakeswap_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
@@ -462,7 +458,5 @@ function getTokenList(listUrl) {
     throw new Error("Unrecognized list URL protocol.");
   });
 }
-export {
-  getTokenList as default,
-  tokenListValidator
-};
+
+export { getTokenList as default, tokenListValidator };

package/dist/getTokenList-YNKBKHZ3.js

@@ -0,0 +1,472 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var chunk4TPCCB4K_js = require('./chunk-4TPCCB4K.js');
+var remove = require('lodash/remove');
+var Ajv = require('ajv');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var remove__default = /*#__PURE__*/_interopDefault(remove);
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+
+// ../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+\\-%/$.]+$",
+          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
+var tokenListValidator = new Ajv__default.default({ allErrors: true }).compile(pancakeswap_default);
+function getTokenList(listUrl) {
+  return chunk4TPCCB4K_js.__async(this, null, function* () {
+    var _a, _b;
+    const urls = uriToHttp(listUrl);
+    for (let i = 0; i < urls.length; i++) {
+      const url = urls[i];
+      const isLast = i === urls.length - 1;
+      let response;
+      try {
+        response = yield fetch(url);
+      } catch (error) {
+        console.error("Failed to fetch list", listUrl, error);
+        if (isLast)
+          throw new Error(`Failed to download list ${listUrl}`);
+        continue;
+      }
+      if (!response.ok) {
+        if (isLast)
+          throw new Error(`Failed to download list ${listUrl}`);
+        continue;
+      }
+      const json = yield response.json();
+      if (json.tokens) {
+        remove__default.default(json.tokens, (token) => {
+          return token.symbol ? token.symbol.length === 0 : true;
+        });
+      }
+      if (!tokenListValidator(json)) {
+        const validationErrors = (_b = (_a = tokenListValidator.errors) == null ? void 0 : _a.reduce((memo, error) => {
+          var _a2;
+          const add = `${error.dataPath} ${(_a2 = error.message) != null ? _a2 : ""}`;
+          return memo.length > 0 ? `${memo}; ${add}` : `${add}`;
+        }, "")) != null ? _b : "unknown error";
+        throw new Error(`Token list failed validation: ${validationErrors}`);
+      }
+      return json;
+    }
+    throw new Error("Unrecognized list URL protocol.");
+  });
+}
+
+exports.default = getTokenList;
+exports.tokenListValidator = tokenListValidator;

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { SerializedToken, Token } from '@pancakeswap/swap-sdk-core';
-import { T as TokenInfo, a as TokenList, V as Version } from './types-d752b62d.js';
-export { b as Tags } from './types-d752b62d.js';
+import { T as TokenInfo, a as TokenList, V as Version } from './types-d6730d17.js';
+export { b as Tags } from './types-d6730d17.js';
 
 interface SerializedWrappedToken extends SerializedToken {
     chainId: number;
-    address: string;
+    address: `0x${string}`;
     decimals: number;
     symbol: string;
     name?: string;
@@ -47,4 +47,6 @@ declare enum VersionUpgrade {
  */
 declare function getVersionUpgrade(base: Version, update: Version): VersionUpgrade;
 
-export { SerializedWrappedToken, TokenAddressMap, TokenInfo, TokenList, Version, VersionUpgrade, WrappedTokenInfo, deserializeToken, getVersionUpgrade };
+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 };