feat: Add support for hardhat-deploy (#249)

* Another stab at a good hardhat-deploy

* Testing etherscan verifications

* Fix linting

* remove artifacts

* keep old deploy script

* remove old hardhat-typechain dependency

* remove unused import

* remove kovan config

* Tweak deployment a bit

* Clean up defaults

* rename hardhat => hh

* Use mock bond manager

* Make deploy a bit more robust

* I committed my private key again. There goes my goerli eth

* and my infura api key too

* Fix lint errors

* Use strict ordering

* refactor: use helper for easy AddressManager deployments (#350)

* Clean up georgios pr

* use dotenv to manage deployer keys

* Update src/hardhat-deploy-ethers.ts
Co-authored-by: Georgios Konstantopoulos <me@gakonst.com>

* Stricter checking on address set

* add argument for sequencer address

* minor tweaks to console.log comments

* move predeploy addresses into their own file

* add small comment for clarity

* update deploy script

* fix incorrect env var in deploy script

* adding deploy.js shim to get ci to work

* simplify deployment environment vars

* temporary tweaks to get a ci run to pass

* print out deploy artifacts

* fix artifact log output format

* fix contract names in artifact log output

* add eth gateway to deploy

* add OVM_Proposer to address manager

* add some comments for clarity

* remove bytecode hash from compiler settings

* minor tweaks in response to review

* transfer address manager ownership after deploy

* explicitly attach deployer to address manager
Co-authored-by: Georgios Konstantopoulos <me@gakonst.com>

packages/contracts/.env.example

+# name of the network to deploy to e.g., kovan or mainnet
+CONTRACTS_TARGET_NETWORK=
+
+# private key for the account that will execute the deploy
+CONTRACTS_DEPLOYER_KEY=
+
+# rpc url for the node that will receive deploy transactions
+CONTRACTS_RPC_URL=

packages/contracts/.gitignore

@@ -10,3 +10,6 @@ build/
 # Coverage output
 coverage/
 coverage.json
+
+# Environment variables
+.env

packages/contracts/bin/deploy.js

 #!/usr/bin/env node
 
-const contracts = require('../build/src/contract-deployment/deploy');
-const { providers, Wallet, utils, ethers } = require('ethers');
-const { LedgerSigner } = require('@ethersproject/hardware-wallets');
-const { JsonRpcProvider } = providers;
-
-const env = process.env;
-const key = env.DEPLOYER_PRIVATE_KEY;
-const sequencerKey = env.SEQUENCER_PRIVATE_KEY;
-let SEQUENCER_ADDRESS = env.SEQUENCER_ADDRESS;
-const web3Url = env.L1_NODE_WEB3_URL || 'http://127.0.0.1:8545';
-const DEPLOY_TX_GAS_LIMIT = env.DEPLOY_TX_GAS_LIMIT || 5000000;
-const MIN_TRANSACTION_GAS_LIMIT = env.MIN_TRANSACTION_GAS_LIMIT || 50000;
-const MAX_TRANSACTION_GAS_LIMIT = env.MAX_TRANSACTION_GAS_LIMIT || 9000000;
-const MAX_GAS_PER_QUEUE_PER_EPOCH = env.MAX_GAS_PER_QUEUE_PER_EPOCH || 250000000;
-const SECONDS_PER_EPOCH = env.SECONDS_PER_EPOCH || 0;
-const WAIT_FOR_RECEIPTS = env.WAIT_FOR_RECEIPTS === 'true';
-let WHITELIST_OWNER = env.WHITELIST_OWNER;
-const WHITELIST_ALLOW_ARBITRARY_CONTRACT_DEPLOYMENT = env.WHITELIST_ALLOW_ARBITRARY_CONTRACT_DEPLOYMENT || true;
-const FORCE_INCLUSION_PERIOD_SECONDS = env.FORCE_INCLUSION_PERIOD_SECONDS || 2592000; // 30 days
-const FRAUD_PROOF_WINDOW_SECONDS = env.FRAUD_PROOF_WINDOW_SECONDS || (60 * 60 * 24 * 7); // 7 days
-const SEQUENCER_PUBLISH_WINDOW_SECONDS = env.SEQUENCER_PUBLISH_WINDOW_SECONDS || (60 * 30); // 30 min
-const CHAIN_ID = env.CHAIN_ID || 420; // layer 2 chainid
-const USE_LEDGER = env.USE_LEDGER || false;
-const ADDRESS_MANAGER_ADDRESS = env.ADDRESS_MANAGER_ADDRESS || undefined;
-const HD_PATH = env.HD_PATH || utils.defaultPath;
-const BLOCK_TIME_SECONDS = env.BLOCK_TIME_SECONDS || 15;
-const L2_CROSS_DOMAIN_MESSENGER_ADDRESS =
-  env.L2_CROSS_DOMAIN_MESSENGER_ADDRESS || '0x4200000000000000000000000000000000000007';
-let RELAYER_ADDRESS = env.RELAYER_ADDRESS || '0x0000000000000000000000000000000000000000';
-const RELAYER_PRIVATE_KEY = env.RELAYER_PRIVATE_KEY;
-
-(async () => {
-  const provider = new JsonRpcProvider(web3Url);
-  let signer;
-
-  // Use the ledger for the deployer
-  if (USE_LEDGER) {
-    signer = new LedgerSigner(provider, 'default', HD_PATH);
-  } else  {
-    if (typeof key === 'undefined')
-      throw new Error('Must pass deployer key as DEPLOYER_PRIVATE_KEY');
-    signer = new Wallet(key, provider);
+const path = require('path')
+const { spawn } = require('child_process')
+const dirtree = require('directory-tree')
+
+const main = async () => {
+  const task = spawn(path.join(__dirname, 'deploy.ts'))
+
+  await new Promise((resolve) => {
+    task.on('exit', () => {
+      resolve()
+    })
+  })
+
+  // Stuff below this line is currently required for CI to work properly. We probably want to
+  // update our CI so this is no longer necessary. But I'm adding it for backwards compat so we can
+  // get the hardhat-deploy stuff merged. Woot.
+  const nicknames = {
+    'Lib_AddressManager': 'AddressManager',
+    'mockOVM_BondManager': 'OVM_BondManager'
   }
 
-  if (SEQUENCER_ADDRESS) {
-    if (!utils.isAddress(SEQUENCER_ADDRESS))
-      throw new Error(`Invalid Sequencer Address: ${SEQUENCER_ADDRESS}`);
-  } else {
-    if (!sequencerKey)
-      throw new Error('Must pass sequencer key as SEQUENCER_PRIVATE_KEY');
-    const sequencer = new Wallet(sequencerKey, provider);
-    SEQUENCER_ADDRESS = await sequencer.getAddress();
-  }
-
-  if (typeof WHITELIST_OWNER === 'undefined')
-    WHITELIST_OWNER = signer;
-
-  // Use the address derived from RELAYER_PRIVATE_KEY if a private key
-  // is passed. Using the zero address as the relayer address will mean
-  // there is no relayer authentication.
-  if (RELAYER_PRIVATE_KEY) {
-    if (!utils.isAddress(RELAYER_ADDRESS))
-      throw new Error(`Invalid Relayer Address: ${RELAYER_ADDRESS}`);
-    const relayer = new Wallet(RELAYER_PRIVATE_KEY, provider);
-    RELAYER_ADDRESS = await relayer.getAddress();
-  }
-
-  const result = await contracts.deploy({
-    deploymentSigner: signer,
-    transactionChainConfig: {
-      forceInclusionPeriodSeconds: FORCE_INCLUSION_PERIOD_SECONDS,
-      sequencer: SEQUENCER_ADDRESS,
-      forceInclusionPeriodBlocks: Math.ceil(FORCE_INCLUSION_PERIOD_SECONDS/BLOCK_TIME_SECONDS),
-    },
-    stateChainConfig: {
-      fraudProofWindowSeconds: FRAUD_PROOF_WINDOW_SECONDS,
-      sequencerPublishWindowSeconds: SEQUENCER_PUBLISH_WINDOW_SECONDS,
-    },
-    ovmGlobalContext: {
-      ovmCHAINID: CHAIN_ID,
-      L2CrossDomainMessengerAddress: L2_CROSS_DOMAIN_MESSENGER_ADDRESS
-    },
-    l1CrossDomainMessengerConfig: {
-      relayerAddress: RELAYER_ADDRESS,
-    },
-    ovmGasMeteringConfig: {
-      minTransactionGasLimit: MIN_TRANSACTION_GAS_LIMIT,
-      maxTransactionGasLimit: MAX_TRANSACTION_GAS_LIMIT,
-      maxGasPerQueuePerEpoch: MAX_GAS_PER_QUEUE_PER_EPOCH,
-      secondsPerEpoch: SECONDS_PER_EPOCH
-    },
-    whitelistConfig: {
-      owner: WHITELIST_OWNER,
-      allowArbitraryContractDeployment: WHITELIST_ALLOW_ARBITRARY_CONTRACT_DEPLOYMENT
-    },
-    deployOverrides: {
-      gasLimit: DEPLOY_TX_GAS_LIMIT
-    },
-    waitForReceipts: WAIT_FOR_RECEIPTS,
-    addressManager: ADDRESS_MANAGER_ADDRESS,
-  });
-
-  const { failedDeployments, AddressManager } = result;
-  if (failedDeployments.length !== 0)
-    throw new Error(`Contract deployment failed: ${failedDeployments.join(',')}`);
-
-  const out = {};
-  out.AddressManager = AddressManager.address;
-  out.OVM_Sequencer = SEQUENCER_ADDRESS;
-  out.Deployer = await signer.getAddress()
-  for (const [name, contract] of Object.entries(result.contracts)) {
-    out[name] = contract.address;
-  }
-  console.log(JSON.stringify(out, null, 2));
-})().catch(err => {
-  console.log(JSON.stringify({error: err.message, stack: err.stack}, null, 2));
-  process.exit(1);
-});
+  const contracts = dirtree(
+    path.resolve(__dirname, `../deployments/custom`)
+  ).children.filter((child) => {
+    return child.extension === '.json'
+  }).reduce((contracts, child) => {
+    const contractName = child.name.replace('.json', '')
+    const artifact = require(path.resolve(__dirname, `../deployments/custom/${child.name}`))
+    contracts[nicknames[contractName] || contractName] = artifact.address
+    return contracts
+  }, {})
+
+  // We *must* console.log here because CI will pipe the output of this script into an
+  // addresses.json file. Also something we should probably remove.
+  console.log(JSON.stringify(contracts, null, 2))
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.log(
+      JSON.stringify({ error: error.message, stack: error.stack }, null, 2)
+    )
+    process.exit(1)
+  })

packages/contracts/bin/deploy.ts

+#!/usr/bin/env ts-node-script
+
+import { Wallet } from 'ethers'
+
+// Ensures that all relevant environment vars are properly set. These lines *must* come before the
+// hardhat import because importing will load the config (which relies on these vars). Necessary
+// because CI currently uses different var names than the ones we've chosen here.
+// TODO: Update CI so that we don't have to do this anymore.
+process.env.HARDHAT_NETWORK = 'custom' // "custom" here is an arbitrary name. only used for CI.
+process.env.CONTRACTS_TARGET_NETWORK = 'custom'
+process.env.CONTRACTS_DEPLOYER_KEY = process.env.DEPLOYER_PRIVATE_KEY
+process.env.CONTRACTS_RPC_URL =
+  process.env.L1_NODE_WEB3_URL || 'http://127.0.0.1:8545'
+
+import hre from 'hardhat'
+
+const main = async () => {
+  const sequencer = new Wallet(process.env.SEQUENCER_PRIVATE_KEY)
+  const deployer = new Wallet(process.env.DEPLOYER_PRIVATE_KEY)
+
+  await hre.run('deploy', {
+    l1BlockTimeSeconds: process.env.BLOCK_TIME_SECONDS,
+    ctcForceInclusionPeriodSeconds: process.env.FORCE_INCLUSION_PERIOD_SECONDS,
+    ctcMaxTransactionGasLimit: process.env.MAX_TRANSACTION_GAS_LIMIT,
+    emMinTransactionGasLimit: process.env.MIN_TRANSACTION_GAS_LIMIT,
+    emMaxtransactionGasLimit: process.env.MAX_TRANSACTION_GAS_LIMIT,
+    emMaxGasPerQueuePerEpoch: process.env.MAX_GAS_PER_QUEUE_PER_EPOCH,
+    emSecondsPerEpoch: process.env.SECONDS_PER_EPOCH,
+    emOvmChainId: process.env.CHAIN_ID,
+    sccFraudProofWindow: parseInt(process.env.FRAUD_PROOF_WINDOW_SECONDS, 10),
+    sccSequencerPublishWindow: process.env.SEQUENCER_PUBLISH_WINDOW_SECONDS,
+    ovmSequencerAddress: sequencer.address,
+    ovmProposerAddress: sequencer.address,
+    ovmRelayerAddress: sequencer.address,
+    ovmAddressManagerOwner: deployer.address,
+  })
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.log(
+      JSON.stringify({ error: error.message, stack: error.stack }, null, 2)
+    )
+    process.exit(1)
+  })

packages/contracts/deploy/000-Lib_AddressManager.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { registerAddress } from '../src/hardhat-deploy-ethers'
+import { predeploys } from '../src/predeploys'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  await deploy('Lib_AddressManager', {
+    from: deployer,
+    args: [],
+    log: true,
+  })
+
+  await registerAddress({
+    hre,
+    name: 'OVM_L2CrossDomainMessenger',
+    address: predeploys.OVM_L2CrossDomainMessenger,
+  })
+
+  await registerAddress({
+    hre,
+    name: 'OVM_DecompressionPrecompileAddress',
+    address: predeploys.OVM_SequencerEntrypoint,
+  })
+
+  await registerAddress({
+    hre,
+    name: 'OVM_Sequencer',
+    address: (hre as any).deployConfig.ovmSequencerAddress,
+  })
+
+  await registerAddress({
+    hre,
+    name: 'OVM_Proposer',
+    address: (hre as any).deployConfig.ovmProposerAddress,
+  })
+
+  await registerAddress({
+    hre,
+    name: 'OVM_L2BatchMessageRelayer',
+    address: (hre as any).deployConfig.ovmRelayerAddress,
+  })
+}
+
+deployFn.tags = ['Lib_AddressManager', 'required']
+
+export default deployFn

