test(arbToGno): deployment scripts for HRE

Author: madhurMongia

contracts/deploy/01-outbox/01-arb-to-gnosis-outbox.ts

@@ -36,17 +36,17 @@ const paramsByChainId = {
     sequencerLimit: 86400, // 24 hours
   },
   HARDHAT: {
-    deposit: parseEther("5"), // 120 xDAI budget for timeout
+    deposit: parseEther("10"), // 120 xDAI budget for timeout
     // Average happy path wait time is 22.5 mins, assume no censorship
     epochPeriod: 600, // 10 min
-    challengePeriod: 600, // 10 min (assume no sequencer backdating)
-    numEpochTimeout: 24, // 6 hours
+    minChallengePeriod: 600, // 10 min (assume no sequencer backdating)
+    numEpochTimeout: 21600, // 6 hours
     claimDelay: 2,
     amb: ethers.constants.AddressZero,
     routerAddress: ethers.constants.AddressZero,
     maxMissingBlocks: 10000000000000,
     routerChainId: 31337,
-    sequencerLimit: 86400, // 24 hours
+    sequencerLimit: 864,
   },
 };
 
@@ -84,27 +84,50 @@ const deployOutbox: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
   // ----------------------------------------------------------------------------------------------
   const hardhatDeployer = async () => {
     let nonce = await ethers.provider.getTransactionCount(deployer);
-    nonce += 4; // SenderGatewayToEthereum deploy tx will be the 5th after this, same network for both sender/receiver.
 
-    const routerAddress = getContractAddress(deployer, nonce);
-    console.log("calculated future router for nonce %d: %s", nonce, routerAddress);
+    const routerAddress = getContractAddress(deployer, nonce + 10);
+    console.log("calculated future router for nonce %d: %s", nonce + 10, routerAddress);
+
+    const senderGatewayAddress = getContractAddress(deployer, nonce + 6); // with the current order of transaction ,nonce for sender gateway would be 14.
+    console.log("calculated future SenderGatewayToGnosis address for nonce %d: %s", nonce, senderGatewayAddress);
+
+    const ambMock = await deploy("MockAMB", {
+      from: deployer,
+      args: [],
+      log: true,
+    });
+
+    const wethMock = await deploy("MockWETH", {
+      from: deployer,
+      args: [],
+      log: true,
+    });
 
-    await deploy("VeaOutboxGnosisMock", {
+    const veaOutbox = await deploy("VeaOutboxArbToGnosis", {
       from: deployer,
+      contract: "VeaOutboxArbToGnosis",
       args: [
         deposit,
         epochPeriod,
         minChallengePeriod,
         numEpochTimeout,
-        amb,
-        ethers.constants.AddressZero,
+        ambMock.address,
+        routerAddress,
         sequencerLimit,
         maxMissingBlocks,
         routerChainId,
-        WETH,
+        wethMock.address,
       ],
       log: true,
     });
+
+    await deploy("ArbToGnosisReceiverGateway", {
+      from: deployer,
+      contract: "ReceiverGatewayMock",
+      args: [veaOutbox.address, senderGatewayAddress],
+      gasLimit: 4000000,
+      log: true,
+    });
   };
 
   // ----------------------------------------------------------------------------------------------

contracts/deploy/02-inbox/02-arb-to-gnosis-inbox.ts

@@ -1,12 +1,14 @@
 import { HardhatRuntimeEnvironment } from "hardhat/types";
 import { DeployFunction } from "hardhat-deploy/types";
 import getContractAddress from "../../deploy-helpers/getContractAddress";
+import { ethers } from "hardhat";
 
 enum SenderChains {
   ARBITRUM = 42161,
   ARBITRUM_SEPOLIA = 421614,
   HARDHAT = 31337,
 }
+
 const paramsByChainId = {
   ARBITRUM: {
     epochPeriod: 3600, // 1 hours
@@ -16,41 +18,65 @@ const paramsByChainId = {
   },
   HARDHAT: {
     epochPeriod: 600, // 10 minutes
+    routerAddress: ethers.constants.AddressZero,
   },
 };
 
-// TODO: use deterministic deployments
 const deployInbox: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
   const { ethers, deployments, getNamedAccounts, getChainId, config } = hre;
   const { deploy } = deployments;
-  const chainId = Number(await getChainId());
-  const { providers } = ethers;
 
-  const deployer = (await getNamedAccounts()).deployer;
-  console.log("deployer: %s", deployer);
+  // fallback to hardhat node signers on local network
+  const deployer = (await getNamedAccounts()).deployer ?? (await hre.ethers.getSigners())[0].address;
+  const chainId = Number(await getChainId());
 
   const { epochPeriod } = paramsByChainId[SenderChains[chainId]];
 
-  const routerNetworks = {
-    ARBITRUM: config.networks.mainnet,
-    ARBITRUM_SEPOLIA: config.networks.sepolia,
-    HARDHAT: config.networks.localhost,
-  };
+  // Hack to predict the deployment address on the sender chain.
+  // TODO: use deterministic deployments
 
   // ----------------------------------------------------------------------------------------------
+  const hardhatDeployer = async () => {
+    let nonce = await ethers.provider.getTransactionCount(deployer);
+
+    const arbitrumBridgeAddress = getContractAddress(deployer, nonce + 5);
+
+    const arbSysMock = await deploy("ArbSysMock", {
+      from: deployer,
+      contract: "ArbSysMockWithBridge",
+      args: [arbitrumBridgeAddress],
+      log: true,
+    });
 
-  const routerChainProvider = new providers.JsonRpcProvider(routerNetworks[SenderChains[chainId]].url);
-  let nonceRouter = await routerChainProvider.getTransactionCount(deployer);
+    const routerAddress = getContractAddress(deployer, nonce + 6);
+    console.log("calculated future router for nonce %d: %s", nonce + 6, routerAddress);
 
-  const routerAddress = getContractAddress(deployer, nonceRouter);
-  console.log("calculated future router for nonce %d: %s", nonceRouter, routerAddress);
+    const receiverGateway = await deployments.get("ArbToGnosisReceiverGateway");
+    const veaInbox = await deploy("VeaInboxArbToGnosis", {
+      from: deployer,
+      contract: "VeaInboxArbToGnosisMock",
+      args: [epochPeriod, routerAddress, arbSysMock.address],
+      log: true,
+    });
 
-  await deploy("VeaInboxArbToGnosis" + (chainId === 42161 ? "" : "Testnet"), {
-    contract: "VeaInboxArbToGnosis",
-    from: deployer,
-    args: [epochPeriod, routerAddress],
-    log: true,
-  });
+    await deploy("ArbToGnosisSenderGateway", {
+      from: deployer,
+      contract: "SenderGatewayMock",
+      args: [veaInbox.address, receiverGateway.address],
+      gasLimit: 4000000,
+      log: true,
+    });
+  };
+
+  // ----------------------------------------------------------------------------------------------
+  const liveDeployer = async () => {};
+
+  // ----------------------------------------------------------------------------------------------
+  if (chainId === 31337) {
+    await hardhatDeployer();
+  } else {
+    await liveDeployer();
+  }
 };
 
 deployInbox.tags = ["ArbToGnosisInbox"];

contracts/deploy/03-routers/03-arb-to-gnosis-router.ts

@@ -39,11 +39,30 @@ const deployRouter: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
   const hardhatDeployer = async () => {
     const veaOutbox = await deployments.get("VeaOutboxArbToGnosis");
     const veaInbox = await deployments.get("VeaInboxArbToGnosis");
+    const amb = await deployments.get("MockAMB");
+    //const ArbSysMock = await deployments.get('arbSysMock');
+
+    const sequencerInbox = await deploy("SequencerInboxMock", {
+      from: deployer,
+      contract: "SequencerInboxMock",
+      args: ["10"],
+    });
+    const outbox = await deploy("OutboxMock", {
+      from: deployer,
+      args: [veaInbox.address],
+      log: true,
+    });
+
+    const arbitrumBridge = await deploy("BridgeMock", {
+      from: deployer,
+      contract: "BridgeMock",
+      args: [outbox.address, sequencerInbox.address],
+    });
 
     const router = await deploy("RouterArbToGnosis", {
       from: deployer,
       contract: "RouterArbToGnosis",
-      args: [arbitrumBridge, amb, veaInbox.address, veaOutbox.address],
+      args: [arbitrumBridge.address, amb.address, veaInbox.address, veaOutbox.address],
     });
   };
 
@@ -73,7 +92,6 @@ const deployRouter: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
 deployRouter.tags = ["ArbToGnosisRouter"];
 deployRouter.skip = async ({ getChainId }) => {
   const chainId = Number(await getChainId());
-  console.log(chainId);
   return !RouterChains[chainId];
 };
 deployRouter.runAtTheEnd = true;