Merge pull request #5314 from ethereum-optimism/feat/l2-deployments

contracts-bedrock: L2 contract deployments

.changeset/poor-carrots-walk.md

+---
+'@eth-optimism/hardhat-deploy-config': patch
+---
+
+Add getter for other network's deploy config

packages/contracts-bedrock/deploy/100-L1BlockImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import { ethers } from 'ethers'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  await deploy({
+    hre,
+    name: 'L1Block',
+    args: [],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'DEPOSITOR_ACCOUNT',
+        ethers.utils.getAddress('0xDeaDDEaDDeAdDeAdDEAdDEaddeAddEAdDEAd0001')
+      )
+    },
+  })
+}
+
+deployFn.tags = ['L1BlockImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/101-L2CrossDomainMessengerImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import { ethers } from 'ethers'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Artifact__L1CrossDomainMessenger = await hre.companionNetworks[
+    'l1'
+  ].deployments.get('L1CrossDomainMessengerProxy')
+
+  await deploy({
+    hre,
+    name: 'L2CrossDomainMessenger',
+    args: [Artifact__L1CrossDomainMessenger.address],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'OTHER_MESSENGER',
+        ethers.utils.getAddress(Artifact__L1CrossDomainMessenger.address)
+      )
+    },
+  })
+}
+
+deployFn.tags = ['L2CrossDomainMessengerImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/102-L2StandardBridgeImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import { ethers } from 'ethers'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Artifact__L1StandardBridge = await hre.companionNetworks[
+    'l1'
+  ].deployments.get('L1StandardBridgeProxy')
+
+  await deploy({
+    hre,
+    name: 'L2StandardBridge',
+    args: [Artifact__L1StandardBridge.address],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'OTHER_BRIDGE',
+        ethers.utils.getAddress(Artifact__L1StandardBridge.address)
+      )
+    },
+  })
+}
+
+deployFn.tags = ['L2StandardBridgeImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/103-L2ToL1MessagePasserImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  await deploy({
+    hre,
+    name: 'L2ToL1MessagePasser',
+    args: [],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(contract, 'MESSAGE_VERSION', 1)
+    },
+  })
+}
+
+deployFn.tags = ['L2ToL1MessagePasserImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/104-L2ERC721BridgeImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import { ethers } from 'ethers'
+
+import { predeploys } from '../src/constants'
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  const Artifact__L1ERC721Bridge = await hre.companionNetworks[
+    'l1'
+  ].deployments.get('L1ERC721BridgeProxy')
+
+  await deploy({
+    hre,
+    name: 'L2ERC721Bridge',
+    args: [predeploys.L2CrossDomainMessenger, Artifact__L1ERC721Bridge.address],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'MESSENGER',
+        ethers.utils.getAddress(predeploys.L2CrossDomainMessenger)
+      )
+      await assertContractVariable(
+        contract,
+        'OTHER_BRIDGE',
+        ethers.utils.getAddress(Artifact__L1ERC721Bridge.address)
+      )
+    },
+  })
+}
+
+deployFn.tags = ['L2ERC721BridgeImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/105-GasPriceOracleImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  await deploy({
+    hre,
+    name: 'GasPriceOracle',
+    args: [],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(contract, 'DECIMALS', 6)
+    },
+  })
+}
+
+deployFn.tags = ['GasPriceOracle', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/106-SequencerFeeVaultImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import { ethers } from 'ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  const l1 = hre.network.companionNetworks['l1']
+  const deployConfig = hre.getDeployConfig(l1)
+
+  const sequencerFeeVaultRecipient = deployConfig.sequencerFeeVaultRecipient
+  if (sequencerFeeVaultRecipient === ethers.constants.AddressZero) {
+    throw new Error(`SequencerFeeVault RECIPIENT undefined`)
+  }
+
+  await deploy({
+    hre,
+    name: 'SequencerFeeVault',
+    args: [sequencerFeeVaultRecipient],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'RECIPIENT',
+        ethers.utils.getAddress(sequencerFeeVaultRecipient)
+      )
+    },
+  })
+}
+
+deployFn.tags = ['SequencerFeeVaultImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/107-BaseFeeVaultImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import { ethers } from 'ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  const l1 = hre.network.companionNetworks['l1']
+  const deployConfig = hre.getDeployConfig(l1)
+
+  const baseFeeVaultRecipient = deployConfig.baseFeeVaultRecipient
+  if (baseFeeVaultRecipient === ethers.constants.AddressZero) {
+    throw new Error('BaseFeeVault RECIPIENT undefined')
+  }
+
+  await deploy({
+    hre,
+    name: 'BaseFeeVault',
+    args: [baseFeeVaultRecipient],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'RECIPIENT',
+        ethers.utils.getAddress(baseFeeVaultRecipient)
+      )
+    },
+  })
+}
+
+deployFn.tags = ['BaseFeeVaultImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/108-L1FeeVaultImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import { ethers } from 'ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+
+const deployFn: DeployFunction = async (hre) => {
+  const l1 = hre.network.companionNetworks['l1']
+  const deployConfig = hre.getDeployConfig(l1)
+
+  const l1FeeVaultRecipient = deployConfig.l1FeeVaultRecipient
+  if (l1FeeVaultRecipient === ethers.constants.AddressZero) {
+    throw new Error('L1FeeVault RECIPIENT undefined')
+  }
+
+  await deploy({
+    hre,
+    name: 'L1FeeVault',
+    args: [l1FeeVaultRecipient],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'RECIPIENT',
+        ethers.utils.getAddress(l1FeeVaultRecipient)
+      )
+    },
+  })
+}
+
+deployFn.tags = ['L1FeeVaultImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/109-OptimismMintableERC20FactoryImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import { ethers } from 'ethers'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+import { predeploys } from '../src/constants'
+
+const deployFn: DeployFunction = async (hre) => {
+  await deploy({
+    hre,
+    name: 'OptimismMintableERC20Factory',
+    args: [predeploys.L2StandardBridge],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'BRIDGE',
+        ethers.utils.getAddress(predeploys.L2StandardBridge)
+      )
+    },
+  })
+}
+
+deployFn.tags = ['OptimismMintableERC20FactoryImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/deploy/110-OptimismMintableERC721FactoryImpl.ts

+import { DeployFunction } from 'hardhat-deploy/dist/types'
+import { ethers } from 'ethers'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+
+import { assertContractVariable, deploy } from '../src/deploy-utils'
+import { predeploys } from '../src/constants'
+
+const deployFn: DeployFunction = async (hre) => {
+  const OptimismMintableERC721Factory = await hre.ethers.getContractAt(
+    'OptimismMintableERC721Factory',
+    predeploys.OptimismMintableERC721Factory
+  )
+  const remoteChainId = await OptimismMintableERC721Factory.REMOTE_CHAIN_ID()
+
+  await deploy({
+    hre,
+    name: 'OptimismMintableERC721Factory',
+    args: [predeploys.L2StandardBridge, remoteChainId],
+    postDeployAction: async (contract) => {
+      await assertContractVariable(
+        contract,
+        'BRIDGE',
+        ethers.utils.getAddress(predeploys.L2StandardBridge)
+      )
+      await assertContractVariable(contract, 'REMOTE_CHAIN_ID', remoteChainId)
+    },
+  })
+}
+
+deployFn.tags = ['OptimismMintableERC721FactoryImpl', 'l2']
+
+export default deployFn

packages/contracts-bedrock/hardhat.config.ts

@@ -50,6 +50,17 @@ const config: HardhatUserConfig = {
       chainId: 5,
       url: process.env.L1_RPC || '',
       accounts: [process.env.PRIVATE_KEY_DEPLOYER || ethers.constants.HashZero],
+      companionNetworks: {
+        l2: 'optimism-goerli',
+      },
+    },
+    'optimism-goerli': {
+      chainId: 420,
+      url: process.env.L2_RPC || '',
+      accounts: [process.env.PRIVATE_KEY_DEPLOYER || ethers.constants.HashZero],
+      companionNetworks: {
+        l1: 'goerli',
+      },
     },
     'alpha-1': {
       chainId: 5,

packages/contracts-bedrock/src/deploy-utils.ts

@@ -44,6 +44,15 @@ export const deploy = async ({
   // external deployments when doing this check. By doing the check ourselves, we also get to
   // consider external deployments. If we already have the deployment, return early.
   let result: Deployment | DeployResult = await hre.deployments.getOrNull(name)
+
+  // Wrap in a try/catch in case there is not a deployConfig for the current network.
+  let numDeployConfirmations: number
+  try {
+    numDeployConfirmations = hre.deployConfig.numDeployConfirmations
+  } catch (e) {
+    numDeployConfirmations = 1
+  }
+
   if (result) {
     console.log(`skipping ${name}, using existing at ${result.address}`)
   } else {
@@ -52,7 +61,7 @@ export const deploy = async ({
       from: deployer,
       args,
       log: true,
-      waitConfirmations: hre.deployConfig.numDeployConfirmations,
+      waitConfirmations: numDeployConfirmations,
     })
     console.log(`Deployed ${name} at ${result.address}`)
     // Only wait for the transaction if it was recently deployed in case the
@@ -68,7 +77,7 @@ export const deploy = async ({
 
   // Create the contract object to return.
   const created = asAdvancedContract({
-    confirmations: hre.deployConfig.numDeployConfirmations,
+    confirmations: numDeployConfirmations,
     contract: new Contract(
       result.address,
       iface !== undefined
@@ -119,7 +128,6 @@ export const asAdvancedContract = (opts: {
   // 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) => {
@@ -199,8 +207,15 @@ export const getContractFromArtifact = async (
     }
   }
 
+  let numDeployConfirmations: number
+  try {
+    numDeployConfirmations = hre.deployConfig.numDeployConfirmations
+  } catch (e) {
+    numDeployConfirmations = 1
+  }
+
   return asAdvancedContract({
-    confirmations: hre.deployConfig.numDeployConfirmations,
+    confirmations: numDeployConfirmations,
     contract: new hre.ethers.Contract(
       artifact.address,
       iface,

packages/hardhat-deploy-config/src/type-extensions.ts

@@ -24,8 +24,8 @@ declare module 'hardhat/types/config' {
 declare module 'hardhat/types/runtime' {
   interface HardhatRuntimeEnvironment {
     deployConfig: {
-      // TODO: Is there any good way to type this?
       [key: string]: any
     }
+    getDeployConfig(network: string): { [key: string]: any }
   }
 }