test(arbToGno): honest claim - dishonest challenge - bridger paid, challenger deposit forfeited

Author: madhurMongia

contracts/test/integration/ArbToGnosis.ts

@@ -349,4 +349,191 @@ describe("Arbitrum to Gnosis Bridge Tests", async () => {
       expect(finalBalance.sub(initialBalance)).to.equal(TEN_ETH, "Incorrect withdrawal amount");
     });
   });
+
+  describe("Honest Claim - Dishonest Challenge - Bridger paid, challenger deposit forfeited", async () => {
+    let epoch: number;
+    let batchMerkleRoot: string;
+
+    beforeEach(async () => {
+      // Setup: Send message and save snapshot on Arbitrum
+      await senderGateway.connect(sender).sendMessage(1121);
+      await veaInbox.connect(bridger).saveSnapshot();
+
+      const BatchOutgoing = veaInbox.filters.SnapshotSaved();
+      const batchOutGoingEvent = await veaInbox.queryFilter(BatchOutgoing);
+      epoch = Math.floor((await batchOutGoingEvent[0].getBlock()).timestamp / EPOCH_PERIOD);
+      batchMerkleRoot = await veaInbox.snapshots(epoch);
+
+      // Advance time to next epoch
+      await network.provider.send("evm_increaseTime", [EPOCH_PERIOD]);
+      await network.provider.send("evm_mine");
+
+      // Ensure bridger and challenger have enough WETH
+      await weth.transfer(bridger.address, TEN_ETH.mul(2));
+      await weth.transfer(challenger.address, TEN_ETH.mul(2));
+
+      // Approve WETH spending for both
+      await weth.connect(bridger).approve(veaOutbox.address, TEN_ETH.mul(2));
+      await weth.connect(challenger).approve(veaOutbox.address, TEN_ETH.mul(2));
+      await amb.setMaxGasPerTx(100000);
+    });
+
+    it("should allow challenger to submit a challenge", async () => {
+      const { claimBlock, challengeTx } = await setupClaimAndChallenge(epoch, batchMerkleRoot, 0);
+
+      await expect(challengeTx).to.emit(veaOutbox, "Challenged").withArgs(epoch, challenger.address);
+    });
+
+    it("should handle the entire cross-chain dispute resolution process", async () => {
+      const { claimBlock } = await setupClaimAndChallenge(epoch, batchMerkleRoot, 0);
+
+      const sendSnapshotTx = await veaInbox.connect(bridger).sendSnapshot(
+        epoch,
+        100000,
+        {
+          stateRoot: batchMerkleRoot,
+          claimer: bridger.address,
+          timestampClaimed: claimBlock.timestamp,
+          timestampVerification: 0,
+          blocknumberVerification: 0,
+          honest: 0,
+          challenger: challenger.address,
+        },
+        { gasLimit: 100000 }
+      );
+
+      await expect(sendSnapshotTx)
+        .to.emit(veaInbox, "SnapshotSent")
+        .withArgs(epoch, ethers.utils.formatBytes32String(""));
+
+      await network.provider.send("evm_increaseTime", [EPOCH_PERIOD]);
+      await network.provider.send("evm_mine");
+
+      const routerEvents = await router.queryFilter(router.filters.Routed(), sendSnapshotTx.blockNumber);
+      expect(routerEvents.length).to.equal(1, "Expected one Routed event");
+      const routedEvent = routerEvents[0];
+      expect(routedEvent.args._epoch).to.equal(epoch, "Routed event epoch mismatch");
+      expect(routedEvent.args._ticketID).to.not.equal(
+        ethers.constants.HashZero,
+        "Routed event ticketID should not be zero"
+      );
+
+      // Simulate time passing for claim and challenge period
+      await network.provider.send("evm_increaseTime", [CHALLENGE_PERIOD + SEQUENCER_DELAY]);
+      await network.provider.send("evm_mine");
+
+      const events = await amb.queryFilter(amb.filters.MockedEvent());
+      expect(events.length).to.be.above(0, "No MockedEvent emitted");
+
+      // Simulate the passage of time
+      await network.provider.send("evm_increaseTime", [EPOCH_PERIOD]);
+      await network.provider.send("evm_mine");
+
+      const lastEvent = events[events.length - 1];
+
+      await amb.executeMessageCall(
+        veaOutbox.address,
+        router.address,
+        lastEvent.args._data,
+        lastEvent.args.messageId,
+        1000000
+      );
+
+      expect(await amb.messageCallStatus(lastEvent.args.messageId)).to.be.true;
+
+      // Check for Verified event
+      const verifiedEvents = await veaOutbox.queryFilter(veaOutbox.filters.Verified());
+      expect(verifiedEvents.length).to.equal(1, "Expected one Verified event");
+      const verifiedEvent = verifiedEvents[0];
+      expect(verifiedEvent.args._epoch).to.equal(epoch, "Verified event epoch mismatch");
+
+      expect(await veaOutbox.stateRoot()).to.equal(batchMerkleRoot, "VeaOutbox stateRoot should be updated");
+      expect(await veaOutbox.latestVerifiedEpoch()).to.equal(epoch, "VeaOutbox latestVerifiedEpoch should be updated");
+    });
+
+    it("should allow bridger to withdraw deposit plus reward", async () => {
+      const { claimBlock } = await setupClaimAndChallenge(epoch, batchMerkleRoot, 0);
+
+      await simulateDisputeResolution(epoch, {
+        stateRoot: batchMerkleRoot,
+        claimer: bridger.address,
+        timestampClaimed: claimBlock.timestamp,
+        timestampVerification: 0,
+        blocknumberVerification: 0,
+        honest: 0,
+        challenger: challenger.address,
+      });
+
+      const bridgerInitialBalance = await weth.balanceOf(bridger.address);
+      await veaOutbox.connect(bridger).withdrawClaimDeposit(epoch, {
+        stateRoot: batchMerkleRoot,
+        claimer: bridger.address,
+        timestampClaimed: claimBlock.timestamp,
+        timestampVerification: 0,
+        blocknumberVerification: 0,
+        honest: 1,
+        challenger: challenger.address,
+      });
+      const bridgerFinalBalance = await weth.balanceOf(bridger.address);
+      expect(bridgerFinalBalance.sub(bridgerInitialBalance)).to.equal(
+        TEN_ETH.add(TEN_ETH.div(2)),
+        "Incorrect withdrawal amount"
+      );
+    });
+
+    it("should not allow challenger to withdraw deposit", async () => {
+      const { claimBlock } = await setupClaimAndChallenge(epoch, batchMerkleRoot, 0);
+
+      await simulateDisputeResolution(epoch, {
+        stateRoot: batchMerkleRoot,
+        claimer: bridger.address,
+        timestampClaimed: claimBlock.timestamp,
+        timestampVerification: 0,
+        blocknumberVerification: 0,
+        honest: 0,
+        challenger: challenger.address,
+      });
+
+      await expect(
+        veaOutbox.connect(challenger).withdrawChallengeDeposit(epoch, {
+          stateRoot: batchMerkleRoot,
+          claimer: bridger.address,
+          timestampClaimed: claimBlock.timestamp,
+          timestampVerification: 0,
+          blocknumberVerification: 0,
+          honest: 1,
+          challenger: challenger.address,
+        })
+      ).to.be.revertedWith("Challenge failed.");
+    });
+
+    it("should allow message relay after dispute resolution", async () => {
+      const { claimBlock } = await setupClaimAndChallenge(epoch, batchMerkleRoot, 0);
+
+      await simulateDisputeResolution(epoch, {
+        stateRoot: batchMerkleRoot,
+        claimer: bridger.address,
+        timestampClaimed: claimBlock.timestamp,
+        timestampVerification: 0,
+        blocknumberVerification: 0,
+        honest: 0,
+        challenger: challenger.address,
+      });
+
+      const MessageSent = veaInbox.filters.MessageSent();
+      const MessageSentEvent = await veaInbox.queryFilter(MessageSent);
+      const msg = MessageSentEvent[0].args._nodeData;
+      const nonce = "0x" + msg.slice(2, 18);
+      const to = "0x" + msg.slice(18, 58);
+      const msgData = "0x" + msg.slice(58);
+
+      let nodes: string[] = [];
+      nodes.push(MerkleTree.makeLeafNode(nonce, to, msgData));
+      const mt = new MerkleTree(nodes);
+      const proof = mt.getHexProof(nodes[0]);
+
+      const relayTx = await veaOutbox.connect(receiver).sendMessage(proof, 0, receiverGateway.address, msgData);
+      await expect(relayTx).to.emit(veaOutbox, "MessageRelayed").withArgs(0);
+    });
+  });
 });