@eth-optimism/tokenlist 4.3.1 → 6.3.21

package/src/abi.ts

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

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

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

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

@@ -1,71 +0,0 @@
-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 }),
-}

package/src/schemas.ts

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