@pancakeswap/token-lists 0.0.2

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+warning package.json: No license field
+$ tsup
+CLI Building entry: {"index":"./src/index.ts","react":"./react/index.ts"}
+CLI Using tsconfig: tsconfig.json
+CLI tsup v6.2.3
+CLI Using tsup config: /home/runner/work/pancake-frontend/pancake-frontend/packages/token-lists/tsup.config.ts
+CLI Target: node14
+ESM Build start
+CJS Build start
+ESM dist/index.mjs                 208.00 B
+ESM dist/react.mjs                 7.70 KB
+ESM dist/chunk-YBVZDUCZ.mjs        1.92 KB
+ESM dist/getTokenList-T45DK2AY.mjs 13.04 KB
+ESM ⚡️ Build success in 111ms
+CJS dist/index.js 3.11 KB
+CJS dist/react.js 25.22 KB
+CJS ⚡️ Build success in 104ms
+DTS Build start
+DTS ⚡️ Build success in 9781ms
+DTS dist/index.d.ts          1.54 KB
+DTS dist/react.d.ts          2.63 KB
+DTS dist/types-b620c9be.d.ts 1.03 KB

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @pancakeswap/token-lists
+
+## 0.0.2
+
+### Patch Changes
+
+- 68440160d: ## PancakeSwap version spec
+  Add `schema` aptos to indentify aptos version of token list
+  without schema will default be uniswap version evm validation

package/dist/chunk-YBVZDUCZ.mjs

@@ -0,0 +1,70 @@
+// 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);
+    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 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 */;
+}
+
+export {
+  WrappedTokenInfo,
+  deserializeToken,
+  VersionUpgrade,
+  getVersionUpgrade
+};

package/dist/getTokenList-T45DK2AY.mjs

@@ -0,0 +1,455 @@
+// ../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 [];
+  }
+}
+
+// react/getTokenList.ts
+import Ajv from "ajv";
+
+// 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({ allErrors: true }).compile(pancakeswap_default);
+async function getTokenList(listUrl) {
+  var _a;
+  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 = await 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 = await response.json();
+    if (!tokenListValidator(json)) {
+      const validationErrors = ((_a = tokenListValidator.errors) == null ? void 0 : _a.reduce((memo, error) => {
+        const add = `${error.dataPath} ${error.message ?? ""}`;
+        return memo.length > 0 ? `${memo}; ${add}` : `${add}`;
+      }, "")) ?? "unknown error";
+      throw new Error(`Token list failed validation: ${validationErrors}`);
+    }
+    return json;
+  }
+  throw new Error("Unrecognized list URL protocol.");
+}
+export {
+  getTokenList as default,
+  tokenListValidator
+};

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import { SerializedToken, Token } from '@pancakeswap/swap-sdk-core';
+import { T as TokenInfo, a as TokenList, V as Version } from './types-b620c9be.js';
+export { b as Tags, T as TokenInfo, a as TokenList, V as Version } from './types-b620c9be.js';
+
+interface SerializedWrappedToken extends SerializedToken {
+    chainId: number;
+    address: string;
+    decimals: number;
+    symbol: string;
+    name?: string;
+    projectLink?: string;
+    logoURI?: string;
+}
+/**
+ * Token instances created from token info.
+ */
+declare class WrappedTokenInfo extends Token {
+    readonly logoURI: string | undefined;
+    constructor(tokenInfo: TokenInfo);
+    get serialize(): SerializedWrappedToken;
+}
+declare type TokenAddressMap<TChainId extends number> = Readonly<{
+    [chainId in TChainId]: Readonly<{
+        [tokenAddress: string]: {
+            token: WrappedTokenInfo;
+            list: TokenList;
+        };
+    }>;
+}>;
+declare function deserializeToken(serializedToken: SerializedWrappedToken): Token;
+
+/**
+ * Enum describing types of version differences
+ */
+
+declare enum VersionUpgrade {
+    NONE = 0,
+    PATCH = 1,
+    MINOR = 2,
+    MAJOR = 3
+}
+/**
+ * Return the upgrade type from the base version to the update version.
+ * Note that downgrades and equivalent versions are both treated as `NONE`.
+ * @param base base list
+ * @param update update to the list
+ */
+declare function getVersionUpgrade(base: Version, update: Version): VersionUpgrade;
+
+export { SerializedWrappedToken, TokenAddressMap, VersionUpgrade, WrappedTokenInfo, deserializeToken, getVersionUpgrade };

package/dist/index.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  VersionUpgrade: () => VersionUpgrade,
+  WrappedTokenInfo: () => WrappedTokenInfo,
+  deserializeToken: () => deserializeToken,
+  getVersionUpgrade: () => getVersionUpgrade
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/wrappedTokenInfo.ts
+var import_swap_sdk_core = require("@pancakeswap/swap-sdk-core");
+var WrappedTokenInfo = class extends import_swap_sdk_core.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 import_swap_sdk_core.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 */;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VersionUpgrade,
+  WrappedTokenInfo,
+  deserializeToken,
+  getVersionUpgrade
+});