@uniswap/token-list-bridge-utils 0.1.1-beta.1

package/src/arb-token-lists/src/lib/token_list_gen.ts

@@ -0,0 +1,334 @@
+import { minVersionBump, nextVersion, TokenList, VersionUpgrade } from '@uniswap/token-lists';
+import { constants as arbConstants } from "arb-ts";
+import { constants, utils } from 'ethers';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { getAllTokens, getTokens } from './graph';
+import { getNetworkConfig } from './instantiate_bridge';
+import { ArbTokenInfo, ArbTokenList, EtherscanList, GraphTokenResult } from './types';
+import {
+  getL2TokenAddressesFromL1,
+  getL2TokenAddressesFromL2,
+  getLogoUri,
+  getTokenListObj, isArbTokenList, listNameToArbifiedListName, listNameToFileName, removeInvalidTokensFromList, sanitizeString, validateTokenListWithErrorThrowing
+} from './utils';
+
+
+export interface ArbificationOptions {
+  overwriteCurrentList: boolean;
+}
+
+export interface L2ToL1GatewayAddresses {
+  [contractAddress: string]: string;
+}
+
+// TODO: read these values from the gateway or a subgraph
+const l2ToL1GatewayAddresses: L2ToL1GatewayAddresses = {
+  // L2 ERC20 Gateway	mainnet
+  '0x09e9222e96e7b4ae2a407b98d48e330053351eee':
+    '0xa3A7B6F88361F48403514059F1F16C8E78d60EeC',
+  // L2 Arb-Custom Gateway	mainnet
+    '0x096760f208390250649e3e8763348e783aef5562':
+    '0xcEe284F754E854890e311e3280b767F80797180d',
+  // L2 weth mainnet
+  '0x6c411ad3e74de3e7bd422b94a27770f5b86c623b':
+    '0xd92023E9d9911199a6711321D1277285e6d4e2db',
+  // L2 dai gateway mainnet
+  '0x467194771dae2967aef3ecbedd3bf9a310c76c65':
+    '0xd3b5b60020504bc3489d6949d545893982ba3011',
+  // L2 ERC20 Gateway	rinkeby
+    "0x195c107f3f75c4c93eba7d9a1312f19305d6375f": "0x91169Dbb45e6804743F94609De50D511C437572E",
+  // L2 Arb-Custom Gateway	rinkeby
+    "0x9b014455acc2fe90c52803849d0002aeec184a06":"0x917dc9a69F65dC3082D518192cd3725E1Fa96cA2",
+  // L2 Weth Gateway rinkeby
+    "0xf94bc045c4e926cc0b34e8d1c41cd7a043304ac9": "0x81d1a19cf7071732D4313c75dE8DD5b8CF697eFD",
+  // old L2 weth gateway in rinkeby? we can prob remove this
+    "0xf90eb31045d5b924900aff29344deb42eae0b087": "0x81d1a19cf7071732D4313c75dE8DD5b8CF697eFD",
+  // livepeer gateway mainnet
+  "0x6d2457a4ad276000a615295f7a80f79e48ccd318": "0x6142f1C8bBF02E6A6bd074E8d564c9A5420a0676"
+};
+
+export const generateTokenList = async (
+  l1TokenList: TokenList,
+  prevArbTokenList?: ArbTokenList,
+  options?: {
+    /**
+     * Append all tokens from the original l1TokenList to the output list.
+     */
+    includeAllL1Tokens?: boolean,
+    /**
+     * Append all unbridged tokens from original l1TokenList to the output list.
+     */
+    includeUnbridgedL1Tokens?: boolean,
+    getAllTokensInNetwork?: boolean
+  }
+) => {
+  if(options?.includeAllL1Tokens && options.includeUnbridgedL1Tokens) {
+    throw new Error("Cannot include both of AllL1Tokens and UnbridgedL1Tokens since UnbridgedL1Tokens is a subset of AllL1Tokens.")
+  }
+
+  const name = l1TokenList.name
+  const mainLogoUri = l1TokenList.logoURI
+
+  const { l1 , l2 } = await getNetworkConfig();
+
+  let tokens =
+    options && options.getAllTokensInNetwork
+      ? await getAllTokens(l2.network.chainID)
+      : await getTokens(
+          l1TokenList.tokens.map((token) => token.address.toLowerCase()),
+          l2.network.chainID
+        );
+
+  
+  const l1TokenAddresses = tokens.map((token:GraphTokenResult) => token.l1TokenAddr);
+  const l2AddressesFromL1 = await getL2TokenAddressesFromL1(l1TokenAddresses, l1.multiCaller, l2.network.tokenBridge.l1GatewayRouter);
+  const l2AddressesFromL2 = await getL2TokenAddressesFromL2(l1TokenAddresses, l2.multiCaller, l2.network.tokenBridge.l2GatewayRouter);
+
+  // if the l2 route hasn't been updated yet we remove the token from the bridged tokens
+  tokens = tokens.filter((t, i) => l2AddressesFromL1[i] === l2AddressesFromL2[i])
+
+  const tokenData = await l2.multiCaller.getTokenData(
+    l2AddressesFromL1.map(t => t || constants.AddressZero),
+    { name: true, decimals: true, symbol: true }
+  )
+  const logoUris: (string | undefined)[] = [];
+  for (const token of tokens) {
+    const uri = await getLogoUri(token.l1TokenAddr);
+    logoUris.push(uri);
+  }
+
+  const arbifiedTokens: {arbTokenInfo: ArbTokenInfo, l1TokenInfo: ArbTokenInfo}[] = tokens
+      .map((t, i) => ({token: t, l2Address: l2AddressesFromL2[i], tokenDatum: tokenData[i]}))
+      // it's possible that even though l2AddressesFromL1[i] === l2AddressesFromL2[i] these addresses could be the zero address
+      // this can happen if the graphql query returns an address that hasnt been bridged
+      .filter((t): t is typeof t & { l2Address: string } => t.l2Address != undefined && t.l2Address !== constants.AddressZero)
+      .map((token, i: number) => {
+    const l2GatewayAddress = token.token.joinTableEntry[0].gateway.gatewayAddr;
+    let { name:_name, decimals, symbol:_symbol } = token.tokenDatum;
+    
+    if(decimals === undefined) throw new Error(`Unexpected undefined token decimals: ${JSON.stringify(token)}`);
+
+    _name = (() => {
+      if(_name === undefined) throw new Error(`Unexpected undefined token name: ${JSON.stringify(token)}`);
+      // if token name is empty, instead set the address as the name
+      // we remove the initial 0x since the token list standard only allows up to 40 characters
+      else if(_name === "") return token.token.l1TokenAddr.substring(2)
+      // parse null terminated bytes32 strings
+      else if(_name.length === 64) return utils.parseBytes32String("0x" + _name)
+      else return _name;
+    })()
+
+    _symbol = (() => {
+      if(_symbol === undefined) throw new Error(`Unexpected undefined token symbol: ${JSON.stringify(token)}`);
+      // schema doesn't allow for empty symbols, and has a max length of 20
+      else if (_symbol === "") return _name.substring(0, Math.min(_name.length, 20));
+      // parse null terminated bytes32 strings
+      else if (_symbol.length === 64) return utils.parseBytes32String("0x" + _symbol);
+      else return _symbol;
+    })()
+
+    const name = sanitizeString(_name)
+    const symbol = sanitizeString(_symbol)
+
+    let arbTokenInfo:ArbTokenInfo = {
+      chainId: +l2.network.chainID,
+      address: token.l2Address,
+      name,
+      symbol,
+      decimals,
+      extensions: {
+        bridgeInfo: {
+          [l1.network.chainID]: {
+            tokenAddress: token.token.l1TokenAddr,
+            originBridgeAddress: l2GatewayAddress,
+            destBridgeAddress: l2ToL1GatewayAddresses[l2GatewayAddress.toLowerCase()]
+          }
+        }
+      }
+    };
+
+    const l1TokenInfo:ArbTokenInfo = {
+      chainId: +l1.network.chainID,
+      address: token.token.l1TokenAddr,
+      name,symbol,decimals,
+      extensions: {
+        bridgeInfo: {
+          [l2.network.chainID]: {
+            tokenAddress: token.l2Address,
+            originBridgeAddress: l2ToL1GatewayAddresses[l2GatewayAddress.toLowerCase()],
+            destBridgeAddress: l2GatewayAddress
+          }
+        }
+      }
+    }
+
+    if (logoUris[i]) {
+      arbTokenInfo = { ...{ logoURI: logoUris[i] }, ...arbTokenInfo };
+    } else {
+      console.log('no logo uri for ',token.token.l1TokenAddr, symbol);
+      
+    }
+
+    return { arbTokenInfo, l1TokenInfo };
+  }).filter(({arbTokenInfo}: {arbTokenInfo: ArbTokenInfo})=>{
+    return arbTokenInfo.extensions && arbTokenInfo.extensions.bridgeInfo[l1.network.chainID].originBridgeAddress !== arbConstants.DISABLED_GATEWAY 
+  })
+
+  let arbifiedTokenList = arbifiedTokens
+    .map(({arbTokenInfo}) => arbTokenInfo)
+    .sort((a, b) => (a.symbol < b.symbol ? -1 : 1));
+  const l1ArbedTokenList = arbifiedTokens.map(({l1TokenInfo}) => l1TokenInfo)
+
+  console.log(`List has ${arbifiedTokenList.length} bridged tokens`);
+
+  if(options?.includeAllL1Tokens) {
+    arbifiedTokenList = arbifiedTokenList.concat(l1ArbedTokenList)
+  } else if(options?.includeUnbridgedL1Tokens) {
+    const l1AddressesOfBridgedTokens = new Set(tokens.map((token)=> token.l1TokenAddr.toLowerCase()))
+    const unbridgedTokens = l1ArbedTokenList.filter((l1TokenInfo)=>{
+      return !l1AddressesOfBridgedTokens.has(l1TokenInfo.address.toLowerCase()) && l1TokenInfo.chainId === +l1.network.chainID
+    }).sort((a, b) => (a.symbol < b.symbol ? -1 : 1))
+    console.log(`List has ${unbridgedTokens.length} unbridged tokens`);
+
+    arbifiedTokenList = arbifiedTokenList.concat(unbridgedTokens)
+  }
+
+  const version = (()=>{
+    if(prevArbTokenList){
+      // @ts-ignore
+      let versionBump = minVersionBump(prevArbTokenList.tokens, arbifiedTokenList)
+
+      // tmp: library doesn't nicely handle patches (for extensions object)
+      if(versionBump === VersionUpgrade.PATCH){
+        versionBump = VersionUpgrade.NONE
+      }
+      return nextVersion(prevArbTokenList.version, versionBump)  
+    }
+    return  {
+      major: 1,
+      minor: 0,
+      patch: 0,
+    }
+  })()
+
+  const arbTokenList: ArbTokenList = {
+    name: listNameToArbifiedListName(name),
+    timestamp: new Date().toISOString(),
+    version,
+    tokens: arbifiedTokenList,
+    logoURI: mainLogoUri
+  };
+
+  const validationTokenList: ArbTokenList = {
+    ...arbTokenList,
+    tokens: arbTokenList.tokens
+  };
+  validateTokenListWithErrorThrowing(validationTokenList);
+
+  console.log(`Generated list with total ${arbTokenList.tokens.length} tokens`);
+  console.log('version:', version);
+  
+  return arbTokenList;
+};
+
+export const arbifyL1List = async (pathOrUrl: string) => {
+  const l1TokenList = await getTokenListObj(pathOrUrl);
+  removeInvalidTokensFromList(l1TokenList)
+  const path = process.env.PWD +
+  '/src/ArbTokenLists/' +
+  listNameToFileName(l1TokenList.name);
+  let prevArbTokenList: ArbTokenList | undefined; 
+
+  if(existsSync(path)){
+    const data = readFileSync(path)
+    console.log('Prev version of Arb List found');
+    
+    prevArbTokenList =  JSON.parse(data.toString()) as ArbTokenList
+    isArbTokenList(prevArbTokenList)
+  } 
+
+  const l1Addresses = l1TokenList.tokens.map((token) =>
+    token.address.toLowerCase()
+  );
+
+  const newList = await generateTokenList(l1TokenList, prevArbTokenList, {
+    includeAllL1Tokens: true
+  });
+
+  writeFileSync(path, JSON.stringify(newList));
+  console.log('Token list generated at', path );
+  
+};
+
+export const updateArbifiedList = async (pathOrUrl: string) => {
+  const arbTokenList = await getTokenListObj(pathOrUrl);
+  removeInvalidTokensFromList(arbTokenList)
+  const path = process.env.PWD +
+  '/src/ArbTokenLists/' +
+  listNameToFileName(arbTokenList.name);
+  let prevArbTokenList: ArbTokenList | undefined; 
+
+  if(existsSync(path)){
+    const data = readFileSync(path)
+    console.log('Prev version of Arb List found');
+    
+    prevArbTokenList =  JSON.parse(data.toString()) as ArbTokenList
+    isArbTokenList(prevArbTokenList)
+  } 
+
+  const newList = await generateTokenList(arbTokenList, prevArbTokenList, { 
+    includeAllL1Tokens: true
+  });
+
+  writeFileSync(path, JSON.stringify(newList));
+  console.log('Token list generated at', path );
+  
+};
+
+
+export const updateLogoURIs = async (path: string)=> {
+  const data = readFileSync(path)
+  const prevArbTokenList =  JSON.parse(data.toString()) as ArbTokenList
+  const tokens:any = []
+  for (let i = 0; i < prevArbTokenList.tokens.length; i++) {
+    const tokenInfo = {...prevArbTokenList.tokens[i]}
+
+    // @ts-ignore
+    const logoURI = await getLogoUri(tokenInfo.extensions.l1Address)
+    if(logoURI){
+      tokenInfo.logoURI = logoURI
+    } else {
+      console.log('not found:', tokenInfo);
+      delete  tokenInfo.logoURI 
+    }
+    tokens.push(tokenInfo) 
+  }
+
+  const newArbList = {...prevArbTokenList, ...{tokens: tokens}}
+  writeFileSync(path, JSON.stringify(newArbList));
+
+}
+
+export const arbListtoEtherscanList = (
+  arbList: ArbTokenList
+): EtherscanList => {
+  const list: EtherscanList = [];
+  arbList.tokens.forEach(tokenInfo => {
+    const { address: l2Address } = tokenInfo;
+    if (tokenInfo.extensions) {
+      // This assumes one origin chain; should be chill
+      const originChainID = Object.keys(tokenInfo.extensions.bridgeInfo)[0];
+      const { tokenAddress, originBridgeAddress, destBridgeAddress } =
+        tokenInfo.extensions.bridgeInfo[originChainID];
+      const data = {
+        l1Address: tokenAddress,
+        l2Address,
+        l1GatewayAddress: destBridgeAddress,
+        l2GatewayAddress: originBridgeAddress
+      };
+      list.push(data);
+    }
+  });
+  return list;
+};
+

