Feat/happy path(claimer) in validator-cli

validator-cli/.env.dist

@@ -1,10 +1,16 @@
 PRIVATE_KEY=
 
+# Networks: devnet, testnet, mainnet
+NETWORKS=devnet,testnet
+
 # Devnet RPCs
 RPC_CHIADO=https://rpc.chiadochain.net
 RPC_ARB_SEPOLIA=https://sepolia-rollup.arbitrum.io/rpc
 RPC_SEPOLIA=
 
+# Devnet Owner
+DEVNET_OWNER=0x5f4eC3Df9Cf2f0f1fDfCfCfCfCfCfCfCfCfCfCfC
+
 # Testnet or Mainnet RPCs
 RPC_ARB=https://sepolia-rollup.arbitrum.io/rpc
 RPC_ETH=
@@ -20,7 +26,8 @@ VEAOUTBOX_ARB_TO_GNOSIS_ADDRESS=0x2f1788F7B74e01c4C85578748290467A5f063B0b
 VEAROUTER_ARB_TO_GNOSIS_ADDRESS=0x5BE03fDE7794Bc188416ba16932510Ed1277b193
 GNOSIS_AMB_ADDRESS=0x8448E15d0e706C0298dECA99F0b4744030e59d7d
 
-VEAOUTBOX_CHAIN_ID=421611
+VEAOUTBOX_CHAINS=11155111,421611
+VEAOUTBOX_SUBGRAPH=https://api.studio.thegraph.com/query/user/outbox-arb-sep/version/latest
 
 # Devnet Addresses
 VEAINBOX_ARBSEPOLIA_TO_SEPOLIA_ADDRESS=0x906dE43dBef27639b1688Ac46532a16dc07Ce410

validator-cli/src/ArbToEth/claimer.test.ts

