feat(validator): saveSnapshot in watcher

Author: Mani Brar

validator-cli/src/utils/botConfig.ts

@@ -18,7 +18,10 @@ interface BotPathParams {
  * @param defaultPath - default path to use if not specified in the command line arguments
  * @returns BotPaths - the bot path (BotPaths)
  */
-export function getBotPath({ cliCommand, defaultPath = BotPaths.BOTH }: BotPathParams): number {
+export function getBotPath({ cliCommand, defaultPath = BotPaths.BOTH }: BotPathParams): {
+  path: number;
+  toSaveSnapshot: boolean;
+} {
   const args = cliCommand.slice(2);
   const pathFlag = args.find((arg) => arg.startsWith("--path="));
 
@@ -33,8 +36,9 @@ export function getBotPath({ cliCommand, defaultPath = BotPaths.BOTH }: BotPathP
   if (path && !(path in pathMapping)) {
     throw new InvalidBotPathError();
   }
-
-  return path ? pathMapping[path] : defaultPath;
+  const saveSnapshotFlag = args.find((a) => a.startsWith("--saveSnapshot"));
+  const toSaveSnapshot = saveSnapshotFlag ? true : false;
+  return path ? { path: pathMapping[path], toSaveSnapshot } : { path: defaultPath, toSaveSnapshot };
 }
 
 export interface NetworkConfig {

validator-cli/src/watcher.ts

@@ -1,6 +1,6 @@
 import { JsonRpcProvider } from "@ethersproject/providers";
 import { getBridgeConfig, Network } from "./consts/bridgeRoutes";
-import { getVeaInbox, getVeaOutbox } from "./utils/ethers";
+import { getTransactionHandler, getVeaInbox, getVeaOutbox } from "./utils/ethers";
 import { getBlockFromEpoch, setEpochRange } from "./utils/epochHandler";
 import { getClaimValidator, getClaimer } from "./utils/ethers";
 import { defaultEmitter } from "./utils/emitter";
@@ -12,6 +12,7 @@ import { getClaim } from "./utils/claim";
 import { MissingEnvError } from "./utils/errors";
 import { CheckAndClaimParams } from "./ArbToEth/claimer";
 import { ChallengeAndResolveClaimParams } from "./ArbToEth/validator";
+import { saveSnapshot, SaveSnapshotParams } from "./utils/snapshot";
 
 const RPC_BLOCK_LIMIT = 500; // RPC_BLOCK_LIMIT is the limit of blocks that can be queried at once
 
@@ -31,24 +32,25 @@ export const watch = async (
   const privKey = process.env.PRIVATE_KEY;
   if (!privKey) throw new MissingEnvError("PRIVATE_KEY");
   const cliCommand = process.argv;
-  const path = getBotPath({ cliCommand });
+  const { path, toSaveSnapshot } = getBotPath({ cliCommand });
   const networkConfigs = getNetworkConfig();
   emitter.emit(BotEvents.STARTED, path, networkConfigs[0].networks);
   const transactionHandlers: { [epoch: number]: any } = {};
-  const toWatch: { [key: string]: number[] } = {};
+  const toWatch: { [key: string]: { count: number; epochs: number[] } } = {};
   while (!shutDownSignal.getIsShutdownSignal()) {
     for (const networkConfig of networkConfigs) {
-      await processNetwork(path, networkConfig, transactionHandlers, toWatch, emitter);
+      await processNetwork(path, toSaveSnapshot, networkConfig, transactionHandlers, toWatch, emitter);
     }
     await wait(1000 * 10);
   }
 };
 
 async function processNetwork(
   path: number,
+  toSaveSnapshot: boolean,
   networkConfig: NetworkConfig,
   transactionHandlers: { [epoch: number]: any },
-  toWatch: { [key: string]: number[] },
+  toWatch: { [key: string]: { count: number; epochs: number[] } },
   emitter: typeof defaultEmitter
 ): Promise<void> {
   const { chainId, networks } = networkConfig;
@@ -57,27 +59,27 @@ async function processNetwork(
     emitter.emit(BotEvents.WATCHING, chainId, network);
     const networkKey = `${chainId}_${network}`;
     if (!toWatch[networkKey]) {
-      toWatch[networkKey] = [];
+      toWatch[networkKey] = { count: -1, epochs: [] };
     }
-
     const veaOutboxProvider = new JsonRpcProvider(outboxRPC);
     let veaOutboxLatestBlock = await veaOutboxProvider.getBlock("latest");
 
     // If the watcher has already started, only check the latest epoch
     if (network == Network.DEVNET) {
-      toWatch[networkKey] = [Math.floor(veaOutboxLatestBlock.timestamp / routeConfig[network].epochPeriod)];
-    } else if (toWatch[networkKey].length == 0) {
+      toWatch[networkKey].epochs = [Math.floor(veaOutboxLatestBlock.timestamp / routeConfig[network].epochPeriod)];
+    } else if (toWatch[networkKey].epochs.length == 0) {
       const epochRange = setEpochRange({
         chainId,
         currentTimestamp: veaOutboxLatestBlock.timestamp,
         epochPeriod: routeConfig[network].epochPeriod,
       });
-      toWatch[networkKey] = epochRange;
+      toWatch[networkKey].epochs = epochRange;
     }
 
     await processEpochsForNetwork({
       chainId,
       path,
+      toSaveSnapshot,
       networkKey,
       network,
       routeConfig,
@@ -88,30 +90,33 @@ async function processNetwork(
       emitter,
     });
     const currentLatestBlock = await veaOutboxProvider.getBlock("latest");
-    const currentLatestEpoch = Math.floor(currentLatestBlock.timestamp / routeConfig[network].epochPeriod);
+    const currentClaimableEpoch = Math.floor(currentLatestBlock.timestamp / routeConfig[network].epochPeriod) - 1;
+
     const toWatchEpochs = toWatch[networkKey];
-    const lastEpochInToWatch = toWatchEpochs[toWatchEpochs.length - 1];
-    if (currentLatestEpoch > lastEpochInToWatch) {
-      toWatch[networkKey].push(currentLatestEpoch);
+    const lastEpochInToWatch = toWatchEpochs[toWatchEpochs.epochs.length - 1];
+    if (currentClaimableEpoch > lastEpochInToWatch) {
+      toWatch[networkKey].epochs.push(currentClaimableEpoch);
     }
   }
 }
 
 interface ProcessEpochParams {
   chainId: number;
   path: number;
+  toSaveSnapshot: boolean;
   networkKey: string;
   network: Network;
   routeConfig: any;
   inboxRPC: string;
   outboxRPC: string;
-  toWatch: { [key: string]: number[] };
+  toWatch: { [key: string]: { count: number; epochs: number[] } };
   transactionHandlers: { [epoch: number]: any };
   emitter: typeof defaultEmitter;
 }
 async function processEpochsForNetwork({
   chainId,
   path,
+  toSaveSnapshot,
   networkKey,
   network,
   routeConfig,
@@ -126,10 +131,39 @@ async function processEpochsForNetwork({
   const veaOutbox = getVeaOutbox(routeConfig[network].veaOutbox.address, privKey, outboxRPC, chainId, network);
   const veaInboxProvider = new JsonRpcProvider(inboxRPC);
   const veaOutboxProvider = new JsonRpcProvider(outboxRPC);
-  let i = toWatch[networkKey].length - 1;
-  const latestEpoch = toWatch[networkKey][i];
+  let i = toWatch[networkKey].epochs.length - 1;
+  const latestEpoch = toWatch[networkKey].epochs[i];
+  const currentEpoch = Math.floor(Date.now() / (1000 * routeConfig[network].epochPeriod));
+  // Checks and saves the snapshot if needed
+  if (toSaveSnapshot) {
+    const TransactionHandler = getTransactionHandler(chainId, network) as any;
+    const transactionHandler =
+      transactionHandlers[currentEpoch] ||
+      new TransactionHandler({
+        network,
+        epoch: currentEpoch,
+        veaInbox,
+        veaOutbox,
+        veaInboxProvider,
+        veaOutboxProvider,
+        emitter,
+      });
+    const { updatedTransactionHandler, latestCount } = await saveSnapshot({
+      veaInbox,
+      network,
+      epochPeriod: routeConfig[network].epochPeriod,
+      count: toWatch[networkKey].count,
+      transactionHandler,
+    } as SaveSnapshotParams);
+    const count = toWatch[networkKey].count;
+    if (count == -1 || count != latestCount) {
+      transactionHandlers[currentEpoch] = updatedTransactionHandler;
+      toWatch[networkKey].count = latestCount;
+    }
+  }
+
   while (i >= 0) {
-    const epoch = toWatch[networkKey][i];
+    const epoch = toWatch[networkKey].epochs[i];
     const epochBlock = await getBlockFromEpoch(epoch, routeConfig[network].epochPeriod, veaOutboxProvider);
     const latestBlock = await veaOutboxProvider.getBlock("latest");
     let toBlock: number | string = "latest";
@@ -142,6 +176,7 @@ async function processEpochsForNetwork({
     const checkAndChallengeResolve = getClaimValidator(chainId, network);
     const checkAndClaim = getClaimer(chainId, network);
     let updatedTransactions;
+
     if (path > BotPaths.CLAIMER && claim != null) {
       const checkAndChallengeResolveDeps: ChallengeAndResolveClaimParams = {
         claim,
@@ -177,7 +212,7 @@ async function processEpochsForNetwork({
       transactionHandlers[epoch] = updatedTransactions;
     } else if (epoch != latestEpoch) {
       delete transactionHandlers[epoch];
-      toWatch[networkKey].splice(i, 1);
+      toWatch[networkKey].epochs.splice(i, 1);
     }
     i--;
   }