Feat/happy path(claimer) in validator-cli

validator-cli/.env.dist

@@ -3,28 +3,29 @@ PRIVATE_KEY=
 # Devnet RPCs
 RPC_CHIADO=https://rpc.chiadochain.net
 RPC_ARB_SEPOLIA=https://sepolia-rollup.arbitrum.io/rpc
-RPC_GNOSIS=https://rpc.chiadochain.net
-RPC_ARB=https://sepolia-rollup.arbitrum.io/rpc
 RPC_SEPOLIA=
 
 # Testnet or Mainnet RPCs
-RPC_ARB=
+RPC_ARB=https://sepolia-rollup.arbitrum.io/rpc
 RPC_ETH=
+RPC_GNOSIS=https://rpc.chiadochain.net
 
 # Testnet or Mainnet Addresses
+# VEA Arbitrum to Ethereum
 VEAINBOX_ARB_TO_ETH_ADDRESS=0xE12daFE59Bc3A996362d54b37DFd2BA9279cAd06
 VEAOUTBOX_ARB_TO_ETH_ADDRESS=0x209BFdC6B7c66b63A8382196Ba3d06619d0F12c9
+# VEA Arbitrum to GNOSIS
+VEAINBOX_ARB_TO_GNOSIS_ADDRESS=0x854374483572FFcD4d0225290346279d0718240b
+VEAOUTBOX_ARB_TO_GNOSIS_ADDRESS=0x2f1788F7B74e01c4C85578748290467A5f063B0b
+VEAROUTER_ARB_TO_GNOSIS_ADDRESS=0x5BE03fDE7794Bc188416ba16932510Ed1277b193
+GNOSIS_AMB_ADDRESS=0x8448E15d0e706C0298dECA99F0b4744030e59d7d
 
+VEAOUTBOX_CHAIN_ID=421611
 
 # Devnet Addresses
 VEAINBOX_ARBSEPOLIA_TO_SEPOLIA_ADDRESS=0x906dE43dBef27639b1688Ac46532a16dc07Ce410
 VEAOUTBOX_ARBSEPOLIA_TO_SEPOLIA_ADDRESS=0x906dE43dBef27639b1688Ac46532a16dc07Ce410
 
-#For arbToGnosis bridge
-VEAINBOX_ARB_TO_GNOSIS_ADDRESS=0x854374483572FFcD4d0225290346279d0718240b
-VEAOUTBOX_ARB_TO_GNOSIS_ADDRESS=0x2f1788F7B74e01c4C85578748290467A5f063B0b
-VEAROUTER_ARB_TO_GNOSIS_ADDRESS=0x5BE03fDE7794Bc188416ba16932510Ed1277b193
-GNOSIS_AMB_ADDRESS=0x8448E15d0e706C0298dECA99F0b4744030e59d7d
 
 TRANSACTION_BATCHER_CONTRACT_ADDRESS_SEPOLIA=0xe7953da7751063d0a41ba727c32c762d3523ade8
 TRANSACTION_BATCHER_CONTRACT_ADDRESS_CHIADO=0xcC0a08D4BCC5f91ee9a1587608f7a2975EA75d73

validator-cli/jest.config.ts

@@ -0,0 +1,10 @@
+import type { Config } from "jest";
+
+const config: Config = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  collectCoverage: true,
+  collectCoverageFrom: ["**/*.ts"],
+};
+
+export default config;

validator-cli/package.json

@@ -10,11 +10,12 @@
     "yarn": "4.2.2"
   },
   "scripts": {
-    "start": "npx ts-node ./src/ArbToEth/watcher.ts",
+    "start": "npx ts-node ./src/watcher.ts",
     "start-chiado-devnet": "npx ts-node ./src/devnet/arbToChiado/happyPath.ts",
     "start-sepolia-devnet": "npx ts-node ./src/devnet/arbToSepolia/happyPath.ts",
     "start-sepolia-testnet": "npx ts-node ./src/ArbToEth/watcherArbToEth.ts",
-    "start-arbitrum-to-gnosis": "npx ts-node ./src/ArbToEth/watcherArbToGnosis.ts"
+    "start-arbitrum-to-gnosis": "npx ts-node ./src/ArbToEth/watcherArbToGnosis.ts",
+    "test": "jest --coverage"
   },
   "dependencies": {
     "@arbitrum/sdk": "4.0.1",
@@ -28,6 +29,9 @@
     "web3-batched-send": "^1.0.3"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2"
   }
 }

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