packages/contracts/deploy/001-OVM_ChainStorageContainer_ctc_batches.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_ChainStorageContainer:CTC:batches',
+    contract: 'OVM_ChainStorageContainer',
+    args: [Lib_AddressManager.address, 'OVM_CanonicalTransactionChain'],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_ChainStorageContainer_ctc_batches']
+
+export default deployFn

packages/contracts/deploy/002-OVM_ChainStorageContainer_ctc_queue.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_ChainStorageContainer:CTC:queue',
+    contract: 'OVM_ChainStorageContainer',
+    args: [Lib_AddressManager.address, 'OVM_CanonicalTransactionChain'],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_ChainStorageContainer_ctc_queue']
+
+export default deployFn

packages/contracts/deploy/003-OVM_ChainStorageContainer_scc_batches.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_ChainStorageContainer:SCC:batches',
+    contract: 'OVM_ChainStorageContainer',
+    args: [Lib_AddressManager.address, 'OVM_StateCommitmentChain'],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_ChainStorageContainer_scc_batches']
+
+export default deployFn

packages/contracts/deploy/004-OVM_CanonicalTransactionChain.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_CanonicalTransactionChain',
+    args: [
+      Lib_AddressManager.address,
+      (hre as any).deployConfig.ctcForceInclusionPeriodSeconds,
+      (hre as any).deployConfig.ctcForceInclusionPeriodBlocks,
+      (hre as any).deployConfig.ctcMaxTransactionGasLimit,
+    ],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_CanonicalTransactionChain']
+
+export default deployFn

packages/contracts/deploy/005-OVM_StateCommitmentChain.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_StateCommitmentChain',
+    args: [
+      Lib_AddressManager.address,
+      (hre as any).deployConfig.sccFraudProofWindow,
+      (hre as any).deployConfig.sccSequencerPublishWindow,
+    ],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_StateCommitmentChain']
+
+export default deployFn

