Feat/happy path(claimer) in validator-cli

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