ctp: fixup deploy scripts for the nft bridge

packages/contracts-periphery/deploy/nft-bridge/L1ERC721BridgeImplementation.ts

@@ -1,14 +1,110 @@
 /* Imports: External */
 import { DeployFunction } from 'hardhat-deploy/dist/types'
-import { ethers } from 'hardhat'
+import { HardhatRuntimeEnvironment } from 'hardhat/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import 'hardhat-deploy'
+import fetch from 'node-fetch'
+
+import {
+  isTargetL1Network,
+  predeploy,
+  getProxyAdmin,
+  validateERC721Bridge,
+} from '../../src/nft-bridge-deploy-helpers'
+
+// Handle the `ops` deployment
+const getL1CrossDomainMessengerProxyDeployment = async (
+  hre: HardhatRuntimeEnvironment
+) => {
+  const network = hre.network.name
+  if (network === 'ops-l1') {
+    const res = await fetch(
+      'http://localhost:8080/deployments/local/Proxy__OVM_L1CrossDomainMessenger.json'
+    )
+    return res.json()
+  } else {
+    return hre.deployments.get('Proxy__OVM_L1CrossDomainMessenger')
+  }
+}
 
 const deployFn: DeployFunction = async (hre) => {
   const { deployer } = await hre.getNamedAccounts()
+  const { deploy } = hre.deployments
+  const { getAddress } = hre.ethers.utils
+
+  if (!isTargetL1Network(hre.network.name)) {
+    console.log(`Deploying to unsupported network ${hre.network.name}`)
+    return
+  }
+
+  console.log(`Deploying L1ERC721Bridge to ${hre.network.name}`)
+  console.log(`Using deployer ${deployer}`)
+
+  const Deployment__L1ERC721BridgeProxy = await hre.deployments.get(
+    'L1ERC721BridgeProxy'
+  )
+
+  const L1ERC721BridgeProxy = await hre.ethers.getContractAt(
+    'Proxy',
+    Deployment__L1ERC721BridgeProxy.address
+  )
+
+  const admin = await L1ERC721BridgeProxy.callStatic.admin()
+  if (getAddress(admin) !== getAddress(deployer)) {
+    throw new Error('deployer is not proxy admin')
+  }
+
+  // Get the address of the currently deployed L1CrossDomainMessenger.
+  // This should be the address of the proxy
+  const Deployment__L1CrossDomainMessengerProxy =
+    await getL1CrossDomainMessengerProxyDeployment(hre)
 
-  await hre.deployments.deploy('L1ERC721Bridge', {
+  const L1CrossDomainMessengerProxyAddress =
+    Deployment__L1CrossDomainMessengerProxy.address
+
+  // Deploy the L1ERC721Bridge. The arguments are
+  // - messenger
+  // - otherBridge
+  // Since this is the L1ERC721Bridge, the otherBridge is the
+  // predeploy address
+  await deploy('L1ERC721Bridge', {
     from: deployer,
-    args: [ethers.constants.AddressZero, ethers.constants.AddressZero],
+    args: [L1CrossDomainMessengerProxyAddress, predeploy],
     log: true,
+    waitConfirmations: 1,
+  })
+
+  const Deployment__L1ERC721Bridge = await hre.deployments.get('L1ERC721Bridge')
+  console.log(
+    `L1ERC721Bridge deployed to ${Deployment__L1ERC721Bridge.address}`
+  )
+
+  await validateERC721Bridge(hre, Deployment__L1ERC721Bridge.address, {
+    messenger: L1CrossDomainMessengerProxyAddress,
+    otherBridge: predeploy,
+  })
+
+  {
+    // Upgrade the Proxy to the newly deployed implementation
+    const tx = await L1ERC721BridgeProxy.upgradeTo(
+      Deployment__L1ERC721Bridge.address
+    )
+    const receipt = await tx.wait()
+    console.log(`L1ERC721BridgeProxy upgraded: ${receipt.transactionHash}`)
+  }
+
+  {
+    // Set the admin correctly
+    const newAdmin = getProxyAdmin(hre.network.name)
+    const tx = await L1ERC721BridgeProxy.changeAdmin(newAdmin)
+    const receipt = await tx.wait()
+    console.log(`L1ERC721BridgeProxy admin updated: ${receipt.transactionHash}`)
+  }
+
+  await validateERC721Bridge(hre, L1ERC721BridgeProxy.address, {
+    messenger: L1CrossDomainMessengerProxyAddress,
+    otherBridge: predeploy,
   })
 }
 

packages/contracts-periphery/deploy/nft-bridge/L1ERC721BridgeProxy.ts

@@ -1,24 +1,37 @@
 /* Imports: External */
 import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import 'hardhat-deploy'
+
+import { isTargetL1Network } from '../../src/nft-bridge-deploy-helpers'
 
 const deployFn: DeployFunction = async (hre) => {
   const { deployer } = await hre.getNamedAccounts()
+  const { deploy } = hre.deployments
 
-  const { deploy } = await hre.deployments.deterministic(
-    'L1ERC721BridgeProxy',
-    {
-      contract: 'Proxy',
-      salt: hre.ethers.utils.solidityKeccak256(
-        ['string'],
-        ['L1ERC721BridgeProxy']
-      ),
-      from: deployer,
-      args: [hre.deployConfig.ddd],
-      log: true,
-    }
-  )
+  if (!isTargetL1Network(hre.network.name)) {
+    console.log(`Deploying to unsupported network ${hre.network.name}`)
+    return
+  }
+
+  console.log(`Deploying L1ERC721BridgeProxy to ${hre.network.name}`)
+  console.log(`Using deployer ${deployer}`)
 
-  await deploy()
+  await deploy('L1ERC721BridgeProxy', {
+    contract: 'Proxy',
+    from: deployer,
+    args: [deployer],
+    log: true,
+    waitConfirmations: 1,
+  })
+
+  const Deployment__L1ERC721BridgeProxy = await hre.deployments.get(
+    'L1ERC721BridgeProxy'
+  )
+  console.log(
+    `L1ERC721BridgeProxy deployed to ${Deployment__L1ERC721BridgeProxy.address}`
+  )
 }
 
 deployFn.tags = ['L1ERC721BridgeProxy']

packages/contracts-periphery/deploy/nft-bridge/L2ERC721BridgeImplementation.ts

@@ -1,18 +1,95 @@
 /* Imports: External */
 import { DeployFunction } from 'hardhat-deploy/dist/types'
-import { ethers } from 'hardhat'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import 'hardhat-deploy'
+import { predeploys } from '@eth-optimism/contracts'
+
+import {
+  isTargetL2Network,
+  predeploy,
+  validateERC721Bridge,
+  getProxyAdmin,
+} from '../../src/nft-bridge-deploy-helpers'
 
 const deployFn: DeployFunction = async (hre) => {
   const { deployer } = await hre.getNamedAccounts()
+  const { getAddress } = hre.ethers.utils
+
+  if (!isTargetL2Network(hre.network.name)) {
+    console.log(`Deploying to unsupported network ${hre.network.name}`)
+    return
+  }
+
+  console.log(`Deploying L2ERC721Bridge to ${hre.network.name}`)
+  console.log(`Using deployer ${deployer}`)
+
+  const L2ERC721BridgeProxy = await hre.ethers.getContractAt('Proxy', predeploy)
+
+  // Check to make sure that the admin of the proxy is the deployer.
+  // The deployer of the L2ERC721Bridge should be the same as the
+  // admin of the L2ERC721BridgeProxy so that it is easy to upgrade
+  // the implementation. The admin is then changed depending on the
+  // network after the L2ERC721BridgeProxy is upgraded to the implementation
+  const admin = await L2ERC721BridgeProxy.callStatic.admin()
+
+  if (getAddress(admin) !== getAddress(deployer)) {
+    throw new Error(`Unexpected admin ${admin}`)
+  }
+
+  const Deployment__L1ERC721Bridge = await hre.deployments.get(
+    'L1ERC721BridgeProxy'
+  )
+
+  const L1ERC721BridgeAddress = Deployment__L1ERC721Bridge.address
 
+  // Deploy the L2ERC721Bridge implementation
   await hre.deployments.deploy('L2ERC721Bridge', {
     from: deployer,
-    args: [ethers.constants.AddressZero, ethers.constants.AddressZero],
+    args: [predeploys.L2CrossDomainMessenger, L1ERC721BridgeAddress],
     log: true,
+    waitConfirmations: 1,
   })
+
+  const Deployment__L2ERC721Bridge = await hre.deployments.get('L2ERC721Bridge')
+  console.log(
+    `L2ERC721Bridge deployed to ${Deployment__L2ERC721Bridge.address}`
+  )
+
+  await validateERC721Bridge(hre, Deployment__L2ERC721Bridge.address, {
+    messenger: predeploys.L2CrossDomainMessenger,
+    otherBridge: L1ERC721BridgeAddress,
+  })
+
+  {
+    // Upgrade the implementation of the proxy to the newly deployed
+    // L2ERC721Bridge
+    const tx = await L2ERC721BridgeProxy.upgradeTo(
+      Deployment__L2ERC721Bridge.address
+    )
+    const receipt = await tx.wait()
+    console.log(
+      `Upgraded the implementation of the L2ERC721BridgeProxy: ${receipt.transactionhash}`
+    )
+  }
+
+  await validateERC721Bridge(hre, L2ERC721BridgeProxy.address, {
+    messenger: predeploys.L2CrossDomainMessenger,
+    otherBridge: L1ERC721BridgeAddress,
+  })
+
+  {
+    const newAdmin = getProxyAdmin(hre.network.name)
+    console.log(`Changing admin to ${newAdmin}`)
+    const tx = await L2ERC721BridgeProxy.changeAdmin(newAdmin)
+    const receipt = await tx.wait()
+    console.log(
+      `Changed admin of the L2ERC721BridgeProxy: ${receipt.transactionHash}`
+    )
+  }
 }
 
 deployFn.tags = ['L2ERC721BridgeImplementation']
-deployFn.dependencies = ['L2ERC721BridgeProxy']
+deployFn.dependencies = ['L2ERC721BridgeProxy', 'L1ERC721BridgeProxy']
 
 export default deployFn

packages/contracts-periphery/deploy/nft-bridge/L2ERC721BridgeProxy.ts

@@ -1,24 +1,68 @@
 /* Imports: External */
 import { DeployFunction } from 'hardhat-deploy/dist/types'
+import '@eth-optimism/hardhat-deploy-config'
+import '@nomiclabs/hardhat-ethers'
+import 'hardhat-deploy'
+
+const predeploy = '0x4200000000000000000000000000000000000014'
 
 const deployFn: DeployFunction = async (hre) => {
   const { deployer } = await hre.getNamedAccounts()
+  const { getAddress } = hre.ethers.utils
 
-  const { deploy } = await hre.deployments.deterministic(
-    'L2ERC721BridgeProxy',
-    {
-      contract: 'Proxy',
-      salt: hre.ethers.utils.solidityKeccak256(
-        ['string'],
-        ['L2ERC721BridgeProxy']
-      ),
-      from: deployer,
-      args: [hre.deployConfig.ddd],
-      log: true,
-    }
+  console.log(`Deploying L2ERC721BridgeProxy to ${hre.network.name}`)
+  console.log(`Using deployer ${deployer}`)
+
+  // Check to make sure that the Proxy has not been deployed yet
+  const pre = await hre.ethers.provider.getCode(predeploy, 'latest')
+  if (pre !== '0x') {
+    console.log(`Code already deployed to ${predeploy}`)
+    return
+  }
+
+  // A special deployer account must be used
+  const mainnetDeployer = getAddress(
+    '0x53A6eecC2dD4795Fcc68940ddc6B4d53Bd88Bd9E'
+  )
+  const goerliDeployer = getAddress(
+    '0x5c679a57e018f5f146838138d3e032ef4913d551'
   )
+  const localDeployer = getAddress('0xdfc82d475833a50de90c642770f34a9db7deb725')
+
+  // Deploy the L2ERC721BridgeProxy as a predeploy address
+  if (hre.network.name === 'optimism') {
+    if (getAddress(deployer) !== mainnetDeployer) {
+      throw new Error(`Incorrect deployer: ${deployer}`)
+    }
+  } else if (hre.network.name === 'optimism-goerli') {
+    if (getAddress(deployer) !== goerliDeployer) {
+      throw new Error(`Incorrect deployer: ${deployer}`)
+    }
+  } else if (hre.network.name === 'ops-l2') {
+    if (getAddress(deployer) !== localDeployer) {
+      throw new Error(`Incorrect deployer: ${deployer}`)
+    }
+  } else {
+    throw new Error(`Unknown network: ${hre.network.name}`)
+  }
+
+  // Set the deployer as the admin of the Proxy. This is
+  // temporary, the admin will be updated when deploying
+  // the implementation
+  await hre.deployments.deploy('L2ERC721BridgeProxy', {
+    contract: 'Proxy',
+    from: deployer,
+    args: [deployer],
+    log: true,
+    waitConfirmations: 1,
+  })
 
-  await deploy()
+  // Check that the Proxy was deployed to the correct address
+  const code = await hre.ethers.provider.getCode(predeploy)
+  if (code === '0x') {
+    throw new Error('Code is not set at expected predeploy address')
+  }
+  console.log(`L2ERC721BridgeProxy deployed to ${predeploy}`)
 }
 
 deployFn.tags = ['L2ERC721BridgeProxy']