packages/contracts/deploy/006-mockOVM_BondManager.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { getDeployedContract } from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  const result = await deploy('mockOVM_BondManager', {
+    from: deployer,
+    args: [Lib_AddressManager.address],
+    log: true,
+  })
+
+  if (!result.newlyDeployed) {
+    return
+  }
+
+  await Lib_AddressManager.setAddress('OVM_BondManager', result.address)
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['mockOVM_BondManager']
+
+export default deployFn

packages/contracts/deploy/007-OVM_L1CrossDomainMessenger.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { getDeployedContract } from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  const result = await deploy('OVM_L1CrossDomainMessenger', {
+    from: deployer,
+    args: [],
+    log: true,
+  })
+
+  if (!result.newlyDeployed) {
+    return
+  }
+
+  const OVM_L1CrossDomainMessenger = await getDeployedContract(
+    hre,
+    'OVM_L1CrossDomainMessenger',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  // NOTE: this initialization is *not* technically required (we only need to initialize the proxy)
+  // but it feels safer to initialize this anyway. Otherwise someone else could come along and
+  // initialize this.
+  await OVM_L1CrossDomainMessenger.initialize(Lib_AddressManager.address)
+
+  const libAddressManager = await OVM_L1CrossDomainMessenger.libAddressManager()
+  if (libAddressManager !== Lib_AddressManager.address) {
+    throw new Error(
+      `\n**FATAL ERROR. THIS SHOULD NEVER HAPPEN. CHECK YOUR DEPLOYMENT.**:\n` +
+        `OVM_L1CrossDomainMessenger could not be succesfully initialized.\n` +
+        `Attempted to set Lib_AddressManager to: ${Lib_AddressManager.address}\n` +
+        `Actual address after initialization: ${libAddressManager}\n` +
+        `This could indicate a compromised deployment.`
+    )
+  }
+
+  await Lib_AddressManager.setAddress(
+    'OVM_L1CrossDomainMessenger',
+    result.address
+  )
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_L1CrossDomainMessenger']
+
+export default deployFn

packages/contracts/deploy/008-Proxy__OVM_L1CrossDomainMessenger.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { getDeployedContract } from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  const result = await deploy('Proxy__OVM_L1CrossDomainMessenger', {
+    contract: 'Lib_ResolvedDelegateProxy',
+    from: deployer,
+    args: [Lib_AddressManager.address, 'OVM_L1CrossDomainMessenger'],
+    log: true,
+  })
+
+  if (!result.newlyDeployed) {
+    return
+  }
+
+  const Proxy__OVM_L1CrossDomainMessenger = await getDeployedContract(
+    hre,
+    'Proxy__OVM_L1CrossDomainMessenger',
+    {
+      signerOrProvider: deployer,
+      iface: 'OVM_L1CrossDomainMessenger',
+    }
+  )
+
+  await Proxy__OVM_L1CrossDomainMessenger.initialize(Lib_AddressManager.address)
+
+  const libAddressManager = await Proxy__OVM_L1CrossDomainMessenger.libAddressManager()
+  if (libAddressManager !== Lib_AddressManager.address) {
+    throw new Error(
+      `\n**FATAL ERROR. THIS SHOULD NEVER HAPPEN. CHECK YOUR DEPLOYMENT.**:\n` +
+        `Proxy__OVM_L1CrossDomainMessenger could not be succesfully initialized.\n` +
+        `Attempted to set Lib_AddressManager to: ${Lib_AddressManager.address}\n` +
+        `Actual address after initialization: ${libAddressManager}\n` +
+        `This could indicate a compromised deployment.`
+    )
+  }
+
+  await Lib_AddressManager.setAddress(
+    'Proxy__OVM_L1CrossDomainMessenger',
+    result.address
+  )
+}
+
+deployFn.dependencies = ['Lib_AddressManager', 'OVM_L1CrossDomainMessenger']
+deployFn.tags = ['Proxy__OVM_L1CrossDomainMessenger']
+
+export default deployFn

packages/contracts/deploy/009-OVM_ExecutionManager.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_ExecutionManager',
+    args: [
+      Lib_AddressManager.address,
+      {
+        minTransactionGasLimit: (hre as any).deployConfig
+          .emMinTransactionGasLimit,
+        maxTransactionGasLimit: (hre as any).deployConfig
+          .emMaxTransactionGasLimit,
+        maxGasPerQueuePerEpoch: (hre as any).deployConfig
+          .emMaxGasPerQueuePerEpoch,
+        secondsPerEpoch: (hre as any).deployConfig.emSecondsPerEpoch,
+      },
+      {
+        ovmCHAINID: (hre as any).deployConfig.emOvmChainId,
+      },
+    ],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_ExecutionManager']
+
+export default deployFn

packages/contracts/deploy/010-OVM_FraudVerifer.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_FraudVerifier',
+    args: [Lib_AddressManager.address],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_FraudVerifier']
+
+export default deployFn

packages/contracts/deploy/011-OVM_StateManagerFactory.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { deployAndRegister } from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  await deployAndRegister({
+    hre,
+    name: 'OVM_StateManagerFactory',
+    args: [],
+  })
+}
+
+deployFn.tags = ['OVM_FraudVerifier']
+
+export default deployFn

packages/contracts/deploy/012-OVM_StateTransitionerFactory.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_StateTransitionerFactory',
+    args: [Lib_AddressManager.address],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_StateTransitionerFactory']
+
+export default deployFn

packages/contracts/deploy/013-OVM_SafetyChecker.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { deployAndRegister } from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  await deployAndRegister({
+    hre,
+    name: 'OVM_SafetyChecker',
+    args: [],
+  })
+}
+
+deployFn.tags = ['OVM_SafetyChecker']
+
+export default deployFn

packages/contracts/deploy/014-OVM_L1MultiMessageRelayer.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import {
+  deployAndRegister,
+  getDeployedContract,
+} from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager'
+  )
+
+  await deployAndRegister({
+    hre,
+    name: 'OVM_L1MultiMessageRelayer',
+    args: [Lib_AddressManager.address],
+  })
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_L1MultiMessageRelayer']
+
+export default deployFn

packages/contracts/deploy/015-OVM_L1ETHGateway.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { getDeployedContract } from '../src/hardhat-deploy-ethers'
+import { predeploys } from '../src/predeploys'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  const result = await deploy('OVM_L1ETHGateway', {
+    from: deployer,
+    args: [],
+    log: true,
+  })
+
+  if (!result.newlyDeployed) {
+    return
+  }
+
+  const OVM_L1ETHGateway = await getDeployedContract(hre, 'OVM_L1ETHGateway', {
+    signerOrProvider: deployer,
+  })
+
+  // NOTE: this initialization is *not* technically required (we only need to initialize the proxy)
+  // but it feels safer to initialize this anyway. Otherwise someone else could come along and
+  // initialize this.
+  await OVM_L1ETHGateway.initialize(
+    Lib_AddressManager.address,
+    predeploys.OVM_ETH
+  )
+
+  const libAddressManager = await OVM_L1ETHGateway.libAddressManager()
+  if (libAddressManager !== Lib_AddressManager.address) {
+    throw new Error(
+      `\n**FATAL ERROR. THIS SHOULD NEVER HAPPEN. CHECK YOUR DEPLOYMENT.**:\n` +
+        `OVM_L1ETHGateway could not be succesfully initialized.\n` +
+        `Attempted to set Lib_AddressManager to: ${Lib_AddressManager.address}\n` +
+        `Actual address after initialization: ${libAddressManager}\n` +
+        `This could indicate a compromised deployment.`
+    )
+  }
+
+  await Lib_AddressManager.setAddress('OVM_L1ETHGateway', result.address)
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['OVM_L1ETHGateway']
+
+export default deployFn