package/src/arb-token-lists/src/lib/types.ts

@@ -0,0 +1,44 @@
+import { TokenInfo, TokenList } from '@uniswap/token-lists';
+
+// extensions object is allowed to be 2 levels deep, but type is out-of-date
+// https://github.com/Uniswap/token-lists/pull/67
+export interface ArbTokenInfo extends Omit<TokenInfo, 'extensions'> {
+  extensions?: {
+    bridgeInfo: {
+      [destinationChainID: string]:{
+        tokenAddress: string,
+        originBridgeAddress: string,
+        destBridgeAddress: string
+      }
+    }
+  }
+}
+
+export interface ArbTokenList extends Omit<TokenList, 'tokens'> {
+  tokens: ArbTokenInfo[];
+}
+
+
+export interface EtherscanToken {
+  l1Address: string | null,
+  l2Address: string,
+  l1GatewayAddress: string | null,
+  l2GatewayAddress: string | null
+}
+
+export type EtherscanList = EtherscanToken[]
+
+
+export interface GraphTokenResult {
+  l2Address: string | null,
+  joinTableEntry: [{
+    gateway: {
+      gatewayAddr: string
+    }
+  }],
+  l1TokenAddr: string
+}
+
+export interface GraphTokensResult {
+  tokens: GraphTokenResult[]
+}

