Feat(validator)/claimer

validator-cli/.env.dist

@@ -1,31 +1,20 @@
 PRIVATE_KEY=
 
-# Devnet RPCs
-RPC_CHIADO=https://rpc.chiadochain.net
-RPC_ARB_SEPOLIA=https://sepolia-rollup.arbitrum.io/rpc
-RPC_SEPOLIA=
+# Networks: devnet, testnet, mainnet
+NETWORKS=devnet,testnet
 
-# Testnet or Mainnet RPCs
+
+# RPCs
 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
+GNOSIS_AMB_ADDRESS=0x8448E15d0e706C0298dECA99F0b4744030e59d7d
 
-# Devnet Addresses
-VEAINBOX_ARBSEPOLIA_TO_SEPOLIA_ADDRESS=0x906dE43dBef27639b1688Ac46532a16dc07Ce410
-VEAOUTBOX_ARBSEPOLIA_TO_SEPOLIA_ADDRESS=0x906dE43dBef27639b1688Ac46532a16dc07Ce410
+VEAOUTBOX_CHAINS=11155111,421611
 
+# vescan subgraph endpoints
+VEAINBOX_SUBGRAPH=https://api.studio.thegraph.com/query/user/inbox-arb-sep/version/latest
+VEAOUTBOX_SUBGRAPH=https://api.studio.thegraph.com/query/user/outbox-arb-sep/version/latest
 
-TRANSACTION_BATCHER_CONTRACT_ADDRESS_SEPOLIA=0xe7953da7751063d0a41ba727c32c762d3523ade8
-TRANSACTION_BATCHER_CONTRACT_ADDRESS_CHIADO=0xcC0a08D4BCC5f91ee9a1587608f7a2975EA75d73

validator-cli/ecosystem.config.js

@@ -1,27 +1,16 @@
 module.exports = {
   apps: [
     {
-      name: "chiado-devnet",
-      script: "yarn",
-      args: "start-chiado-devnet",
-      interpreter: "/bin/bash",
+      name: "validator-cli",
+      script: "./src/watcher.ts",
+      interpreter: "../node_modules/.bin/ts-node",
+      interpreter_args: "--project tsconfig.json -r tsconfig-paths/register",
       log_date_format: "YYYY-MM-DD HH:mm Z",
-      watch: false,
-      autorestart: false,
-      env: {
-        NODE_ENV: "development",
-      },
-    },
-    {
-      name: "start-sepolia-devnet",
-      script: "yarn",
-      args: "start-sepolia-devnet",
-      interpreter: "/bin/bash",
-      log_date_format: "YYYY-MM-DD HH:mm Z",
-      watch: false,
-      autorestart: false,
+      watch: true,
+      autorestart: true,
       env: {
         NODE_ENV: "development",
+        TS_NODE_PROJECT: "./tsconfig.json",
       },
     },
   ],

validator-cli/package.json

@@ -22,10 +22,8 @@
     "@kleros/vea-contracts": "workspace:^",
     "@typechain/ethers-v6": "^0.5.1",
     "dotenv": "^16.4.5",
-    "pm2": "^5.2.2",
-    "typescript": "^4.9.5",
-    "web3": "^4.16.0",
-    "web3-batched-send": "^1.0.3"
+    "pm2": "^6.0.5",
+    "typescript": "^4.9.5"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

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);
+      });
+    });
+  });
+});