packages/contracts/deploy/016-Proxy__OVM_L1ETHGateway.deploy.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { getDeployedContract } from '../src/hardhat-deploy-ethers'
+import { predeploys } from '../src/predeploys'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  const result = await deploy('Proxy__OVM_L1ETHGateway', {
+    contract: 'Lib_ResolvedDelegateProxy',
+    from: deployer,
+    args: [Lib_AddressManager.address, 'OVM_L1ETHGateway'],
+    log: true,
+  })
+
+  if (!result.newlyDeployed) {
+    return
+  }
+
+  const Proxy__OVM_L1ETHGateway = await getDeployedContract(
+    hre,
+    'Proxy__OVM_L1ETHGateway',
+    {
+      signerOrProvider: deployer,
+      iface: 'OVM_L1ETHGateway',
+    }
+  )
+
+  await Proxy__OVM_L1ETHGateway.initialize(
+    Lib_AddressManager.address,
+    predeploys.OVM_ETH
+  )
+
+  const libAddressManager = await Proxy__OVM_L1ETHGateway.libAddressManager()
+  if (libAddressManager !== Lib_AddressManager.address) {
+    throw new Error(
+      `\n**FATAL ERROR. THIS SHOULD NEVER HAPPEN. CHECK YOUR DEPLOYMENT.**:\n` +
+        `Proxy__OVM_L1ETHGateway could not be succesfully initialized.\n` +
+        `Attempted to set Lib_AddressManager to: ${Lib_AddressManager.address}\n` +
+        `Actual address after initialization: ${libAddressManager}\n` +
+        `This could indicate a compromised deployment.`
+    )
+  }
+
+  await Lib_AddressManager.setAddress('Proxy__OVM_L1ETHGateway', result.address)
+}
+
+deployFn.dependencies = ['Lib_AddressManager', 'OVM_L1ETHGateway']
+deployFn.tags = ['Proxy__OVM_L1ETHGateway']
+
+export default deployFn

packages/contracts/deploy/017-finalize.ts

+/* Imports: External */
+import { DeployFunction } from 'hardhat-deploy/dist/types'
+
+/* Imports: Internal */
+import { getDeployedContract } from '../src/hardhat-deploy-ethers'
+
+const deployFn: DeployFunction = async (hre) => {
+  const { deployer } = await hre.getNamedAccounts()
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  const owner = (hre as any).deployConfig.ovmAddressManagerOwner
+  const remoteOwner = await Lib_AddressManager.owner()
+  if (remoteOwner === owner) {
+    console.log(
+      `✓ Not changing owner of Lib_AddressManager because it's already correctly set`
+    )
+    return
+  }
+
+  console.log(`Transferring ownership of Lib_AddressManager to ${owner}...`)
+  const tx = await Lib_AddressManager.transferOwnership(owner)
+  await tx.wait()
+
+  const newRemoteOwner = await Lib_AddressManager.owner()
+  if (newRemoteOwner !== owner) {
+    throw new Error(
+      `\n**FATAL ERROR. THIS SHOULD NEVER HAPPEN. CHECK YOUR DEPLOYMENT.**:\n` +
+        `Could not transfer ownership of Lib_AddressManager.\n` +
+        `Attempted to set owner of Lib_AddressManager to: ${owner}\n` +
+        `Actual owner after transaction: ${newRemoteOwner}\n` +
+        `This could indicate a compromised deployment.`
+    )
+  }
+
+  console.log(`✓ Set owner of Lib_AddressManager to: ${owner}`)
+}
+
+deployFn.dependencies = ['Lib_AddressManager']
+deployFn.tags = ['finalize']
+
+export default deployFn

packages/contracts/hardhat.config.ts

 import { HardhatUserConfig } from 'hardhat/types'
 import 'solidity-coverage'
