@lodestar/validator 1.49.0-dev.ae6cc426f1 → 1.49.0-dev.c535e94f25

package/src/slashingProtection/interchange/formats/v5.ts

@@ -1,5 +1,5 @@
 import {fromHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {fromOptionalHexString, numToString, toOptionalHexString} from "../../utils.js";
+import {fromOptionalHexString, numToString, stringToNum, toOptionalHexString} from "../../utils.js";
 import {InterchangeLodestar} from "../types.js";
 
 /**
@@ -107,12 +107,12 @@ export function parseInterchangeV5(interchange: InterchangeV5): InterchangeLodes
     data: interchange.data.map((validator) => ({
       pubkey: fromHex(validator.pubkey),
       signedBlocks: validator.signed_blocks.map((block) => ({
-        slot: parseInt(block.slot, 10),
+        slot: stringToNum(block.slot),
         signingRoot: fromOptionalHexString(block.signing_root),
       })),
       signedAttestations: validator.signed_attestations.map((att) => ({
-        sourceEpoch: parseInt(att.source_epoch, 10),
-        targetEpoch: parseInt(att.target_epoch, 10),
+        sourceEpoch: stringToNum(att.source_epoch),
+        targetEpoch: stringToNum(att.target_epoch),
         signingRoot: fromOptionalHexString(att.signing_root),
       })),
     })),

package/src/slashingProtection/interface.ts

@@ -18,7 +18,16 @@ export interface ISlashingProtection {
    */
   hasAttestedInEpoch(pubKey: BLSPubkey, epoch: Epoch): Promise<boolean>;
 
-  importInterchange(interchange: Interchange, genesisValidatorsRoot: Uint8Array | Root, logger?: Logger): Promise<void>;
+  /**
+   * Import an EIP-3076 interchange, rejects attestations with a target epoch more than one epoch after `currentEpoch`
+   * (or genesis if earlier)
+   */
+  importInterchange(
+    interchange: Interchange,
+    genesisValidatorsRoot: Uint8Array | Root,
+    logger?: Logger,
+    currentEpoch?: Epoch
+  ): Promise<void>;
   exportInterchange(
     genesisValidatorsRoot: Uint8Array | Root,
     pubkeys: BLSPubkey[],

package/src/slashingProtection/utils.ts

@@ -1,5 +1,6 @@
 import {Epoch, Root, ssz} from "@lodestar/types";
 import {fromHex, toHex, toRootHex} from "@lodestar/utils";
+import {InterchangeError, InterchangeErrorErrorCode} from "./interchange/errors.js";
 
 export const blsPubkeyLen = 48;
 export const ZERO_ROOT = ssz.Root.defaultValue();
@@ -27,6 +28,17 @@ export function numToString(num: number): string {
   return String(num);
 }
 
+/**
+ * Parse a decimal uint string, rejecting values the slashing protection DB range scans cannot see
+ */
+export function stringToNum(str: string): number {
+  const num = Number(str);
+  if (!/^[0-9]+$/.test(str) || num >= Number.MAX_SAFE_INTEGER) {
+    throw new InterchangeError({code: InterchangeErrorErrorCode.INVALID_VALUE, value: str});
+  }
+  return num;
+}
+
 export function minEpoch(epochs: Epoch[]): Epoch | null {
   return epochs.length > 0 ? epochs.reduce((minEpoch, epoch) => (minEpoch < epoch ? minEpoch : epoch)) : null;
 }

package/src/validator.ts

@@ -430,7 +430,12 @@ export class Validator {
   }
 
   async importInterchange(interchange: Interchange): Promise<void> {
-    return this.slashingProtection.importInterchange(interchange, this.genesis.genesisValidatorsRoot);
+    return this.slashingProtection.importInterchange(
+      interchange,
+      this.genesis.genesisValidatorsRoot,
+      undefined,
+      this.clock.currentEpoch
+    );
   }
 
   async exportInterchange(pubkeys: BLSPubkey[], formatVersion: InterchangeFormatVersion): Promise<Interchange> {