@eth-optimism/tokenlist 4.3.1

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@eth-optimism/tokenlist",
+  "description": "[Optimism] token list",
+  "version": "4.3.1",
+  "main": "dist/eth-optimism-tokenlist.cjs.js",
+  "module": "dist/eth-optimism-tokenlist.esm.js",
+  "homepage": "https://github.com/ethereum-optimism/tokenlist#readme",
+  "license": "MIT",
+  "author": "roninjin10",
+  "preconstruct": {
+    "entrypoints": [
+      "index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ethereum-optimism/tokenlist.git"
+  },
+  "scripts": {
+    "validate": "ts-node ./bin/cli.ts validate",
+    "generate": "ts-node ./bin/cli.ts generate",
+    "generate:ci": "yarn generate --datadir ./data --outfile optimism.tokenlist.json",
+    "build": "preconstruct build",
+    "build:ci": "yarn generate:ci && yarn build",
+    "release": "yarn build:ci && npm publish",
+    "test": "jest --detectOpenHandles",
+    "lint:check": "eslint . --max-warnings=0",
+    "lint:fix": "eslint --fix .",
+    "lint": "yarn lint:fix && yarn lint:check",
+    "postinstall": "preconstruct dev",
+    "start-bot": "ts-node ./src/bot.ts"
+  },
+  "devDependencies": {
+    "@actions/core": "^1.4.0",
+    "@babel/eslint-parser": "^7.18.2",
+    "@eth-optimism/common-ts": "^0.6.5",
+    "@eth-optimism/contracts": "^0.5.7",
+    "@eth-optimism/core-utils": "^0.9.3",
+    "@preconstruct/cli": "^2.2.2",
+    "@types/glob": "^8.0.0",
+    "@types/jest": "^29.0.3",
+    "@types/node": "^12.0.0",
+    "@types/uuid": "^8.3.4",
+    "@typescript-eslint/eslint-plugin": "^5.26.0",
+    "@typescript-eslint/parser": "^4.26.0",
+    "@uniswap/token-lists": "^1.0.0-beta.30",
+    "ajv": "^8.11.2",
+    "ajv-formats": "^2.1.1",
+    "commander": "^9.4.0",
+    "eslint": "^8.16.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-jsdoc": "^35.1.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "eslint-plugin-react": "^7.24.0",
+    "eslint-plugin-unicorn": "^42.0.0",
+    "ethers": "^5.4.1",
+    "extract-zip": "^2.0.1",
+    "glob": "^8.0.3",
+    "jest": "^28.1.3",
+    "jsonschema": "^1.4.1",
+    "mocha": "^8.4.0",
+    "node-fetch": "^2.6.7",
+    "octokit": "^2.0.7",
+    "prettier": "^2.3.1",
+    "ts-jest": "^29.0.1",
+    "ts-mocha": "^10.0.0",
+    "ts-node": "^10.8.2",
+    "typescript": "^4.6.2",
+    "uuid": "^9.0.0"
+  },
+  "dependencies": {
+    "@babel/preset-typescript": "^7.18.6",
+    "babel": "^6.23.0"
+  }
+}

package/src/abi.ts