+import * as dotenv from 'dotenv'
 
 import {
   DEFAULT_ACCOUNTS_HARDHAT,
@@ -9,14 +10,22 @@ import {
 // Hardhat plugins
 import '@nomiclabs/hardhat-ethers'
 import '@nomiclabs/hardhat-waffle'
+import 'hardhat-deploy'
 import '@typechain/hardhat'
 import '@eth-optimism/plugins/hardhat/compiler'
+import './hh'
+
+// Load environment variables from .env
+dotenv.config()
 
 const config: HardhatUserConfig = {
   networks: {
     hardhat: {
       accounts: DEFAULT_ACCOUNTS_HARDHAT,
       blockGasLimit: RUN_OVM_TEST_GAS * 2,
+      live: false,
+      saveDeployments: false,
+      tags: ['local'],
     },
   },
   mocha: {
@@ -26,6 +35,9 @@ const config: HardhatUserConfig = {
     version: '0.7.6',
     settings: {
       optimizer: { enabled: true, runs: 200 },
+      metadata: {
+        bytecodeHash: 'none',
+      },
       outputSelection: {
         '*': {
           '*': ['storageLayout'],
@@ -37,6 +49,29 @@ const config: HardhatUserConfig = {
     outDir: 'build/types',
     target: 'ethers-v5',
   },
+  paths: {
+    deploy: './deploy',
+    deployments: './deployments',
+  },
+  namedAccounts: {
+    deployer: {
+      default: 0,
+    },
+  },
+}
+
+if (
+  process.env.CONTRACTS_TARGET_NETWORK &&
+  process.env.CONTRACTS_DEPLOYER_KEY &&
+  process.env.CONTRACTS_RPC_URL
+) {
+  config.networks[process.env.CONTRACTS_TARGET_NETWORK] = {
+    accounts: [process.env.CONTRACTS_DEPLOYER_KEY],
+    url: process.env.CONTRACTS_RPC_URL,
+    live: true,
+    saveDeployments: true,
+    tags: [process.env.CONTRACTS_TARGET_NETWORK],
+  }
 }
 
 export default config

packages/contracts/hh/index.ts

+import './tasks/task-deploy'

packages/contracts/hh/tasks/task-deploy.ts

+/* Imports: External */
+import { ethers } from 'ethers'
+import { task } from 'hardhat/config'
+import * as types from 'hardhat/internal/core/params/argumentTypes'
+
+const DEFAULT_L1_BLOCK_TIME_SECONDS = 15
+const DEFAULT_CTC_FORCE_INCLUSION_PERIOD_SECONDS = 60 * 60 * 24 * 30 // 30 days
+const DEFAULT_CTC_MAX_TRANSACTION_GAS_LIMIT = 9_000_000
+const DEFAULT_EM_MIN_TRANSACTION_GAS_LIMIT = 50_000
+const DEFAULT_EM_MAX_TRANSACTION_GAS_LIMIT = 9_000_000
+const DEFAULT_EM_MAX_GAS_PER_QUEUE_PER_EPOCH = 250_000_000
+const DEFAULT_EM_SECONDS_PER_EPOCH = 0
+const DEFAULT_EM_OVM_CHAIN_ID = 420
+const DEFAULT_SCC_FRAUD_PROOF_WINDOW = 60 * 60 * 24 * 7 // 7 days
+const DEFAULT_SCC_SEQUENCER_PUBLISH_WINDOW = 60 * 30 // 30 minutes
+
+task('deploy')
+  .addOptionalParam(
+    'l1BlockTimeSeconds',
+    'Number of seconds on average between every L1 block.',
+    DEFAULT_L1_BLOCK_TIME_SECONDS,
+    types.int
+  )
+  .addOptionalParam(
+    'ctcForceInclusionPeriodSeconds',
+    'Number of seconds that the sequencer has to include transactions before the L1 queue.',
+    DEFAULT_CTC_FORCE_INCLUSION_PERIOD_SECONDS,
+    types.int
+  )
+  .addOptionalParam(
+    'ctcMaxTransactionGasLimit',
+    'Max gas limit for L1 queue transactions.',
+    DEFAULT_CTC_MAX_TRANSACTION_GAS_LIMIT,
+    types.int
+  )
+  .addOptionalParam(
+    'emMinTransactionGasLimit',
+    'Minimum allowed transaction gas limit.',
+    DEFAULT_EM_MIN_TRANSACTION_GAS_LIMIT,
+    types.int
+  )
+  .addOptionalParam(
+    'emMaxTransactionGasLimit',
+    'Maximum allowed transaction gas limit.',
+    DEFAULT_EM_MAX_TRANSACTION_GAS_LIMIT,
+    types.int
+  )
+  .addOptionalParam(
+    'emMaxGasPerQueuePerEpoch',
+    'Maximum gas allowed in a given queue for each epoch.',
+    DEFAULT_EM_MAX_GAS_PER_QUEUE_PER_EPOCH,
+    types.int
+  )
+  .addOptionalParam(
+    'emSecondsPerEpoch',
+    'Number of seconds in each epoch.',
+    DEFAULT_EM_SECONDS_PER_EPOCH,
+    types.int
+  )
+  .addOptionalParam(
+    'emOvmChainId',
+    'Chain ID for the L2 network.',
+    DEFAULT_EM_OVM_CHAIN_ID,
+    types.int
+  )
+  .addOptionalParam(
+    'sccFraudProofWindow',
+    'Number of seconds until a transaction is considered finalized.',
+    DEFAULT_SCC_FRAUD_PROOF_WINDOW,
+    types.int
+  )
+  .addOptionalParam(
+    'sccSequencerPublishWindow',
+    'Number of seconds that the sequencer is exclusively allowed to post state roots.',
+    DEFAULT_SCC_SEQUENCER_PUBLISH_WINDOW,
+    types.int
+  )
+  .addOptionalParam(
+    'ovmSequencerAddress',
+    'Address of the sequencer. Must be provided or this deployment will fail.',
+    undefined,
+    types.string
+  )
+  .addOptionalParam(
+    'ovmProposerAddress',
+    'Address of the account that will propose state roots. Must be provided or this deployment will fail.',
+    undefined,
+    types.string
+  )
+  .addOptionalParam(
+    'ovmRelayerAddress',
+    'Address of the message relayer. Must be provided or this deployment will fail.',
+    undefined,
+    types.string
+  )
+  .addOptionalParam(
+    'ovmAddressManagerOwner',
+    'Address that will own the Lib_AddressManager. Must be provided or this deployment will fail.',
+    undefined,
+    types.string
+  )
+  .setAction(async (args, hre: any, runSuper) => {
+    // Necessary because hardhat doesn't let us attach non-optional parameters to existing tasks.
+    const validateAddressArg = (argName: string) => {
+      if (args[argName] === undefined) {
+        throw new Error(
+          `argument for ${argName} is required but was not provided`
+        )
+      }
+      if (!ethers.utils.isAddress(args[argName])) {
+        throw new Error(
+          `argument for ${argName} is not a valid address: ${args[argName]}`
+        )
+      }
+    }
+
+    validateAddressArg('ovmSequencerAddress')
+    validateAddressArg('ovmProposerAddress')
+    validateAddressArg('ovmRelayerAddress')
+    validateAddressArg('ovmAddressManagerOwner')
+
+    args.ctcForceInclusionPeriodBlocks = Math.floor(
+      args.ctcForceInclusionPeriodSeconds / args.l1BlockTimeSeconds
+    )
+
+    hre.deployConfig = args
+    return runSuper(args)
+  })

packages/contracts/package.json

@@ -32,7 +32,7 @@
     "test:coverage": "NODE_OPTIONS=--max_old_space_size=8192 hardhat coverage",
     "lint": "yarn lint:fix && yarn lint:check",
     "lint:check": "tslint --format stylish --project .",
-    "lint:fix": "prettier --config prettier-config.json --write \"hardhat.config.ts\" \"{src,test}/**/*.ts\"",
+    "lint:fix": "prettier --config prettier-config.json --write \"hardhat.config.ts\" \"{src,test,hh,deploy,bin}/**/*.ts\"",
     "clean": "rm -rf ./build ./artifacts ./artifacts-ovm ./cache ./cache-ovm",
     "deploy": "./bin/deploy.js",
     "serve": "./bin/serve_dump.sh"
@@ -53,6 +53,7 @@
     "@eth-optimism/dev": "^1.1.1",
     "@eth-optimism/plugins": "^1.0.0-alpha.2",
     "@eth-optimism/smock": "1.0.0-alpha.3",
+    "@ethersproject/abstract-signer": "^5.0.14",
     "@nomiclabs/hardhat-ethers": "^2.0.1",
     "@nomiclabs/hardhat-waffle": "^2.0.1",
     "@typechain/ethers-v5": "1.0.0",
@@ -62,9 +63,12 @@
     "buffer-xor": "^2.0.2",
     "chai": "^4.3.1",
     "copyfiles": "^2.3.0",
+    "directory-tree": "^2.2.7",
+    "dotenv": "^8.2.0",
     "ethereum-waffle": "^3.3.0",
     "ethers": "^5.0.31",
     "hardhat": "^2.0.8",
+    "hardhat-deploy": "^0.7.0-beta.50",
     "lodash": "^4.17.20",
     "merkle-patricia-tree": "^4.0.0",
     "merkletreejs": "^0.2.12",

packages/contracts/src/contract-dumps.ts

@@ -8,6 +8,7 @@ import { fromHexString, toHexString, remove0x } from '@eth-optimism/core-utils'
 /* Internal Imports */
 import { deploy, RollupDeployConfig } from './contract-deployment'
 import { getContractDefinition } from './contract-defs'
+import { predeploys } from './predeploys'
 
 interface StorageDump {
   [key: string]: string
@@ -160,19 +161,6 @@ export const makeStateDump = async (cfg: RollupDeployConfig): Promise<any> => {
 
   config = { ...config, ...cfg }
 
-  const predeploys = {
-    OVM_L2ToL1MessagePasser: '0x4200000000000000000000000000000000000000',
-    OVM_L1MessageSender: '0x4200000000000000000000000000000000000001',
-    OVM_DeployerWhitelist: '0x4200000000000000000000000000000000000002',
-    OVM_ECDSAContractAccount: '0x4200000000000000000000000000000000000003',
-    OVM_ProxySequencerEntrypoint: '0x4200000000000000000000000000000000000004',
-    OVM_SequencerEntrypoint: '0x4200000000000000000000000000000000000005',
-    OVM_ETH: '0x4200000000000000000000000000000000000006',
-    OVM_L2CrossDomainMessenger: '0x4200000000000000000000000000000000000007',
-    Lib_AddressManager: '0x4200000000000000000000000000000000000008',
-    ERC1820Registry: '0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24',
-  }
-
   const ovmCompiled = [
     'OVM_L2ToL1MessagePasser',
     'OVM_L2CrossDomainMessenger',

packages/contracts/src/hardhat-deploy-ethers.ts

+/* Imports: External */
+import { Contract } from 'ethers'
+import { Provider } from '@ethersproject/abstract-provider'
+import { Signer } from '@ethersproject/abstract-signer'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+
+export const registerAddress = async ({
+  hre,
+  name,
+  address,
+}): Promise<void> => {
+  // TODO: Cache these 2 across calls?
+  const { deployer } = await hre.getNamedAccounts()
+  const Lib_AddressManager = await getDeployedContract(
+    hre,
+    'Lib_AddressManager',
+    {
+      signerOrProvider: deployer,
+    }
+  )
+
+  const currentAddress = await Lib_AddressManager.getAddress(name)
+  if (address === currentAddress) {
+    console.log(
+      `✓ Not registering address for ${name} because it's already been correctly registered`
+    )
+    return
+  }
+
+  console.log(`Registering address for ${name} to ${address}...`)
+  const tx = await Lib_AddressManager.setAddress(name, address)
+  await tx.wait()
+
+  const remoteAddress = await Lib_AddressManager.getAddress(name)
+  if (remoteAddress !== address) {
+    throw new Error(
+      `\n**FATAL ERROR. THIS SHOULD NEVER HAPPEN. CHECK YOUR DEPLOYMENT.**:\n` +
+        `Call to Lib_AddressManager.setAddress(${name}) was unsuccessful.\n` +
+        `Attempted to set address to: ${address}\n` +
+        `Actual address was set to: ${remoteAddress}\n` +
+        `This could indicate a compromised deployment.`
+    )
+  }
+
+  console.log(`✓ Registered address for ${name}`)
+}
+
+export const deployAndRegister = async ({
+  hre,
+  name,
+  args,
+  contract,
+}: {
+  hre: HardhatRuntimeEnvironment
+  name: string
+  args: any[]
+  contract?: string
+}) => {
+  const { deploy } = hre.deployments
+  const { deployer } = await hre.getNamedAccounts()
+
+  const result = await deploy(name, {
+    contract,
+    from: deployer,
+    args,
+    log: true,
+  })
+
+  await hre.ethers.provider.waitForTransaction(result.transactionHash)
+
+  if (result.newlyDeployed) {
+    await registerAddress({
+      hre,
+      name,
+      address: result.address,
+    })
+  }
+}
+
+export const getDeployedContract = async (
+  hre: HardhatRuntimeEnvironment,
+  name: string,
+  options: {
+    iface?: string
+    signerOrProvider?: Signer | Provider | string
+  } = {}
+): Promise<Contract> => {
+  const deployed = await hre.deployments.get(name)
+
+  await hre.ethers.provider.waitForTransaction(deployed.receipt.transactionHash)
+
+  // Get the correct interface.
+  let iface = new hre.ethers.utils.Interface(deployed.abi)
+  if (options.iface) {
+    const factory = await hre.ethers.getContractFactory(options.iface)
+    iface = factory.interface
+  }
+
+  let signerOrProvider: Signer | Provider = hre.ethers.provider
+  if (options.signerOrProvider) {
+    if (typeof options.signerOrProvider === 'string') {
+      signerOrProvider = hre.ethers.provider.getSigner(options.signerOrProvider)
+    } else {
+      signerOrProvider = options.signerOrProvider
+    }
+  }
+
+  // Temporarily override Object.defineProperty to bypass ether's object protection.
+  const def = Object.defineProperty
+  Object.defineProperty = (obj, propName, prop) => {
+    prop.writable = true
+    return def(obj, propName, prop)
+  }
+
+  const contract = new Contract(deployed.address, iface, signerOrProvider)
+
+  // Now reset Object.defineProperty
+  Object.defineProperty = def
+
+  // Override each function call to also `.wait()` so as to simplify the deploy scripts' syntax.
+  for (const fnName of Object.keys(contract.functions)) {
+    const fn = contract[fnName].bind(contract)
+    ;(contract as any)[fnName] = async (...args: any) => {
+      const result = await fn(...args)
+      if (typeof result === 'object' && typeof result.wait === 'function') {
+        await result.wait()
+      }
+      return result
+    }
+  }
+
+  return contract
+}

packages/contracts/src/predeploys.ts

+export const predeploys = {
+  OVM_L2ToL1MessagePasser: '0x4200000000000000000000000000000000000000',
+  OVM_L1MessageSender: '0x4200000000000000000000000000000000000001',
+  OVM_DeployerWhitelist: '0x4200000000000000000000000000000000000002',
+  OVM_ECDSAContractAccount: '0x4200000000000000000000000000000000000003',
+  OVM_ProxySequencerEntrypoint: '0x4200000000000000000000000000000000000004',
+  OVM_SequencerEntrypoint: '0x4200000000000000000000000000000000000005',
+  OVM_ETH: '0x4200000000000000000000000000000000000006',
+  OVM_L2CrossDomainMessenger: '0x4200000000000000000000000000000000000007',
+  Lib_AddressManager: '0x4200000000000000000000000000000000000008',
+  ERC1820Registry: '0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24',
+}

packages/contracts/tslint.json

@@ -2,6 +2,7 @@
   "extends": "@eth-optimism/dev/tslint.json",
   "rules": {
     "array-type": false,
-    "class-name": false
+    "class-name": false,
+    "prefer-conditional-expression": false
   }
 }

packages/contracts/yarn.lock

@@ -78,7 +78,7 @@
   dependencies:
     node-fetch "^2.6.1"
 
-"@eth-optimism/smock@^1.0.0-alpha.3":
+"@eth-optimism/smock@1.0.0-alpha.3":
   version "1.0.0-alpha.3"
   resolved "https://registry.yarnpkg.com/@eth-optimism/smock/-/smock-1.0.0-alpha.3.tgz#5f3e8f137407c4c62f06aed60bac3dc282632f89"
   integrity sha512-TKqbmElCWQ0qM6qj8JajqOijZVKl47L/5v2NnEWBJERKZ6zkuFxT0Y8HtUCM3r4ZEURuXFbRxRLP/ZTrOG6axg==
@@ -156,7 +156,7 @@
     "@ethersproject/properties" ">=5.0.0-beta.131"
     "@ethersproject/strings" ">=5.0.0-beta.130"
 
-"@ethersproject/abi@5.0.12", "@ethersproject/abi@^5.0.1", "@ethersproject/abi@^5.0.10":
+"@ethersproject/abi@5.0.12", "@ethersproject/abi@^5.0.1", "@ethersproject/abi@^5.0.10", "@ethersproject/abi@^5.0.2":
   version "5.0.12"
   resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.0.12.tgz#9aebe6aedc05ce45bb6c41b06d80bd195b7de77c"
   integrity sha512-Ujr/3bwyYYjXLDQfebeiiTuvOw9XtUKM8av6YkoBeMXyGQM9GkjrQlwJMNwGTmqjATH/ZNbRgCh98GjOLiIB1Q==
@@ -212,7 +212,7 @@
     "@ethersproject/transactions" "^5.0.9"
     "@ethersproject/web" "^5.0.12"
 
-"@ethersproject/abstract-signer@5.0.13", "@ethersproject/abstract-signer@^5.0.10":
+"@ethersproject/abstract-signer@5.0.13", "@ethersproject/abstract-signer@^5.0.10", "@ethersproject/abstract-signer@^5.0.2":
   version "5.0.13"
   resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.0.13.tgz#59b4d0367d6327ec53bc269c6730c44a4a3b043c"
   integrity sha512-VBIZEI5OK0TURoCYyw0t3w+TEO4kdwnI9wvt4kqUwyxSn3YCRpXYVl0Xoe7XBR/e5+nYOi2MyFGJ3tsFwONecQ==
@@ -223,7 +223,18 @@
     "@ethersproject/logger" "^5.0.8"
     "@ethersproject/properties" "^5.0.7"
 
-"@ethersproject/address@5.0.10", "@ethersproject/address@>=5.0.0-beta.128", "@ethersproject/address@^5.0.9":
+"@ethersproject/abstract-signer@^5.0.14":
+  version "5.0.14"
+  resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.0.14.tgz#30ef912b0f86599d90fdffc65c110452e7b55cf1"
+  integrity sha512-JztBwVO7o5OHLh2vyjordlS4/1EjRyaECtc8vPdXTF1i4dXN+J0coeRoPN6ZFbBvi/YbaB6br2fvqhst1VQD/g==
+  dependencies:
+    "@ethersproject/abstract-provider" "^5.0.8"
+    "@ethersproject/bignumber" "^5.0.13"
+    "@ethersproject/bytes" "^5.0.9"
+    "@ethersproject/logger" "^5.0.8"
+    "@ethersproject/properties" "^5.0.7"
+
+"@ethersproject/address@5.0.10", "@ethersproject/address@>=5.0.0-beta.128", "@ethersproject/address@^5.0.2", "@ethersproject/address@^5.0.9":
   version "5.0.10"
   resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.0.10.tgz#2bc69fdff4408e0570471cd19dee577ab06a10d0"
   integrity sha512-70vqESmW5Srua1kMDIN6uVfdneZMaMyRYH4qPvkAXGkbicrCOsA9m01vIloA4wYiiF+HLEfL1ENKdn5jb9xiAw==
@@ -249,7 +260,7 @@
     "@ethersproject/bytes" "^5.0.9"
     "@ethersproject/properties" "^5.0.7"
 
-"@ethersproject/bignumber@5.0.14", "@ethersproject/bignumber@>=5.0.0-beta.130", "@ethersproject/bignumber@^5.0.13":
+"@ethersproject/bignumber@5.0.14", "@ethersproject/bignumber@>=5.0.0-beta.130", "@ethersproject/bignumber@^5.0.13", "@ethersproject/bignumber@^5.0.5":
   version "5.0.14"
   resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.0.14.tgz#605bc61dcbd4a8c6df8b5a7a77c0210273f3de8a"
   integrity sha512-Q4TjMq9Gg3Xzj0aeJWqJgI3tdEiPiET7Y5OtNtjTAODZ2kp4y9jMNg97zVcvPedFvGROdpGDyCI77JDFodUzOw==
@@ -258,7 +269,7 @@
     "@ethersproject/logger" "^5.0.8"
     bn.js "^4.4.0"
 
-"@ethersproject/bytes@5.0.10", "@ethersproject/bytes@>=5.0.0-beta.129", "@ethersproject/bytes@^5.0.9":
+"@ethersproject/bytes@5.0.10", "@ethersproject/bytes@>=5.0.0-beta.129", "@ethersproject/bytes@^5.0.2", "@ethersproject/bytes@^5.0.9":
   version "5.0.10"
   resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.0.10.tgz#aa49afe7491ba24ff76fa33d98677351263f9ba4"
   integrity sha512-vpu0v1LZ1j1s9kERQIMnVU69MyHEzUff7nqK9XuCU4vx+AM8n9lU2gj7jtJIvGSt9HzatK/6I6bWusI5nyuaTA==
@@ -272,7 +283,7 @@
   dependencies:
     "@ethersproject/bignumber" "^5.0.13"
 
-"@ethersproject/contracts@5.0.11", "@ethersproject/contracts@^5.0.5":
+"@ethersproject/contracts@5.0.11", "@ethersproject/contracts@^5.0.2", "@ethersproject/contracts@^5.0.5":
   version "5.0.11"
   resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.0.11.tgz#e6cc57698a05be2329cb2ca3d7e87686f95e438a"
   integrity sha512-FTUUd/6x00dYL2VufE2VowZ7h3mAyBfCQMGwI3tKDIWka+C0CunllFiKrlYCdiHFuVeMotR65dIcnzbLn72MCw==
@@ -385,7 +396,7 @@
   dependencies:
     "@ethersproject/logger" "^5.0.8"
 
-"@ethersproject/providers@5.0.23":
+"@ethersproject/providers@5.0.23", "@ethersproject/providers@^5.0.5":
   version "5.0.23"
   resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.0.23.tgz#1e26512303d60bbd557242532fdb5fa3c5d5fb73"
   integrity sha512-eJ94z2tgPaUgUmxwd3BVkIzkgkbNIkY6wRPVas04LVaBTycObQbgj794aaUu2bfk7+Bn2B/gjUZtJW1ybxh9/A==
@@ -445,7 +456,7 @@
     "@ethersproject/properties" "^5.0.7"
     elliptic "6.5.4"
 
-"@ethersproject/solidity@5.0.9":
+"@ethersproject/solidity@5.0.9", "@ethersproject/solidity@^5.0.2":
   version "5.0.9"
   resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.0.9.tgz#49100fbe9f364ac56f7ff7c726f4f3d151901134"
   integrity sha512-LIxSAYEQgLRXE3mRPCq39ou61kqP8fDrGqEeNcaNJS3aLbmAOS8MZp56uK++WsdI9hj8sNsFh78hrAa6zR9Jag==
@@ -465,7 +476,7 @@
     "@ethersproject/constants" "^5.0.8"
     "@ethersproject/logger" "^5.0.8"
 
-"@ethersproject/transactions@5.0.10", "@ethersproject/transactions@^5.0.0-beta.135", "@ethersproject/transactions@^5.0.9":
+"@ethersproject/transactions@5.0.10", "@ethersproject/transactions@^5.0.0-beta.135", "@ethersproject/transactions@^5.0.2", "@ethersproject/transactions@^5.0.9":
   version "5.0.10"
   resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.0.10.tgz#d50cafd80d27206336f80114bc0f18bc18687331"
   integrity sha512-Tqpp+vKYQyQdJQQk4M73tDzO7ODf2D42/sJOcKlDAAbdSni13v6a+31hUdo02qYXhVYwIs+ZjHnO4zKv5BNk8w==
@@ -489,7 +500,7 @@
     "@ethersproject/constants" "^5.0.8"
     "@ethersproject/logger" "^5.0.8"
 
-"@ethersproject/wallet@5.0.11":
+"@ethersproject/wallet@5.0.11", "@ethersproject/wallet@^5.0.2":
   version "5.0.11"
   resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.0.11.tgz#9891936089d1b91e22ed59f850bc344b1544bf26"
   integrity sha512-2Fg/DOvUltR7aZTOyWWlQhru+SKvq2UE3uEhXSyCFgMqDQNuc2nHXh1SHJtN65jsEbjVIppOe1Q7EQMvhmeeRw==
@@ -981,6 +992,11 @@
   resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.2.3.tgz#ef65165aea2924c9359205bf748865b8881753c0"
   integrity sha512-PijRCG/K3s3w1We6ynUKdxEc5AcuuH3NBmMDP8uvKVp6X43UY7NQlTzczakXP3DJR0F4dfNQIGjU2cUeRYs2AA==
 
+"@types/qs@^6.9.4":
+  version "6.9.5"
+  resolved "https://registry.yarnpkg.com/@types/qs/-/qs-6.9.5.tgz#434711bdd49eb5ee69d90c1d67c354a9a8ecb18b"
+  integrity sha512-/JHkVHtx/REVG0VVToGRGH2+23hsYLHdyG+GrvoUGlGAd0ErauXDyvHtRI/7H7mzLm+tBCKA7pfcpkQ1lf58iQ==
+
 "@types/resolve@^0.0.8":
   version "0.0.8"
   resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-0.0.8.tgz#f26074d238e02659e323ce1a13d041eee280e194"
@@ -1361,6 +1377,11 @@ asynckit@^0.4.0:
   resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
   integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
 
+at-least-node@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2"
+  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
+
 atob@^2.1.2:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
@@ -1381,6 +1402,13 @@ aws4@^1.8.0:
   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59"
   integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==
 
+axios@^0.21.1:
+  version "0.21.1"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.1.tgz#22563481962f4d6bde9a76d516ef0e5d3c09b2b8"
+  integrity sha512-dKQiRHxGD9PPRIUNIWvZhPTPpl1rf/OxTYKsqKUDjBwYylTvV7SjSHJb9ratfyzM6wCdLCOYLzs73qpg5c4iGA==
+  dependencies:
+    follow-redirects "^1.10.0"
+
 babel-code-frame@^6.26.0:
   version "6.26.0"
   resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
@@ -2343,7 +2371,7 @@ chalk@^2.0.0, chalk@^2.3.0, chalk@^2.4.1, chalk@^2.4.2:
     escape-string-regexp "^1.0.5"
     supports-color "^5.3.0"
 
-chalk@^4.0.0:
+chalk@^4.0.0, chalk@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
   integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
@@ -2987,11 +3015,21 @@ dir-glob@^3.0.1:
   dependencies:
     path-type "^4.0.0"
 
+directory-tree@^2.2.7:
+  version "2.2.7"
+  resolved "https://registry.yarnpkg.com/directory-tree/-/directory-tree-2.2.7.tgz#4617c794ee89d5618f03fffb7486c7e49df52ad2"
+  integrity sha512-fgTad/YdV6Y2njsCRK4fl4ZUlGhmb5xj1qrZUIMjvnrKvghVqh8dkB+OUssjYVvb/Q2L+5+8XG0l5uTGI9/8iQ==
+
 dom-walk@^0.1.0:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/dom-walk/-/dom-walk-0.1.2.tgz#0c548bef048f4d1f2a97249002236060daa3fd84"
   integrity sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==
 
+dotenv@^8.2.0:
+  version "8.2.0"
+  resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-8.2.0.tgz#97e619259ada750eea3e4ea3e26bceea5424b16a"
+  integrity sha512-8sJ78ElpbDJBHNeBzUbUVLsqKdccaa/BXF1uPTw3GrvQTBgrQrtObr2mUrE38vzYd8cEv+m/JBfDLioYcfXoaw==
+
 dotignore@~0.1.2:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/dotignore/-/dotignore-0.1.2.tgz#f942f2200d28c3a76fbdd6f0ee9f3257c8a2e905"
@@ -3058,6 +3096,11 @@ emoji-regex@^8.0.0:
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
+encode-utf8@^1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/encode-utf8/-/encode-utf8-1.0.3.tgz#f30fdd31da07fb596f281beb2f6b027851994cda"
+  integrity sha512-ucAnuBEhUK4boH2HjVYG5Q2mQyPorvv0u/ocS+zhdw0S8AlHYY+GOFhP1Gio5z4icpP2ivFSvhtFjQi8+T9ppw==
+
 encodeurl@~1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
@@ -4028,7 +4071,14 @@ flow-stoplight@^1.0.0:
   resolved "https://registry.yarnpkg.com/flow-stoplight/-/flow-stoplight-1.0.0.tgz#4a292c5bcff8b39fa6cc0cb1a853d86f27eeff7b"
   integrity sha1-SiksW8/4s5+mzAyxqFPYbyfu/3s=
 
-follow-redirects@^1.12.1:
+fmix@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/fmix/-/fmix-0.1.0.tgz#c7bbf124dec42c9d191cfb947d0a9778dd986c0c"
+  integrity sha1-x7vxJN7ELJ0ZHPuUfQqXeN2YbAw=
+  dependencies:
+    imul "^1.0.0"
+
+follow-redirects@^1.10.0, follow-redirects@^1.12.1:
   version "1.13.2"
   resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.13.2.tgz#dd73c8effc12728ba5cf4259d760ea5fb83e3147"
   integrity sha512-6mPTgLxYm3r6Bkkg0vNM0HTjfGrOEtsfbhagQvbxDEsEkpNhw582upBaoRZylzen6krEmxXJgt9Ju6HiI4O7BA==
@@ -4138,6 +4188,16 @@ fs-extra@^8.1.0:
     jsonfile "^4.0.0"
     universalify "^0.1.0"
 
+fs-extra@^9.0.0:
+  version "9.1.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.1.0.tgz#5954460c764a8da2094ba3554bf839e6b9a7c86d"
+  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
+  dependencies:
+    at-least-node "^1.0.0"
+    graceful-fs "^4.2.0"
+    jsonfile "^6.0.1"
+    universalify "^2.0.0"
+
 fs-minipass@^1.2.5:
   version "1.2.7"
   resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-1.2.7.tgz#ccff8570841e7fe4265693da88936c55aed7f7c7"
@@ -4462,6 +4522,32 @@ har-validator@~5.1.3:
     ajv "^6.12.3"
     har-schema "^2.0.0"
 
+hardhat-deploy@^0.7.0-beta.50:
+  version "0.7.0-beta.50"
+  resolved "https://registry.yarnpkg.com/hardhat-deploy/-/hardhat-deploy-0.7.0-beta.50.tgz#e9e8ae0a6b566303f784aa74311d945cc109b857"
+  integrity sha512-WSt/wQYy4TLgwXZrvC4PNM+zpngX8nldhE8/pZ6B7JxovU9LwLhgqa9pvPST+sOhr7fTuBGrO7XyTVq2TgK6YQ==
+  dependencies:
+    "@ethersproject/abi" "^5.0.2"
+    "@ethersproject/abstract-signer" "^5.0.2"
+    "@ethersproject/address" "^5.0.2"
+    "@ethersproject/bignumber" "^5.0.5"
+    "@ethersproject/bytes" "^5.0.2"
+    "@ethersproject/contracts" "^5.0.2"
+    "@ethersproject/providers" "^5.0.5"
+    "@ethersproject/solidity" "^5.0.2"
+    "@ethersproject/transactions" "^5.0.2"
+    "@ethersproject/wallet" "^5.0.2"
+    "@types/qs" "^6.9.4"
+    axios "^0.21.1"
+    chalk "^4.1.0"
+    chokidar "^3.4.0"
+    debug "^4.1.1"
+    form-data "^3.0.0"
+    fs-extra "^9.0.0"
+    match-all "^1.2.6"
+    murmur-128 "^0.2.1"
+    qs "^6.9.4"
+
 hardhat@^2.0.8:
   version "2.0.10"
   resolved "https://registry.yarnpkg.com/hardhat/-/hardhat-2.0.10.tgz#9b50da13b6915bb9b61b7f38f8f2b9b352447462"
@@ -4746,6 +4832,11 @@ immutable@^4.0.0-rc.12:
   resolved "https://registry.yarnpkg.com/immutable/-/immutable-4.0.0-rc.12.tgz#ca59a7e4c19ae8d9bf74a97bdf0f6e2f2a5d0217"
   integrity sha512-0M2XxkZLx/mi3t8NVwIm1g8nHoEmM9p9UBl/G9k4+hm0kBgOVdMV/B3CY5dQ8qG8qc80NN4gDV4HQv6FTJ5q7A==
 
+imul@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/imul/-/imul-1.0.1.tgz#9d5867161e8b3de96c2c38d5dc7cb102f35e2ac9"
+  integrity sha1-nVhnFh6LPelsLDjV3HyxAvNeKsk=
+
 inflight@^1.0.4:
   version "1.0.6"
   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
@@ -5227,6 +5318,15 @@ jsonfile@^4.0.0:
   optionalDependencies:
     graceful-fs "^4.1.6"
 
+jsonfile@^6.0.1:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
+  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
+  dependencies:
+    universalify "^2.0.0"
+  optionalDependencies:
+    graceful-fs "^4.1.6"
+
 jsonify@~0.0.0:
   version "0.0.0"
   resolved "https://registry.yarnpkg.com/jsonify/-/jsonify-0.0.0.tgz#2c74b6ee41d93ca51b7b5aaee8f503631d252a73"
@@ -5674,6 +5774,11 @@ map-visit@^1.0.0:
   dependencies:
     object-visit "^1.0.0"
 
+match-all@^1.2.6:
+  version "1.2.6"
+  resolved "https://registry.yarnpkg.com/match-all/-/match-all-1.2.6.tgz#66d276ad6b49655551e63d3a6ee53e8be0566f8d"
+  integrity sha512-0EESkXiTkWzrQQntBu2uzKvLu6vVkUGz40nGPbSZuegcfE5UuSzNjLaIu76zJWuaT/2I3Z/8M06OlUOZLGwLlQ==
+
 md5.js@^1.3.4:
   version "1.3.5"
   resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
@@ -6071,6 +6176,15 @@ multihashes@^0.4.15, multihashes@~0.4.15:
     multibase "^0.7.0"
     varint "^5.0.0"
 
+murmur-128@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/murmur-128/-/murmur-128-0.2.1.tgz#a9f6568781d2350ecb1bf80c14968cadbeaa4b4d"
+  integrity sha512-WseEgiRkI6aMFBbj8Cg9yBj/y+OdipwVC7zUo3W2W1JAJITwouUOtpqsmGSg67EQmwwSyod7hsVsWY5LsrfQVg==
+  dependencies:
+    encode-utf8 "^1.0.2"
+    fmix "^0.1.0"
+    imul "^1.0.0"
+
 nan@2.13.2:
   version "2.13.2"
   resolved "https://registry.yarnpkg.com/nan/-/nan-2.13.2.tgz#f51dc7ae66ba7d5d55e1e6d4d8092e802c9aefe7"
@@ -6898,7 +7012,7 @@ qs@6.7.0:
   resolved "https://registry.yarnpkg.com/qs/-/qs-6.7.0.tgz#41dc1a015e3d581f1621776be31afb2876a9b1bc"
   integrity sha512-VCdBRNFTX1fyE7Nb6FYoURo/SPe62QCaAyzJvUjwRaIsc+NePBEniHlvxFmmX56+HZphIGtV0XeCirBtpDrTyQ==
 
-qs@^6.7.0:
+qs@^6.7.0, qs@^6.9.4:
   version "6.9.6"
   resolved "https://registry.yarnpkg.com/qs/-/qs-6.9.6.tgz#26ed3c8243a431b2924aca84cc90471f35d5a0ee"
   integrity sha512-TIRk4aqYLNoJUbd+g2lEdz5kLWIuTMRagAXxl78Q0RiVjAOugHmeKNGdd3cwo/ktpf9aL9epCfFqWDEKysUlLQ==
@@ -8438,6 +8552,11 @@ universalify@^0.1.0:
   resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
   integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
 
+universalify@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717"
+  integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==
+
 unorm@^1.3.3:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/unorm/-/unorm-1.6.0.tgz#029b289661fba714f1a9af439eb51d9b16c205af"