Merge pull request #26 from unknownunknown1/feat/deployment-scripts

Add governance + bug fixes

contracts/deploy/002_foreign_proxy.js

@@ -13,7 +13,7 @@ const paramsByChainId = {
     arbitratorExtraData:
       "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
     zkAddress: "0x9A6DE0f62Aa270A8bCB1e2610078650D539B1Ef9",
-    metaEvidence: "/ipfs/QmUWbqopqmdJhabN1WpUMXse6TzTdUiM6TF95FQnP4AonY/realitio.json",
+    metaEvidence: "/ipfs/QmZjtv9jTbykD39z8U7ZAmZ3mvRw7J6etKohgJBS5Nmxm5/metaevidence.json",
   },
   1: {
     arbitrator: "0x988b3a538b618c7a603e1c11ab82cd16dbe28069", // KlerosLiquid address
@@ -24,21 +24,32 @@ const paramsByChainId = {
   },
 };
 
-const surplus = ethers.utils.parseUnits("0.01", "ether");
+const surplus = ethers.utils.parseUnits("0.05", "ether");
 const winnerMultiplier = 3000;
 const loserMultiplier = 7000;
 const loserAppealPeriodMultiplier = 5000;
+const l2GasLimit = 1500000;
+const l2GasPerPubdataByteLimit = 800;
 
 async function main() {
   console.log("Starting foreign proxy deployment..");
   const chainId = hre.network.config.chainId;
   const { arbitrator, arbitratorExtraData, zkAddress, metaEvidence } = paramsByChainId[chainId];
+  let governor;
+  if (chainId === 1) {
+    governor = "TODO"; // Determine later
+  } else {
+    governor = (await ethers.getSigners())[0].address;
+  }
 
   const ForeignProxy = await ethers.getContractFactory("zkRealitioForeignProxy");
   const foreignProxy = await ForeignProxy.deploy(
+    governor,
     arbitrator,
     arbitratorExtraData,
     zkAddress,
+    l2GasLimit,
+    l2GasPerPubdataByteLimit,
     surplus,
     metaEvidence,
     winnerMultiplier,

contracts/hardhat.config.js

@@ -9,14 +9,6 @@ require("@matterlabs/hardhat-zksync-solc");
 require('hardhat-contract-sizer');
 require("@matterlabs/hardhat-zksync-verify");
 
-const getProof = require("./tasks/get_proof.js");
-
-task("getProof", "Obtain a proof and send it to L2")
-  .addParam("txhash", "The transaction hash")
-  .setAction(async (taskArgs) => {
-    await getProof(taskArgs.txhash);
-  });
-
 module.exports = {
   solidity: {
     version: "0.8.19",
@@ -37,6 +29,8 @@ module.exports = {
   networks: {
     hardhat: {
       blockGasLimit: 100000000000,
+      // Enable zkSync only if not in a test environment. We need this flag to create zk artifacts. For tests the ordinary artifacts will be used for both proxies.
+      zksync: !process.env.TEST_ENV,
     },
     zkSyncGoerli: {
       url: "https://testnet.era.zksync.dev",

contracts/package.json

@@ -9,9 +9,9 @@
     "size": "hardhat size-contracts",
     "deploy:staging": "hardhat compile && hardhat deploy-zksync --script \\deploy\\001_home_proxy.js --network zkSyncSepolia && hardhat run .\\deploy\\002_foreign_proxy.js --network sepolia",
     "deploy-production": "hardhat compile && hardhat deploy-zksync --script \\deploy\\001_home_proxy.js --network zkSyncMainnet && hardhat run .\\deploy\\002_foreign_proxy.js --network mainnet",
-    "proof:staging": "hardhat getProof --network zkSyncSepolia",
-    "proof:production": "hardhat getProof --network zkSyncMainnet",
-    "test": "hardhat test"
+    "proof:staging": "hardhat run .\\scripts\\execute_proof.js --network zkSyncSepolia",
+    "proof:production": "hardhat run .\\scripts\\execute_proof.js --network zkSyncMainnet",
+    "test": "set TEST_ENV=true && hardhat test"
   },
   "dependencies": {
     "@kleros/dispute-resolver-interface-contract": "^8.0.0",

contracts/scripts/execute_proof.js

@@ -0,0 +1,109 @@
+const hre = require("hardhat");
+const { Provider, utils } = require("zksync-web3");
+const { getL1MessageSentEvent, getCalldata } = require("../helpers/get_event_properties");
+const RealitioForeignArbitrationProxy = require("@kleros/cross-chain-realitio-contracts/artifacts-zk/src/zkRealitioForeignProxy.sol/zkRealitioForeignProxy.json");
+const RealitioHomeArbitrationProxy = require("@kleros/cross-chain-realitio-contracts/artifacts-zk/src/zkRealitioHomeProxy.sol/zkRealitioHomeProxy.json");
+
+async function executeProof() {
+  // https://era.zksync.io/docs/dev/how-to/send-message-l2-l1.html
+  const txHash = "";
+
+  const { providers } = ethers;
+  const foreignNetworks = {
+    280: hre.config.networks.goerli,
+    324: hre.config.networks.mainnet,
+    300: hre.config.networks.sepolia,
+  };
+  const chainId = hre.network.config.chainId;
+  const url = foreignNetworks[chainId];
+
+  const l1Provider = new Provider(hre.network.config.url);
+  const l2Provider = new providers.JsonRpcProvider(url);
+
+  const l1MessageSentEvent = await getL1MessageSentEvent(txHash, utils.L1_MESSENGER, l1Provider);
+
+  if (!l1MessageSentEvent) {
+    throw new Error("No L1MessageSent event found in the transaction.");
+  }
+
+  const blockNumber = l1MessageSentEvent.blockNumber;
+  const homeProxy = "0x" + BigInt(l1MessageSentEvent.address).toString(16);
+  const msgHash = l1MessageSentEvent.msgHash;
+  const eventData = await getCalldata(txHash, l1Provider);
+  const homeProxyContract = new ethers.Contract(homeProxy, RealitioHomeArbitrationProxy.abi, l1Provider);
+  console.log(await homeProxyContract.foreignProxy());
+  const foreignProxyContract = new ethers.Contract(
+    await homeProxyContract.foreignProxy(),
+    RealitioForeignArbitrationProxy.abi,
+    l2Provider
+  );
+
+  console.log(`Event: ${l1MessageSentEvent.name}`);
+  console.log("Block Number:", blockNumber);
+  console.log("Smart Contract Address:", homeProxy);
+  console.log("Hash:", msgHash);
+  console.log("Message:", eventData);
+
+  const proof = await getL1MessageProof(blockNumber, l1Provider, homeProxy, msgHash);
+  console.log(`Proof is: `, proof);
+  const { l1BatchNumber, l1BatchTxIndex } = await l1Provider.getTransactionReceipt(txHash);
+
+  console.log("L1 Index for Tx in block :>> ", l1BatchTxIndex);
+  console.log("L1 Batch for block :>> ", l1BatchNumber);
+
+  const result = await proveL1MessageInclusion(
+    l1BatchNumber,
+    proof,
+    l1BatchTxIndex,
+    l1Provider,
+    l2Provider,
+    homeProxy,
+    eventData
+  );
+
+  console.log("Result is :>> ", result);
+
+  if (result) {
+    const signer = new ethers.Wallet(process.env.PRIVATE_KEY, l2Provider);
+    try {
+      await foreignProxyContract
+        .connect(signer)
+        .consumeMessageFromL2(l1BatchNumber, proof.id, l1BatchTxIndex, eventData, proof.proof);
+      console.log("Message successfully consumed on L2");
+    } catch (error) {
+      console.error("Error calling consumeMessageFromL2:", error.message);
+    }
+  } else {
+    console.error("The result is false. Skipping the call");
+  }
+  process.exit();
+}
+
+async function getL1MessageProof(blockNumber, l1Provider, homeProxy, msgHash) {
+  console.log(`Getting L1 message proof for block ${blockNumber}`);
+  return await l1Provider.getMessageProof(blockNumber, homeProxy, msgHash);
+}
+
+async function proveL1MessageInclusion(l1BatchNumber, proof, trxIndex, l1Provider, l2Provider, homeProxy, message) {
+  const zkAddress = await l1Provider.getMainContractAddress();
+
+  const mailboxL1Contract = new ethers.Contract(zkAddress, utils.ZKSYNC_MAIN_ABI, l2Provider);
+  const messageInfo = {
+    txNumberInBlock: trxIndex,
+    sender: homeProxy,
+    data: message,
+  };
+
+  console.log(`Retrieving proof for batch ${l1BatchNumber}, transaction index ${trxIndex} and proof id ${proof.id}`);
+  const res = await mailboxL1Contract.proveL2MessageInclusion(l1BatchNumber, proof.id, messageInfo, proof.proof);
+
+  return res;
+}
+
+executeProof()
+  .then(() => {
+    console.log("Executed successfully!");
+  })
+  .catch((error) => {
+    console.error("Error:", error);
+  });