@@ -0,0 +1,77 @@
+export const FACTORY_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: '_l1Token',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: '_l2Token',
+        type: 'address',
+      },
+    ],
+    name: 'StandardL2TokenCreated',
+    type: 'event',
+  },
+  {
+    inputs: [
+      { internalType: 'address', name: '_l1Token', type: 'address' },
+      { internalType: 'string', name: '_name', type: 'string' },
+      { internalType: 'string', name: '_symbol', type: 'string' },
+    ],
+    name: 'createStandardL2Token',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+]
+
+export const TOKEN_ABI = [
+  {
+    constant: true,
+    inputs: [],
+    name: 'name',
+    outputs: [
+      {
+        name: '',
+        type: 'string',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'decimals',
+    outputs: [
+      {
+        name: '',
+        type: 'uint8',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: 'symbol',
+    outputs: [
+      {
+        name: '',
+        type: 'string',
+      },
+    ],
+    payable: false,
+    stateMutability: 'view',
+    type: 'function',
+  },
+]

package/src/bot.ts

@@ -0,0 +1,236 @@
+import crypto from 'crypto'
+import fs from 'fs'
+import path from 'path'
+
+import {
+  BaseServiceV2,
+  ExpressRouter,
+  validators,
+} from '@eth-optimism/common-ts'
+import { Octokit } from 'octokit'
+import extract from 'extract-zip'
+import uuid from 'uuid'
+
+import { version } from '../package.json'
+
+type TOptions = {
+  secret: string
+  pat: string
+  tempdir: string
+}
+
+type TMetrics = {}
+
+type TState = {
+  gh: Octokit
+}
+
+export class Bot extends BaseServiceV2<TOptions, TMetrics, TState> {
+  constructor(options?: Partial<TOptions>) {
+    super({
+      name: 'token-list-bot',
+      version,
+      options,
+      optionsSpec: {
+        secret: {
+          secret: true,
+          desc: 'secret used to check webhook validity',
+          validator: validators.str,
+        },
+        pat: {
+          secret: true,
+          desc: 'personal access token for github',
+          validator: validators.str,
+        },
+        tempdir: {
+          desc: 'temporary directory for storing files',
+          validator: validators.str,
+          default: './tmp',
+        },
+      },
+      metricsSpec: {
+        // ...
+      },
+    })
+  }
+
+  async init(): Promise<void> {
+    this.state.gh = new Octokit({
+      auth: this.options.pat,
+    })
+
+    // Create the temporary directory if it doesn't exist.
+    if (!fs.existsSync(this.options.tempdir)) {
+      fs.mkdirSync(this.options.tempdir)
+    }
+  }
+
+  async routes(router: ExpressRouter): Promise<void> {
+    router.post('/webhook', async (req: any, res: any) => {
+      const id = uuid.v4()
+      try {
+        // We'll need this later
+        const owner = 'ethereum-optimism'
+        const repo = 'ethereum-optimism.github.io'
+
+        // Compute the HMAC of the request body
+        const sig = Buffer.from(req.get('X-Hub-Signature-256') || '', 'utf8')
+        const hmac = crypto.createHmac('sha256', this.options.secret)
+        const digest = Buffer.from(
+          `sha256=${hmac.update(req.rawBody).digest('hex')}`,
+          'utf8'
+        )
+
+        // Check that the HMAC is valid
+        if (!crypto.timingSafeEqual(digest, sig)) {
+          return res
+            .status(200)
+            .json({ ok: false, message: 'invalid signature on workflow' })
+        }
+
+        // Make sure we're only looking at "Validate PR" workflows
+        if (req.body.workflow.name !== 'Validate PR') {
+          return res
+            .status(200)
+            .json({ ok: false, message: 'incorrect workflow' })
+        }
+
+        const artifactQueryResponse = await this.state.gh.request(
+          'GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts',
+          {
+            owner,
+            repo,
+            run_id: req.body.workflow_run.id,
+          }
+        )
+
+        if (artifactQueryResponse.data.total_count !== 1) {
+          return res
+            .status(200)
+            .json({ ok: false, message: 'incorrect number of artifacts' })
+        }
+
+        const artifact = artifactQueryResponse.data.artifacts[0]
+        if (artifact.name !== 'logs-artifact') {
+          return res
+            .status(200)
+            .json({ ok: false, message: 'incorrect artifact name' })
+        }
+
+        const artifactDownloadResponse = await this.state.gh.request(
+          'GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}',
+          {
+            owner,
+            repo,
+            artifact_id: artifact.id,
+            archive_format: 'zip',
+          }
+        )
+
+        const tempdir = path.resolve(this.options.tempdir, id)
+        if (!fs.existsSync(tempdir)) {
+          fs.mkdirSync(tempdir)
+        }
+
+        const temploc = path.resolve(tempdir, `${artifact.id}.zip`)
+        const tempout = path.resolve(tempdir, `${artifact.id}-out`)
+
+        fs.writeFileSync(
+          temploc,
+          Buffer.from(
+            new Uint8Array(artifactDownloadResponse.data as ArrayBuffer)
+          )
+        )
+
+        await extract(temploc, {
+          dir: path.resolve(tempout),
+        })
+
+        const pr = fs.readFileSync(path.resolve(tempout, 'pr.txt'), 'utf8')
+        const err = fs.readFileSync(path.resolve(tempout, 'err.txt'), 'utf8')
+        const std = fs.readFileSync(path.resolve(tempout, 'std.txt'), 'utf8')
+
+        if (err.length > 0) {
+          await this.state.gh.request(
+            'POST /repos/{owner}/{repo}/issues/{issue_number}/comments',
+            {
+              owner,
+              repo,
+              issue_number: parseInt(pr, 10),
+              body: `Got some errors while validating this PR. You will need to fix these errors before this PR can be reviewed.\n\`\`\`\n${err}\`\`\``,
+            }
+          )
+
+          return res
+            .status(200)
+            .json({ ok: true, message: 'ok with error comment on PR' })
+        }
+
+        const warns = std.split('\n').filter((line) => {
+          return line.startsWith('warning')
+        })
+
+        if (warns.length > 0) {
+          await this.state.gh.request(
+            'POST /repos/{owner}/{repo}/issues/{issue_number}/comments',
+            {
+              owner,
+              repo,
+              issue_number: parseInt(pr, 10),
+              body: `Got some warnings while validating this PR. This is usually OK but this PR will require manual review if you are unable to resolve these warnings.\n\`\`\`\n${warns.join(
+                '\n'
+              )}\n\`\`\``,
+            }
+          )
+
+          await this.state.gh.request(
+            'POST /repos/{owner}/{repo}/issues/{issue_number}/labels',
+            {
+              owner,
+              repo,
+              issue_number: parseInt(pr, 10),
+              labels: ['requires-manual-review'],
+            }
+          )
+
+          return res
+            .status(200)
+            .json({ ok: true, message: 'ok with warning comment on PR' })
+        }
+
+        // Can safely remove requires-manual-review if we got here without warnings! Sometimes the
+        // label will be on the PR because a previous iteration of the workflow had warnings but the
+        // warnings were cleared up.
+        await this.state.gh.request(
+          'DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}',
+          {
+            owner,
+            repo,
+            issue_number: parseInt(pr, 10),
+            name: 'requires-manual-review',
+          }
+        )
+
+        return res.status(200).json({ ok: true, message: 'noice!' })
+      } catch (err) {
+        this.logger.error(err)
+        return res.status(500).json({ ok: false, message: 'unexpected error' })
+      } finally {
+        // Always clean up the tempdir.
+        const tempdir = path.resolve(this.options.tempdir, id)
+        if (fs.existsSync(tempdir)) {
+          fs.rmdirSync(tempdir, { recursive: true })
+        }
+      }
+    })
+  }
+
+  async main(): Promise<void> {
+    // nothing to do here
+  }
+}
+
+if (require.main === module) {
+  const bot = new Bot()
+  bot.run()
+}

package/src/chains.ts

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers'
+
+export const NETWORK_DATA = {
+  ethereum: {
+    id: 1,
+    name: 'Mainnet',
+    provider: new ethers.providers.InfuraProvider('homestead'),
+    layer: 1,
+    pair: 'optimism',
+    bridge: '0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1',
+  },
+  optimism: {
+    id: 10,
+    name: 'Optimism',
+    provider: new ethers.providers.StaticJsonRpcProvider(
+      'https://mainnet.optimism.io'
+    ),
+    layer: 2,
+    pair: 'ethereum',
+    bridge: '0x4200000000000000000000000000000000000010',
+  },
+  kovan: {
+    id: 42,
+    name: 'Kovan',
+    provider: new ethers.providers.InfuraProvider('kovan'),
+    layer: 1,
+    pair: 'optimism-kovan',
+    bridge: '0x22F24361D548e5FaAfb36d1437839f080363982B',
+  },
+  'optimism-kovan': {
+    id: 69,
+    name: 'Optimism Kovan',
+    provider: new ethers.providers.StaticJsonRpcProvider(
+      'https://kovan.optimism.io'
+    ),
+    layer: 2,
+    pair: 'kovan',
+    bridge: '0x4200000000000000000000000000000000000010',
+  },
+  goerli: {
+    id: 5,
+    name: 'Goerli',
+    provider: new ethers.providers.InfuraProvider('goerli'),
+    layer: 1,
+    pair: 'optimism-goerli',
+    bridge: '0x636Af16bf2f682dD3109e60102b8E1A089FedAa8',
+  },
+  'optimism-goerli': {
+    id: 420,
+    name: 'Optimism Goerli',
+    provider: new ethers.providers.StaticJsonRpcProvider(
+      'https://goerli.optimism.io'
+    ),
+    layer: 2,
+    pair: 'goerli',
+    bridge: '0x4200000000000000000000000000000000000010',
+  },
+}

package/src/generate.ts

@@ -0,0 +1,69 @@
+import fs from 'fs'
+import path from 'path'
+
+import { glob } from 'glob'
+
+import { version } from '../package.json'
+import { NETWORK_DATA } from './chains'
+import { TokenData } from './types'
+
+/**
+ * Base URL where static assets are hosted.
+ */
+const BASE_URL = 'https://ethereum-optimism.github.io'
+
+/**
+ * Generates a token list from the data in the data folder.
+ *
+ * @param datadir Directory containing data files.
+ *
+ * @returns Generated token list JSON object.
+ */
+export const generate = (datadir: string) => {
+  return fs
+    .readdirSync(datadir)
+    .sort((a, b) => {
+      return a.toLowerCase().localeCompare(b.toLowerCase())
+    })
+    .map((folder) => {
+      const data: TokenData = JSON.parse(
+        fs.readFileSync(path.join(datadir, folder, 'data.json'), 'utf8')
+      )
+      const logofiles = glob.sync(
+        `${path.join(datadir, folder)}/logo.{png,svg}`
+      )
+      const logoext = logofiles[0].endsWith('png') ? 'png' : 'svg'
+      return Object.entries(data.tokens).map(([chain, token]) => {
+        return {
+          chainId: NETWORK_DATA[chain].id,
+          address: token.address,
+          name: token.overrides?.name ?? data.name,
+          symbol: token.overrides?.symbol ?? data.symbol,
+          decimals: token.overrides?.decimals ?? data.decimals,
+          logoURI: `${BASE_URL}/data/${folder}/logo.${logoext}`,
+          extensions: {
+            optimismBridgeAddress:
+              token.overrides?.bridge ?? NETWORK_DATA[chain].bridge,
+          },
+        }
+      })
+    })
+    .reduce(
+      (list, tokens) => {
+        list.tokens = list.tokens.concat(tokens)
+        return list
+      },
+      {
+        name: 'Optimism',
+        logoURI: `${BASE_URL}/optimism.svg`,
+        keywords: ['scaling', 'layer2', 'infrastructure'],
+        timestamp: new Date().toISOString(),
+        tokens: [],
+        version: {
+          major: parseInt(version.split('.')[0], 10),
+          minor: parseInt(version.split('.')[1], 10),
+          patch: parseInt(version.split('.')[2], 10),
+        },
+      }
+    )
+}

package/src/index.ts

@@ -0,0 +1,71 @@
+import _extendedList from '../optimism.tokenlist.json'
+import _defaultSymbols from '../optimism.defaulttokens.json'
+
+export interface TokenList {
+  name: string
+  logoURI: string
+  tokens: TokenListItem[]
+}
+
+export interface TokenListItem {
+  chainId: number
+  address: string
+  name: string
+  symbol: string
+  decimals: number
+  logoURI?: string
+  extensions?: {
+    optimismBridgeAddress?: string
+    ens?: string
+  }
+}
+
+export enum TokenListChoice {
+  'EXTENDED' = 'EXTENDED',
+  'DEFAULT' = 'DEFAULT',
+  'DEFAULT_DEVNET' = 'DEFAULT_DEVNET',
+  'EXTENDED_DEVNET' = 'EXTENDED_DEVNET',
+}
+
+export const extendedList = _extendedList
+
+export interface FilterOptions {
+  chainId?: number
+  filterTerm?: string
+}
+
+export const filterTokens = (
+  list: TokenList['tokens'],
+  { chainId, filterTerm }: FilterOptions = {}
+) => {
+  return (
+    list
+      // filter by chainId
+      .filter((token) => !chainId || token.chainId === chainId)
+      // filter by filterTerm
+      .filter(
+        (token) =>
+          !filterTerm ||
+          token.address.toLowerCase().includes(filterTerm.toLowerCase()) ||
+          token.symbol.toLowerCase().includes(filterTerm.toLowerCase()) ||
+          token.name.toLowerCase().includes(filterTerm.toLowerCase())
+      )
+  )
+}
+
+export const defaultSymbols = new Set(_defaultSymbols)
+
+export const defaultTokenList = {
+  ...extendedList,
+  name: 'Default Token List',
+  tokens: extendedList.tokens.filter(({ symbol }) =>
+    defaultSymbols.has(symbol)
+  ),
+}
+
+export const tokensByNetwork = {
+  1: filterTokens(extendedList.tokens, { chainId: 1 }),
+  5: filterTokens(extendedList.tokens, { chainId: 5 }),
+  10: filterTokens(extendedList.tokens, { chainId: 10 }),
+  420: filterTokens(extendedList.tokens, { chainId: 420 }),
+}