package/src/arb-token-lists/src/lib/utils.ts

@@ -0,0 +1,285 @@
+import { schema, TokenList } from '@uniswap/token-lists'
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+import { abi, MultiCaller } from 'arb-ts'
+import axios from 'axios'
+import betterAjvErrors from 'better-ajv-errors'
+import { existsSync, readFileSync } from 'fs'
+import path from 'path'
+import { ArbTokenList } from './types'
+
+const coinGeckoBuff = readFileSync(path.resolve(__dirname, '../Assets/coingecko_uris.json'))
+const logoURIsBuff = readFileSync(path.resolve(__dirname, '../Assets/logo_uris.json'))
+
+const coingeckoURIs = JSON.parse(coinGeckoBuff.toString())
+const logoUris = JSON.parse(logoURIsBuff.toString())
+for (const address of Object.keys(logoUris)) {
+  logoUris[address.toLowerCase()] = logoUris[address]
+}
+
+export const listNameToFileName = (name: string) => {
+  const prefix = 'arbed_'
+  let fileName = name.split(' ').join('_').toLowerCase() + '.json'
+  if (!fileName.startsWith(prefix)) {
+    fileName = prefix + fileName
+  }
+  return fileName
+}
+
+export const listNameToArbifiedListName = (name: string) => {
+  const prefix = 'Arbed '
+
+  let fileName = sanitizeString(name)
+  if (!fileName.startsWith(prefix)) {
+    fileName = prefix + fileName
+  }
+  return fileName.split(' ').slice(0, 2).join(' ').slice(0, 20)
+}
+
+export const getL2TokenAddressesFromL1 = async (
+  l1TokenAddresses: string[],
+  multiCaller: MultiCaller,
+  l1GatewayRouterAddress: string,
+) => {
+  const iFace = abi.L1GatewayRouter__factory.createInterface()
+
+  return await multiCaller.multiCall(
+    l1TokenAddresses.map((addr) => ({
+      encoder: () =>
+        iFace.encodeFunctionData('calculateL2TokenAddress', [addr]),
+      decoder: (returnData: string) =>
+        iFace.decodeFunctionResult(
+          'calculateL2TokenAddress',
+          returnData,
+        )[0] as string,
+      targetAddr: l1GatewayRouterAddress,
+    })),
+  )
+}
+
+export const getL2TokenAddressesFromL2 = async (
+  l1TokenAddresses: string[],
+  multiCaller: MultiCaller,
+  l2GatewayRouterAddress: string,
+) => {
+  const iFace = abi.L2GatewayRouter__factory.createInterface()
+
+  return await multiCaller.multiCall(
+    l1TokenAddresses.map((addr) => ({
+      encoder: () =>
+        iFace.encodeFunctionData('calculateL2TokenAddress', [addr]),
+      decoder: (returnData: string) =>
+        iFace.decodeFunctionResult(
+          'calculateL2TokenAddress',
+          returnData,
+        )[0] as string,
+      targetAddr: l2GatewayRouterAddress,
+    })),
+  )
+}
+
+export const getLogoUri = async (l1TokenAddress: string) => {
+  const l1TokenAddressLCase = l1TokenAddress.toLowerCase()
+  const logoUri: string | undefined = logoUris[l1TokenAddressLCase]
+  const coinGeckoURI: string | undefined = coingeckoURIs[l1TokenAddressLCase]
+  const trustWalletUri = `https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/${l1TokenAddress}/logo.png`
+  const uris = [logoUri, coinGeckoURI, trustWalletUri].filter(
+    (x): x is string => !!x,
+  )
+
+  for (const uri of uris) {
+    try {
+      const res = await axios.get(uri)
+      if (res.status === 200) {
+        return uri
+      }
+    } catch (e) {}
+  }
+  return
+}
+export const getTokenListObjFromUrl = async (url: string) => {
+  return (await axios.get(url)).data as TokenList
+}
+export const getTokenListObjFromLocalPath = async (path: string) => {
+  return JSON.parse(readFileSync(path).toString()) as TokenList
+}
+
+export const tokenListIsValid = (tokenList: ArbTokenList | TokenList) => {
+  const ajv = new Ajv()
+  addFormats(ajv)
+  const validate = ajv.compile(schema)
+
+  const res = validate(tokenList)
+  if (validate.errors) {
+    const output = betterAjvErrors(schema, tokenList, validate.errors, {
+      indent: 2,
+    })
+    console.log(output)
+  }
+
+  return res
+}
+
+export const validateTokenListWithErrorThrowing = (
+  tokenList: ArbTokenList | TokenList,
+) => {
+  try {
+    const valid = tokenListIsValid(tokenList)
+    if (valid) return true
+    else throw new Error('Data does not conform to token list schema; not sure why')
+  } catch(e) {
+    console.log('Invalid token list:')
+    throw e
+  }
+}
+
+export const removeInvalidTokensFromList = (tokenList: ArbTokenList | TokenList):ArbTokenList | TokenList  =>{
+  let valid = tokenListIsValid(tokenList);
+  const startingTokenListLen = tokenList.tokens.length
+  
+  if (valid) {
+    return tokenList;
+  } else {
+    const tokenListCopy = JSON.parse(JSON.stringify(tokenList)) as typeof tokenList
+    console.log("Invalid token list:");
+    while (!valid && tokenListCopy.tokens.length > 0){
+      const targetToken = tokenListCopy.tokens.pop()
+      const tokenTokenIndex = tokenListCopy.tokens.length 
+      valid = tokenListIsValid(tokenListCopy);
+      if(valid){
+        console.log('Invalid token token, removing from list', targetToken);
+        
+        tokenList.tokens.splice(tokenTokenIndex , 1)
+        // pre-recursion sanity check:
+        if( tokenList.tokens.length >= startingTokenListLen ){
+          throw new Error("666: removeInvalidTokensFromList failed basic sanity check")
+        }
+        return removeInvalidTokensFromList(tokenList)
+      }
+    }
+    throw new Error('Data does not confirm to token list schema; not sure why');
+  }
+}
+
+export const getTokenListObj = async (pathOrUrl: string) => {
+  const tokenList: TokenList = await (async (pathOrUrl: string) => {
+    const localFileExists = existsSync(pathOrUrl)
+    const looksLikeUrl = isValidHttpUrl(pathOrUrl)
+    if (localFileExists) {
+      return getTokenListObjFromLocalPath(pathOrUrl)
+    } else if (looksLikeUrl) {
+      return await getTokenListObjFromUrl(pathOrUrl)
+    } else {
+      throw new Error('Could not find token list')
+    }
+  })(pathOrUrl);
+  isTokenList(tokenList)
+  return tokenList
+};
+
+// https://stackoverflow.com/questions/5717093/check-if-a-javascript-string-is-a-url
+
+function isValidHttpUrl(urlString: string) {
+  let url
+
+  try {
+    url = new URL(urlString)
+  } catch (_) {
+    return false
+  }
+
+  return url.protocol === 'http:' || url.protocol === 'https:'
+}
+
+// typeguard:
+export const isArbTokenList = (obj: any) => {
+  const expectedListKeys = ['name', 'timestamp', 'version', 'tokens']
+  const actualListKeys = new Set(Object.keys(obj))
+  if (!expectedListKeys.every((key) => actualListKeys.has(key))) {
+    throw new Error(
+      'ArbTokenList typeguard error: requried list key not included',
+    )
+  }
+  const { version, tokens } = obj
+  if (
+    !['major', 'minor', 'patch'].every((key) => {
+      return typeof version[key] === 'number'
+    })
+  ) {
+    throw new Error('ArbTokenList typeguard error: invalid version')
+  }
+  if (
+    !tokens.every((token: any) => {
+      const tokenKeys = new Set(Object.keys(token))
+      return ['chainId', 'address', 'name', 'decimals', 'symbol'].every(
+        (key) => {
+          return tokenKeys.has(key)
+        },
+      )
+    })
+  ) {
+    throw new Error('ArbTokenList typeguard error: token missing required key')
+  }
+  tokens.forEach((token: any) => {
+    if (token.extensions && token.extensions.bridgeInfo) {
+      const {
+        extensions: { bridgeInfo },
+      } = token
+      const bridges = Object.keys(bridgeInfo)
+      if (!bridges.length) {
+        throw new Error('ArbTokenList typeguard error: no bridge info found')
+      }
+      const someDestinationChain = bridges[0]
+      const {
+        tokenAddress,
+        originBridgeAddress,
+        destBridgeAddress,
+      } = bridgeInfo[someDestinationChain]
+
+      if (
+        ![tokenAddress, originBridgeAddress, destBridgeAddress].every((k) => k)
+      ) {
+        throw new Error('ArbTokenList typeguard error: missing extension')
+      }
+    }
+  })
+}
+
+
+// typeguard:
+export const isTokenList = (obj:any)=>{
+  const expectedListKeys = ['name', 'timestamp', 'version', 'tokens']
+  const actualListKeys = new Set(Object.keys(obj))
+  if(!expectedListKeys.every((key)=>actualListKeys.has(key) )){
+    throw new Error("tokenlist typeguard error: requried list key not included")
+  }
+  const { version, tokens } = obj
+  if(!['major','minor', 'patch'].every((key)=>{    
+    return typeof version[key] === 'number'
+  })){
+    throw new Error("tokenlist typeguard error: invalid version")
+  }
+  if(!tokens.every((token:any)=>{
+    const tokenKeys = new Set(Object.keys(token))
+    return ['chainId', 'address','name', 'decimals','symbol' ].every((key)=>{
+      return tokenKeys.has(key)
+    })
+  })){
+    throw new Error ("tokenlist typeguard error: token missing required key")
+  }
+}
+
+export const sanitizeString = (str: string) =>
+  str.replace(/[^ \w.'+\-%/À-ÖØ-öø-ÿ:&\[\]\(\)]/gi, '')
+
+export const excludeList = [
+  '0x0CE51000d5244F1EAac0B313a792D5a5f96931BF', //rkr
+  '0x4Dbd4fc535Ac27206064B68FfCf827b0A60BAB3f', //in
+  '0xEDA6eFE5556e134Ef52f2F858aa1e81c84CDA84b', // bad cap
+  '0xe54942077Df7b8EEf8D4e6bCe2f7B58B0082b0cd', // swapr
+  '0x282db609e787a132391eb64820ba6129fceb2695', // amy
+  '0x99d8a9c45b2eca8864373a26d1459e3dff1e17f3', // mim
+  '0x106538cc16f938776c7c180186975bca23875287', // remove once bridged (basv2)
+  '0xB4A3B0Faf0Ab53df58001804DdA5Bfc6a3D59008', // spera
+  // "0x960b236a07cf122663c4303350609a66a7b288c0", //aragon old
+].map((s) => s.toLowerCase())