@eth-optimism/tokenlist 4.3.1 → 6.3.22

package/src/types.ts

@@ -1,33 +0,0 @@
-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

@@ -1,271 +0,0 @@
-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

@@ -1,87 +0,0 @@
-// 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

@@ -1,21 +0,0 @@
-{
-  "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

@@ -1,13 +0,0 @@
-<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

@@ -1,16 +0,0 @@
-{
-  "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

@@ -1,12 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,27 +0,0 @@
-{
-  "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/**/*"
-  ]
-}