@@ -0,0 +1,234 @@
+import { ethers } from "ethers";
+import { checkAndClaim, CheckAndClaimParams } from "./claimer";
+import { ClaimHonestState } from "../utils/claim";
+import { Network } from "../consts/bridgeRoutes";
+
+describe("claimer", () => {
+  const NETWORK = Network.DEVNET;
+  let veaOutbox: any;
+  let veaInbox: any;
+  let veaInboxProvider: any;
+  let veaOutboxProvider: any;
+  let emitter: any;
+  let mockClaim: any;
+  let mockGetLatestClaimedEpoch: any;
+  let mockGetTransactionHandler: any;
+  let mockDeps: CheckAndClaimParams;
+
+  let mockTransactionHandler: any;
+  const mockTransactions = {
+    claimTxn: "0x111",
+    withdrawClaimDepositTxn: "0x222",
+    startVerificationTxn: "0x333",
+    verifySnapshotTxn: "0x444",
+    devnetAdvanceStateTxn: "0x555",
+  };
+  beforeEach(() => {
+    mockClaim = {
+      stateRoot: "0x1234",
+      claimer: "0xFa00D29d378EDC57AA1006946F0fc6230a5E3288",
+      timestampClaimed: 1234,
+      timestampVerification: 0,
+      blocknumberVerification: 0,
+      honest: 0,
+      challenger: ethers.ZeroAddress,
+    };
+    veaInbox = {
+      snapshots: jest.fn().mockResolvedValue(mockClaim.stateRoot),
+    };
+
+    veaOutbox = {
+      stateRoot: jest.fn().mockResolvedValue(mockClaim.stateRoot),
+    };
+    veaOutboxProvider = {
+      getBlock: jest.fn().mockResolvedValue({ number: 0, timestamp: 110 }),
+    };
+    emitter = {
+      emit: jest.fn(),
+    };
+
+    mockGetLatestClaimedEpoch = jest.fn();
+    mockGetTransactionHandler = jest.fn().mockReturnValue(function DummyTransactionHandler(params: any) {
+      // Return an object that matches our expected transaction handler.
+      return mockTransactionHandler;
+    });
+    mockDeps = {
+      chainId: 0,
+      claim: mockClaim,
+      network: NETWORK,
+      epoch: 10,
+      epochPeriod: 10,
+      veaInbox,
+      veaInboxProvider,
+      veaOutboxProvider,
+      veaOutbox,
+      transactionHandler: null,
+      emitter,
+      fetchLatestClaimedEpoch: mockGetLatestClaimedEpoch,
+      now: 110000, // (epoch+ 1) * epochPeriod * 1000 for claimable epoch
+    };
+
+    mockTransactionHandler = {
+      withdrawClaimDeposit: jest.fn().mockImplementation(() => {
+        mockTransactionHandler.transactions.withdrawClaimDepositTxn = mockTransactions.withdrawClaimDepositTxn;
+        return Promise.resolve();
+      }),
+      makeClaim: jest.fn().mockImplementation(() => {
+        mockTransactionHandler.transactions.claimTxn = mockTransactions.claimTxn;
+        return Promise.resolve();
+      }),
+      startVerification: jest.fn().mockImplementation(() => {
+        mockTransactionHandler.transactions.startVerificationTxn = mockTransactions.startVerificationTxn;
+        return Promise.resolve();
+      }),
+      verifySnapshot: jest.fn().mockImplementation(() => {
+        mockTransactionHandler.transactions.verifySnapshotTxn = mockTransactions.verifySnapshotTxn;
+        return Promise.resolve();
+      }),
+      transactions: {
+        claimTxn: "0x0",
+        withdrawClaimDepositTxn: "0x0",
+        startVerificationTxn: "0x0",
+        verifySnapshotTxn: "0x0",
+      },
+    };
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  describe("checkAndClaim", () => {
+    beforeEach(() => {
+      mockTransactionHandler = {
+        withdrawClaimDeposit: jest.fn().mockImplementation(() => {
+          mockTransactionHandler.transactions.withdrawClaimDepositTxn = mockTransactions.withdrawClaimDepositTxn;
+          return Promise.resolve();
+        }),
+        makeClaim: jest.fn().mockImplementation(() => {
+          mockTransactionHandler.transactions.claimTxn = mockTransactions.claimTxn;
+          return Promise.resolve();
+        }),
+        startVerification: jest.fn().mockImplementation(() => {
+          mockTransactionHandler.transactions.startVerificationTxn = mockTransactions.startVerificationTxn;
+          return Promise.resolve();
+        }),
+        verifySnapshot: jest.fn().mockImplementation(() => {
+          mockTransactionHandler.transactions.verifySnapshotTxn = mockTransactions.verifySnapshotTxn;
+          return Promise.resolve();
+        }),
+        devnetAdvanceState: jest.fn().mockImplementation(() => {
+          mockTransactionHandler.transactions.devnetAdvanceStateTxn = mockTransactions.devnetAdvanceStateTxn;
+          return Promise.resolve();
+        }),
+        transactions: {
+          claimTxn: "0x0",
+          withdrawClaimDepositTxn: "0x0",
+          startVerificationTxn: "0x0",
+          verifySnapshotTxn: "0x0",
+        },
+      };
+      mockGetTransactionHandler = jest.fn().mockReturnValue(function DummyTransactionHandler(param: any) {
+        return mockTransactionHandler;
+      });
+      mockDeps.fetchTransactionHandler = mockGetTransactionHandler;
+    });
+    it("should return null if no claim is made for a passed epoch", async () => {
+      mockDeps.epoch = 7; // claimable epoch - 3
+      mockDeps.claim = null;
+
+      mockDeps.fetchTransactionHandler = mockGetTransactionHandler;
+      const result = await checkAndClaim(mockDeps);
+      expect(result).toBeNull();
+    });
+    it("should return null if no snapshot is saved on the inbox for a claimable epoch", async () => {
+      veaInbox.snapshots = jest.fn().mockResolvedValue(ethers.ZeroHash);
+      mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+        challenged: false,
+        stateroot: "0x1111",
+      });
+      mockDeps.claim = null;
+      mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+      const result = await checkAndClaim(mockDeps);
+      expect(result).toBeNull();
+    });
+    it("should return null if there are no new messages in the inbox", async () => {
+      veaInbox.snapshots = jest.fn().mockResolvedValue(mockClaim.stateRoot);
+      mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+        challenged: false,
+        stateroot: "0x1111",
+      });
+      mockDeps.claim = null;
+      mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+      const result = await checkAndClaim(mockDeps);
+      expect(result).toBeNull();
+    });
+    describe("devnet", () => {
+      beforeEach(() => {
+        mockDeps.network = Network.DEVNET;
+      });
+      it("should make a valid claim and advance state", async () => {
+        veaInbox.snapshots = jest.fn().mockResolvedValue("0x7890");
+        mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+          challenged: false,
+          stateroot: mockClaim.stateRoot,
+        });
+        mockDeps.transactionHandler = mockTransactionHandler;
+        mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+        mockDeps.claim = null;
+        mockDeps.veaInbox = veaInbox;
+        const result = await checkAndClaim(mockDeps);
+        expect(result.transactions.devnetAdvanceStateTxn).toBe(mockTransactions.devnetAdvanceStateTxn);
+      });
+    });
+    describe("testnet", () => {
+      beforeEach(() => {
+        mockDeps.network = Network.TESTNET;
+      });
+      it("should make a valid claim if no claim is made", async () => {
+        veaInbox.snapshots = jest.fn().mockResolvedValue("0x7890");
+        mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+          challenged: false,
+          stateroot: mockClaim.stateRoot,
+        });
+        mockDeps.transactionHandler = mockTransactionHandler;
+        mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+        mockDeps.claim = null;
+        mockDeps.veaInbox = veaInbox;
+        const result = await checkAndClaim(mockDeps);
+        expect(result.transactions.claimTxn).toBe(mockTransactions.claimTxn);
+      });
+      it("should make a valid claim if last claim was challenged", async () => {
+        veaInbox.snapshots = jest.fn().mockResolvedValue(mockClaim.stateRoot);
+        mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+          challenged: true,
+          stateroot: mockClaim.stateRoot,
+        });
+        mockDeps.transactionHandler = mockTransactionHandler;
+        mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+        mockDeps.claim = null;
+        mockDeps.veaInbox = veaInbox;
+        const result = await checkAndClaim(mockDeps);
+        expect(result.transactions.claimTxn).toEqual(mockTransactions.claimTxn);
+      });
+      it("should withdraw claim deposit if claimer is honest", async () => {
+        mockDeps.transactionHandler = mockTransactionHandler;
+        mockClaim.honest = ClaimHonestState.CLAIMER;
+        const result = await checkAndClaim(mockDeps);
+        expect(result.transactions.withdrawClaimDepositTxn).toEqual(mockTransactions.withdrawClaimDepositTxn);
+      });
+      it("should start verification if verification is not started", async () => {
+        mockDeps.transactionHandler = mockTransactionHandler;
+        mockClaim.honest = ClaimHonestState.NONE;
+        const result = await checkAndClaim(mockDeps);
+        expect(result.transactions.startVerificationTxn).toEqual(mockTransactions.startVerificationTxn);
+      });
+      it("should verify snapshot if verification is started", async () => {
+        mockDeps.transactionHandler = mockTransactionHandler;
+        mockClaim.honest = ClaimHonestState.NONE;
+        mockClaim.timestampVerification = 1234;
+        mockDeps.claim = mockClaim;
+        const result = await checkAndClaim(mockDeps);
+        expect(result.transactions.verifySnapshotTxn).toEqual(mockTransactions.verifySnapshotTxn);
+      });
+    });
+  });
+});