@@ -0,0 +1,176 @@
+import { ethers } from "ethers";
+import { checkAndClaim } from "./claimer";
+import { ArbToEthTransactionHandler } from "./transactionHandler";
+import { ClaimHonestState } from "../utils/claim";
+import { start } from "pm2";
+describe("claimer", () => {
+  let veaOutbox: any;
+  let veaInbox: any;
+  let veaInboxProvider: any;
+  let veaOutboxProvider: any;
+  let emitter: any;
+  let mockGetClaim: any;
+  let mockClaim: any;
+  let mockGetLatestClaimedEpoch: any;
+  let mockDeps: any;
+  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: 100 }),
+    };
+    emitter = {
+      emit: jest.fn(),
+    };
+
+    mockGetClaim = jest.fn();
+    mockGetLatestClaimedEpoch = jest.fn();
+    mockDeps = {
+      epoch: 10,
+      epochPeriod: 10,
+      veaInbox,
+      veaInboxProvider,
+      veaOutboxProvider,
+      veaOutbox,
+      transactionHandler: null,
+      emitter,
+      fetchClaim: mockGetClaim,
+      fetchLatestClaimedEpoch: mockGetLatestClaimedEpoch,
+    };
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  describe("checkAndClaim", () => {
+    let mockTransactionHandler: any;
+    const mockTransactions = {
+      claimTxn: "0x111",
+      withdrawClaimDepositTxn: "0x222",
+      startVerificationTxn: "0x333",
+      verifySnapshotTxn: "0x444",
+    };
+    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();
+        }),
+        transactions: {
+          claimTxn: "0x0",
+          withdrawClaimDepositTxn: "0x0",
+          startVerificationTxn: "0x0",
+          verifySnapshotTxn: "0x0",
+        },
+      };
+    });
+    it("should return null if no claim is made for a passed epoch", async () => {
+      mockGetClaim = jest.fn().mockReturnValue(null);
+      mockDeps.epoch = 7; // claimable epoch - 3
+      mockDeps.fetchClaim = mockGetClaim;
+      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 () => {
+      mockGetClaim = jest.fn().mockReturnValue(null);
+      veaInbox.snapshots = jest.fn().mockResolvedValue(ethers.ZeroHash);
+      mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+        challenged: false,
+        stateroot: "0x1111",
+      });
+      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 () => {
+      mockGetClaim = jest.fn().mockReturnValue(null);
+      veaInbox.snapshots = jest.fn().mockResolvedValue(mockClaim.stateRoot);
+      mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+        challenged: false,
+        stateroot: "0x1111",
+      });
+      mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+      const result = await checkAndClaim(mockDeps);
+      expect(result).toBeNull();
+    });
+    it("should make a valid calim if no claim is made", async () => {
+      mockGetClaim = jest.fn().mockReturnValue(null);
+      veaInbox.snapshots = jest.fn().mockResolvedValue("0x7890");
+      mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+        challenged: false,
+        stateroot: mockClaim.stateRoot,
+      });
+      mockDeps.transactionHandler = mockTransactionHandler;
+      mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+      mockDeps.fetchClaim = mockGetClaim;
+      mockDeps.veaInbox = veaInbox;
+      const result = await checkAndClaim(mockDeps);
+      expect(result.transactions.claimTxn).toBe(mockTransactions.claimTxn);
+    });
+    it("should make a valid calim if last claim was challenged", async () => {
+      mockGetClaim = jest.fn().mockReturnValue(null);
+      veaInbox.snapshots = jest.fn().mockResolvedValue(mockClaim.stateRoot);
+      mockGetLatestClaimedEpoch = jest.fn().mockResolvedValue({
+        challenged: true,
+        stateroot: mockClaim.stateRoot,
+      });
+      mockDeps.transactionHandler = mockTransactionHandler;
+      mockDeps.fetchLatestClaimedEpoch = mockGetLatestClaimedEpoch;
+      mockDeps.fetchClaim = mockGetClaim;
+      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;
+
+      mockGetClaim = jest.fn().mockResolvedValue(mockClaim);
+      mockDeps.fetchClaim = mockGetClaim;
+      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;
+      mockGetClaim = jest.fn().mockResolvedValue(mockClaim);
+      mockDeps.fetchClaim = mockGetClaim;
+      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;
+      mockGetClaim = jest.fn().mockResolvedValue(mockClaim);
+      mockDeps.fetchClaim = mockGetClaim;
+      const result = await checkAndClaim(mockDeps);
+      expect(result.transactions.verifySnapshotTxn).toEqual(mockTransactions.verifySnapshotTxn);
+    });
+  });
+});

validator-cli/src/ArbToEth/claimer.ts

@@ -0,0 +1,75 @@
+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";
+interface checkAndClaimParams {
+  epochPeriod: number;
+  epoch: number;
+  veaInbox: any;
+  veaInboxProvider: JsonRpcProvider;
+  veaOutbox: any;
+  veaOutboxProvider: JsonRpcProvider;
+  transactionHandler: ArbToEthTransactionHandler | null;
+  emitter: EventEmitter;
+  fetchClaim?: typeof getClaim;
+  fetchLatestClaimedEpoch?: typeof getLastClaimedEpoch;
+}
+
+export async function checkAndClaim({
+  epoch,
+  epochPeriod,
+  veaInbox,
+  veaInboxProvider,
+  veaOutbox,
+  veaOutboxProvider,
+  transactionHandler,
+  emitter,
+  fetchClaim = getClaim,
+  fetchLatestClaimedEpoch = getLastClaimedEpoch,
+}: checkAndClaimParams) {
+  let outboxStateRoot = await veaOutbox.stateRoot();
+  const finalizedOutboxBlock = await veaOutboxProvider.getBlock("finalized");
+  const claimAbleEpoch = finalizedOutboxBlock.timestamp / epochPeriod;
+  const claim = await fetchClaim(veaOutbox, veaOutboxProvider, epoch, finalizedOutboxBlock.number, "finalized");
+  if (!transactionHandler) {
+    transactionHandler = new ArbToEthTransactionHandler(
+      epoch,
+      veaInbox,
+      veaOutbox,
+      veaInboxProvider,
+      veaOutboxProvider,
+      emitter,
+      claim
+    );
+  } else {
+    transactionHandler.claim = claim;
+  }
+  if (claim == null && epoch == claimAbleEpoch) {
+    const [savedSnapshot, claimData] = await Promise.all([veaInbox.snapshots(epoch), fetchLatestClaimedEpoch()]);
+    const newMessagesToBridge: boolean = savedSnapshot != outboxStateRoot && savedSnapshot != ethers.ZeroHash;
+    const lastClaimChallenged: boolean = claimData.challenged && savedSnapshot == outboxStateRoot;
+
+    if (newMessagesToBridge || lastClaimChallenged) {
+      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.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;
+}