@eth-optimism/tokenlist 4.3.1

package/src/schemas.ts

@@ -0,0 +1,174 @@
+export const ADDRESS_TYPE = {
+  type: 'string',
+  minLength: 42,
+  maxLength: 42,
+}
+
+export const TOKEN_SCHEMA = {
+  type: 'object',
+  properties: {
+    address: ADDRESS_TYPE,
+    overrides: {
+      bridge: ADDRESS_TYPE,
+      name: {
+        type: 'string',
+      },
+      symbol: {
+        type: 'string',
+      },
+      decimals: {
+        type: 'integer',
+      },
+    },
+  },
+  additionalProperties: false,
+  required: ['address'],
+}
+
+export const TOKEN_DATA_SCHEMA = {
+  type: 'object',
+  properties: {
+    nonstandard: {
+      type: 'boolean',
+    },
+    nobridge: {
+      type: 'boolean',
+    },
+    name: {
+      type: 'string',
+    },
+    symbol: {
+      type: 'string',
+    },
+    decimals: {
+      type: 'integer',
+    },
+    description: {
+      type: 'string',
+      minLength: 1,
+      maxLength: 150,
+    },
+    website: {
+      type: 'string',
+      format: 'uri',
+    },
+    twitter: {
+      type: 'string',
+    },
+    tokens: {
+      oneOf: [
+        {
+          type: 'object',
+          properties: {
+            ethereum: TOKEN_SCHEMA,
+            optimism: TOKEN_SCHEMA,
+            kovan: TOKEN_SCHEMA,
+            'optimism-kovan': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['ethereum', 'optimism', 'kovan', 'optimism-kovan'],
+        },
+        {
+          type: 'object',
+          properties: {
+            ethereum: TOKEN_SCHEMA,
+            optimism: TOKEN_SCHEMA,
+            goerli: TOKEN_SCHEMA,
+            'optimism-goerli': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['ethereum', 'optimism', 'goerli', 'optimism-goerli'],
+        },
+        {
+          type: 'object',
+          properties: {
+            ethereum: TOKEN_SCHEMA,
+            optimism: TOKEN_SCHEMA,
+            kovan: TOKEN_SCHEMA,
+            'optimism-kovan': TOKEN_SCHEMA,
+            goerli: TOKEN_SCHEMA,
+            'optimism-goerli': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: [
+            'ethereum',
+            'optimism',
+            'kovan',
+            'optimism-kovan',
+            'goerli',
+            'optimism-goerli',
+          ],
+        },
+        {
+          type: 'object',
+          properties: {
+            optimism: TOKEN_SCHEMA,
+            'optimism-kovan': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['optimism', 'optimism-kovan'],
+        },
+        {
+          type: 'object',
+          properties: {
+            optimism: TOKEN_SCHEMA,
+            'optimism-goerli': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['optimism', 'optimism-goerli'],
+        },
+        {
+          type: 'object',
+          properties: {
+            optimism: TOKEN_SCHEMA,
+            'optimism-kovan': TOKEN_SCHEMA,
+            'optimism-goerli': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['optimism', 'optimism-kovan', 'optimism-goerli'],
+        },
+        {
+          type: 'object',
+          properties: {
+            ethereum: TOKEN_SCHEMA,
+            optimism: TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['ethereum', 'optimism'],
+        },
+        {
+          type: 'object',
+          properties: {
+            kovan: TOKEN_SCHEMA,
+            'optimism-kovan': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['kovan', 'optimism-kovan'],
+        },
+        {
+          type: 'object',
+          properties: {
+            goerli: TOKEN_SCHEMA,
+            'optimism-goerli': TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['goerli', 'optimism-goerli'],
+        },
+        {
+          type: 'object',
+          properties: {
+            optimism: TOKEN_SCHEMA,
+          },
+          additionalProperties: false,
+          required: ['optimism'],
+        },
+      ],
+    },
+  },
+  additionalProperties: false,
+  required: ['name', 'symbol', 'decimals', 'tokens', 'description', 'website'],
+}
+
+module.exports = {
+  TOKEN_DATA_SCHEMA,
+}

package/src/types.ts

@@ -0,0 +1,33 @@
+export interface Token {
+  address: string
+  overrides?: {
+    bridge?: string
+    name?: string
+    symbol?: string
+    decimals?: number
+  }
+}
+
+export interface TokenData {
+  nonstandard?: boolean
+  nobridge?: boolean
+  twitter?: string
+  name: string
+  symbol: string
+  decimals: number
+  description: string
+  website: string
+  tokens: {
+    ethereum?: Token
+    optimism?: Token
+    kovan?: Token
+    'optimism-kovan'?: Token
+    goerli?: Token
+    'optimism-goerli'?: Token
+  }
+}
+
+export interface ValidationResult {
+  type: 'error' | 'warning'
+  message: string
+}

package/src/validate.ts

@@ -0,0 +1,271 @@
+import fs from 'fs'
+import path from 'path'
+import { URLSearchParams } from 'url'
+
+import { glob } from 'glob'
+import fetch from 'node-fetch'
+import { Validator } from 'jsonschema'
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+import { schema } from '@uniswap/token-lists'
+import { ethers } from 'ethers'
+import { sleep } from '@eth-optimism/core-utils'
+
+import { generate } from './generate'
+import { TOKEN_DATA_SCHEMA } from './schemas'
+import { NETWORK_DATA } from './chains'
+import { FACTORY_ABI, TOKEN_ABI } from './abi'
+import { TokenData, ValidationResult } from './types'
+
+/**
+ * Validates a token list data folder.
+ *
+ * @param datadir Directory containing data files.
+ * @param tokens List of tokens to run validation on.
+ *
+ * @return Validation results.
+ */
+export const validate = async (
+  datadir: string,
+  tokens: string[]
+): Promise<ValidationResult[]> => {
+  // Load data files to validate and filter for requested tokens
+  console.log(tokens)
+  const folders = fs
+    .readdirSync(datadir)
+    .sort((a, b) => {
+      return a.toLowerCase().localeCompare(b.toLowerCase())
+    })
+    .filter((folder) => {
+      return !tokens || tokens.includes(folder)
+    })
+
+  // Load the CoinGecko tokenlist once to avoid additional requests
+  const cgret = await fetch('https://tokens.coingecko.com/uniswap/all.json')
+  const cg = await cgret.json()
+
+  const results = []
+  for (const folder of folders) {
+    // Make sure the data file exists
+    const datafile = path.join(datadir, folder, 'data.json')
+    if (!fs.existsSync(datafile)) {
+      results.push({
+        type: 'error',
+        message: `data file ${datafile} does not exist`,
+      })
+    }
+
+    // Load the data now that we know it exists
+    const data: TokenData = JSON.parse(fs.readFileSync(datafile, 'utf8'))
+
+    // Make sure ONE logo file exists
+    const logofiles = glob.sync(`${path.join(datadir, folder)}/logo.{png,svg}`)
+    if (logofiles.length !== 1) {
+      results.push({
+        type: 'error',
+        message: `${folder} has ${logofiles.length} logo files, make sure your logo is either logo.png OR logo.svg`,
+      })
+    }
+
+    // Validate the data file
+    const v = new Validator()
+    const result = v.validate(data, TOKEN_DATA_SCHEMA as any)
+    if (!result.valid) {
+      for (const error of result.errors) {
+        results.push({
+          type: 'error',
+          message: `${folder}: ${error.property}: ${error.message}`,
+        })
+      }
+
+      // Since the data file is invalid, we can't continue validating the rest of the files
+      continue
+    }
+
+    // Validate each token configuration
+    for (const [chain, token] of Object.entries(data.tokens)) {
+      // Check to make sure the website will load
+      for (let i = 0; i < 5; i++) {
+        try {
+          await fetch(data.website)
+          break
+        } catch (err) {
+          if (i < 4) {
+            await sleep(5000)
+          } else {
+            results.push({
+              type: 'error',
+              message: `${folder} on chain ${chain} website did not load`,
+            })
+          }
+        }
+      }
+
+      // Validate any standard tokens
+      if (folder !== 'ETH' && data.nonstandard !== true) {
+        const contract = new ethers.Contract(
+          token.address,
+          TOKEN_ABI,
+          NETWORK_DATA[chain].provider
+        )
+
+        // Check that the token exists on this chain
+        if ((await contract.provider.getCode(token.address)) === '0x') {
+          results.push({
+            type: 'error',
+            message: `${folder} on chain ${chain} token ${token.address} does not exist`,
+          })
+        }
+
+        // Check that the token has the correct decimals
+        if (token.overrides?.decimals === undefined) {
+          try {
+            if (data.decimals !== (await contract.decimals())) {
+              results.push({
+                type: 'error',
+                message: `${folder} on chain ${chain} token ${token.address} has incorrect decimals`,
+              })
+            }
+          } catch (err) {
+            results.push({
+              type: 'error',
+              message: `${folder} on chain ${chain} token ${token.address} failed to get decimals`,
+            })
+          }
+        } else {
+          results.push({
+            type: 'warning',
+            message: `${folder} on chain ${chain} token ${token.address} has overridden decimals`,
+          })
+        }
+
+        // Check that the token has the correct symbol
+        if (token.overrides?.symbol === undefined) {
+          try {
+            if (data.symbol !== (await contract.symbol())) {
+              results.push({
+                type: 'error',
+                message: `${folder} on chain ${chain} token ${token.address} has incorrect symbol`,
+              })
+            }
+          } catch (err) {
+            results.push({
+              type: 'error',
+              message: `${folder} on chain ${chain} token ${token.address} failed to get symbol`,
+            })
+          }
+        } else {
+          results.push({
+            type: 'warning',
+            message: `${folder} on chain ${chain} token ${token.address} has overridden symbol`,
+          })
+        }
+
+        // Check that the token has the correct name
+        if (token.overrides?.name === undefined) {
+          try {
+            if (data.name !== (await contract.name())) {
+              results.push({
+                type: 'error',
+                message: `${folder} on chain ${chain} token ${token.address} has incorrect name`,
+              })
+            }
+          } catch (err) {
+            results.push({
+              type: 'error',
+              message: `${folder} on chain ${chain} token ${token.address} failed to get name`,
+            })
+          }
+        } else {
+          results.push({
+            type: 'warning',
+            message: `${folder} on chain ${chain} token ${token.address} has overridden name`,
+          })
+        }
+
+        // Check that the Ethereum token exists in the CG token list
+        if (chain === 'ethereum') {
+          const found = cg.tokens.find((t) => {
+            return t.address.toLowerCase() === token.address.toLowerCase()
+          })
+
+          // Trigger manual review if the Ethereum token is not in the CG token list
+          if (!found) {
+            results.push({
+              type: 'warning',
+              message: `${folder} on chain ${chain} token ${token.address} not found on CoinGecko token list`,
+            })
+          }
+        }
+
+        if (chain.startsWith('optimism')) {
+          const factory = new ethers.Contract(
+            '0x4200000000000000000000000000000000000012',
+            FACTORY_ABI,
+            NETWORK_DATA[chain].provider
+          )
+
+          const events = await factory.queryFilter(
+            factory.filters.StandardL2TokenCreated(undefined, token.address)
+          )
+
+          // Trigger review if not created by standard token factory.
+          if (events.length === 0) {
+            results.push({
+              type: 'warning',
+              message: `${folder} on chain ${chain} token ${token.address} not created by standard token factory`,
+            })
+          }
+        } else {
+          // Make sure the token is verified on Etherscan.
+          // Etherscan API is heavily rate limited, so sleep for 1s to avoid errors.
+          await sleep(1000)
+          const { qResult } = await (
+            await fetch(
+              `https://api${
+                chain === 'ethereum' ? '' : `-${chain}`
+              }.etherscan.io/api?` +
+                new URLSearchParams({
+                  module: 'contract',
+                  action: 'getsourcecode',
+                  address: token.address,
+                  apikey: process.env.ETHERSCAN_API_KEY,
+                })
+            )
+          ).json()
+
+          // Trigger review if code not verified on Etherscan
+          if (qResult[0].ABI === 'Contract source code not verified') {
+            results.push({
+              type: 'warning',
+              message: `${folder} on chain ${chain} token ${token.address} code not verified on Etherscan`,
+            })
+          }
+        }
+      } else {
+        results.push({
+          type: 'warning',
+          message: `${folder} on chain ${chain} token ${token.address} is a nonstandard token`,
+        })
+      }
+    }
+  }
+
+  // Verify that the final generated token list is valid
+  const list = generate(datadir)
+  const ajv = new Ajv({ allErrors: true, verbose: true })
+  addFormats(ajv)
+  const validator = ajv.compile(schema)
+  if (!validator(list)) {
+    results.push({
+      type: 'error',
+      message: `final token list is invalid: ${JSON.stringify(
+        validator.errors,
+        null,
+        2
+      )}`,
+    })
+  }
+
+  return results
+}

package/tests/__snapshots__/generate.test.ts.snap

@@ -0,0 +1,87 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`'generate' script parse data dir and compile correct token list 1`] = `
+Object {
+  "keywords": Array [
+    "scaling",
+    "layer2",
+    "infrastructure",
+  ],
+  "logoURI": "https://ethereum-optimism.github.io/optimism.svg",
+  "name": "Optimism",
+  "timestamp": "2022-08-17T17:00:00.000Z",
+  "tokens": Array [
+    Object {
+      "address": "0x0000000000000000000000000000000000000000",
+      "chainId": 1,
+      "decimals": 18,
+      "extensions": Object {
+        "optimismBridgeAddress": "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1",
+      },
+      "logoURI": "https://ethereum-optimism.github.io/data/ETH/logo.svg",
+      "name": "Ether",
+      "symbol": "ETH",
+    },
+    Object {
+      "address": "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000",
+      "chainId": 10,
+      "decimals": 18,
+      "extensions": Object {
+        "optimismBridgeAddress": "0x4200000000000000000000000000000000000010",
+      },
+      "logoURI": "https://ethereum-optimism.github.io/data/ETH/logo.svg",
+      "name": "Ether",
+      "symbol": "ETH",
+    },
+    Object {
+      "address": "0x0000000000000000000000000000000000000000",
+      "chainId": 42,
+      "decimals": 18,
+      "extensions": Object {
+        "optimismBridgeAddress": "0x22F24361D548e5FaAfb36d1437839f080363982B",
+      },
+      "logoURI": "https://ethereum-optimism.github.io/data/ETH/logo.svg",
+      "name": "Ether",
+      "symbol": "ETH",
+    },
+    Object {
+      "address": "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000",
+      "chainId": 69,
+      "decimals": 18,
+      "extensions": Object {
+        "optimismBridgeAddress": "0x4200000000000000000000000000000000000010",
+      },
+      "logoURI": "https://ethereum-optimism.github.io/data/ETH/logo.svg",
+      "name": "Ether",
+      "symbol": "ETH",
+    },
+    Object {
+      "address": "0x4200000000000000000000000000000000000042",
+      "chainId": 10,
+      "decimals": 18,
+      "extensions": Object {
+        "optimismBridgeAddress": "0x4200000000000000000000000000000000000010",
+      },
+      "logoURI": "https://ethereum-optimism.github.io/data/OP/logo.png",
+      "name": "Optimism",
+      "symbol": "OP",
+    },
+    Object {
+      "address": "0x4200000000000000000000000000000000000042",
+      "chainId": 69,
+      "decimals": 18,
+      "extensions": Object {
+        "optimismBridgeAddress": "0x4200000000000000000000000000000000000010",
+      },
+      "logoURI": "https://ethereum-optimism.github.io/data/OP/logo.png",
+      "name": "Optimism",
+      "symbol": "OP",
+    },
+  ],
+  "version": Object {
+    "major": 4,
+    "minor": 3,
+    "patch": Any<Number>,
+  },
+}
+`;

package/tests/data/ETH/data.json

@@ -0,0 +1,21 @@
+{
+  "name": "Ether",
+  "symbol": "ETH",
+  "decimals": 18,
+  "description": "Ethereum",
+  "website": "https://ethereum.org",
+  "tokens": {
+    "ethereum": {
+      "address": "0x0000000000000000000000000000000000000000"
+    },
+    "optimism": {
+      "address": "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000"
+    },
+    "kovan": {
+      "address": "0x0000000000000000000000000000000000000000"
+    },
+    "optimism-kovan": {
+      "address": "0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000"
+    }
+  }
+}

package/tests/data/ETH/logo.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="2500" height="2500" viewBox="0 0 32 32">
+  <g fill="none" fill-rule="evenodd">
+    <circle cx="16" cy="16" r="16" fill="#627EEA"/>
+    <g fill="#FFF" fill-rule="nonzero">
+      <path fill-opacity=".602" d="M16.498 4v8.87l7.497 3.35z"/>
+      <path d="M16.498 4L9 16.22l7.498-3.35z"/>
+      <path fill-opacity=".602" d="M16.498 21.968v6.027L24 17.616z"/>
+      <path d="M16.498 27.995v-6.028L9 17.616z"/>
+      <path fill-opacity=".2" d="M16.498 20.573l7.497-4.353-7.497-3.348z"/>
+      <path fill-opacity=".602" d="M9 16.22l7.498 4.353v-7.701z"/>
+    </g>
+  </g>
+</svg>

package/tests/data/OP/data.json

@@ -0,0 +1,16 @@
+{
+  "name": "Optimism",
+  "symbol": "OP",
+  "decimals": 18,
+  "nobridge": true,
+  "description": "Optimism",
+  "website": "https://optimism.io",
+  "tokens": {
+    "optimism": {
+      "address": "0x4200000000000000000000000000000000000042"
+    },
+    "optimism-kovan": {
+      "address": "0x4200000000000000000000000000000000000042"
+    }
+  }
+}

package/tests/defaultTokens.test.ts

@@ -0,0 +1,12 @@
+import { filterTokens, defaultTokenList, defaultSymbols } from '../src'
+
+describe('default tokens', () => {
+  it('all default tokens symbols should exist on the default token list without a typo', () => {
+    expect(defaultSymbols.size).toBeGreaterThan(0)
+    defaultSymbols.forEach((symbol) => {
+      expect(
+        filterTokens(defaultTokenList.tokens, { filterTerm: symbol }).length
+      ).toBeGreaterThan(0)
+    })
+  })
+})

package/tests/generate.test.ts

@@ -0,0 +1,20 @@
+import path from 'path'
+
+import { generate } from '../src/generate'
+
+test("'generate' script parse data dir and compile correct token list", async () => {
+  jest
+    .spyOn(path, 'resolve')
+    .mockReturnValueOnce(path.resolve(__dirname, 'data'))
+
+  const mockDate = new Date(1660755600000)
+  jest.spyOn(global, 'Date').mockImplementation(() => mockDate as any)
+
+  const tokenList = generate(path.resolve(__dirname, 'data'))
+  expect(tokenList).toMatchSnapshot({
+    timestamp: mockDate.toISOString(),
+    version: {
+      patch: expect.any(Number),
+    }
+  })
+})

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "module": "commonjs",
+    "target": "es2017",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "composite": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "noImplicitAny": false,
+    "removeComments": true,
+    "noLib": false,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "typeRoots": ["node_modules/@types"]
+  },
+  "exclude": ["node_modules/**/*", "dist"],
+  "include": [
+    "index.ts",
+    "optimism.tokenlist.json",
+    "optimism.defaulttokens.json",
+    "package.json",
+    "src/**/*",
+    "bin/**/*"
+  ]
+}