validator-cli/src/ArbToEth/claimer.ts

@@ -0,0 +1,116 @@
+import { EventEmitter } from "events";
+import { ethers } from "ethers";
+import { JsonRpcProvider } from "@ethersproject/providers";
+import { getClaim, ClaimHonestState } from "../utils/claim";
+import { getLastClaimedEpoch } from "../utils/graphQueries";
+import { ArbToEthTransactionHandler } from "./transactionHandler";
+import { BotEvents } from "../utils/botEvents";
+import { ClaimStruct } from "@kleros/vea-contracts/typechain-types/arbitrumToEth/VeaInboxArbToEth";
+import { ArbToEthDevnetTransactionHandler } from "./transactionHandlerDevnet";
+import { getTransactionHandler } from "../utils/ethers";
+import { Network } from "../consts/bridgeRoutes";
+interface CheckAndClaimParams {
+  chainId: number;
+  network: Network;
+  claim: ClaimStruct | null;
+  epochPeriod: number;
+  epoch: number;
+  veaInbox: any;
+  veaInboxProvider: JsonRpcProvider;
+  veaOutbox: any;
+  veaOutboxProvider: JsonRpcProvider;
+  transactionHandler: ArbToEthTransactionHandler | null;
+  emitter: EventEmitter;
+  fetchClaim?: typeof getClaim;
+  fetchLatestClaimedEpoch?: typeof getLastClaimedEpoch;
+  fetchTransactionHandler?: typeof getTransactionHandler;
+  now?: number;
+}
+
+async function checkAndClaim({
+  chainId,
+  network,
+  claim,
+  epoch,
+  epochPeriod,
+  veaInbox,
+  veaInboxProvider,
+  veaOutbox,
+  veaOutboxProvider,
+  transactionHandler,
+  emitter,
+  fetchLatestClaimedEpoch = getLastClaimedEpoch,
+  fetchTransactionHandler = getTransactionHandler,
+  now = Date.now(),
+}: CheckAndClaimParams) {
+  let outboxStateRoot = await veaOutbox.stateRoot();
+  const finalizedOutboxBlock = await veaOutboxProvider.getBlock("finalized");
+  const claimAbleEpoch = Math.floor(now / (1000 * epochPeriod)) - 1;
+  if (!transactionHandler) {
+    const TransactionHandler = fetchTransactionHandler(chainId, network);
+    transactionHandler = new TransactionHandler({
+      network,
+      epoch,
+      veaInbox,
+      veaOutbox,
+      veaInboxProvider,
+      veaOutboxProvider,
+      emitter,
+      claim,
+    });
+  } else {
+    transactionHandler.claim = claim;
+  }
+  var savedSnapshot;
+  var claimData;
+  var newMessagesToBridge: boolean;
+  var lastClaimChallenged: boolean;
+
+  if (network == Network.DEVNET) {
+    const devnetTransactionHandler = transactionHandler as ArbToEthDevnetTransactionHandler;
+    if (claim == null) {
+      [savedSnapshot, claimData] = await Promise.all([
+        veaInbox.snapshots(epoch),
+        fetchLatestClaimedEpoch(veaOutbox.target),
+      ]);
+
+      newMessagesToBridge = savedSnapshot != outboxStateRoot && savedSnapshot != ethers.ZeroHash;
+      if (newMessagesToBridge && savedSnapshot != ethers.ZeroHash) {
+        await devnetTransactionHandler.devnetAdvanceState(savedSnapshot);
+        return devnetTransactionHandler;
+      }
+    }
+  } else if (claim == null && epoch == claimAbleEpoch) {
+    [savedSnapshot, claimData] = await Promise.all([
+      veaInbox.snapshots(epoch),
+      fetchLatestClaimedEpoch(veaOutbox.target),
+    ]);
+    newMessagesToBridge = savedSnapshot != outboxStateRoot && savedSnapshot != ethers.ZeroHash;
+    lastClaimChallenged = claimData.challenged && savedSnapshot == outboxStateRoot;
+    if ((newMessagesToBridge || lastClaimChallenged) && savedSnapshot != ethers.ZeroHash) {
+      await transactionHandler.makeClaim(savedSnapshot);
+      return transactionHandler;
+    }
+  } else if (claim != null) {
+    if (claim.honest == ClaimHonestState.CLAIMER) {
+      await transactionHandler.withdrawClaimDeposit();
+      return transactionHandler;
+    } else if (claim.honest == ClaimHonestState.NONE) {
+      if (claim.challenger != ethers.ZeroAddress) {
+        emitter.emit(BotEvents.CLAIM_CHALLENGED, epoch);
+        return transactionHandler;
+      }
+      if (claim.timestampVerification == 0) {
+        await transactionHandler.startVerification(finalizedOutboxBlock.timestamp);
+      } else {
+        await transactionHandler.verifySnapshot(finalizedOutboxBlock.timestamp);
+      }
+      return transactionHandler;
+    }
+  } else {
+    emitter.emit(BotEvents.CLAIM_EPOCH_PASSED, epoch);
+  }
+  return null;
+}
+
+export { checkAndClaim, CheckAndClaimParams };