@lodestar/validator 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

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

@@ -1,125 +0,0 @@
-import {fromHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {fromOptionalHexString, numToString, toOptionalHexString} from "../../utils.js";
-import {InterchangeLodestar} from "../types.js";
-
-/**
- * A complete record of all blocks and attestations signed by a set of validators
- * Spec from: https://hackmd.io/@sproul/Bk0Y0qdGD
- */
-export type InterchangeCompleteV4 = {
-  metadata: {
-    interchange_format: "complete";
-    interchange_format_version: "4";
-    /**
-     * ```
-     * "0x04700007fabc8282644aed6d1c7c9e21d38a03a0c4ba193f3afe428824b3a673"
-     * ```
-     */
-    genesis_validators_root: string;
-  };
-  data: {
-    /**
-     * pubkey: BLSPubkey is the BLS public key of the validator encoded as 0x-prefixed hex
-     * ```
-     * "0xb845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed"
-     * ```
-     */
-    pubkey: string;
-    /**
-     * signed_blocks is a list of objects with fields
-     */
-    signed_blocks: {
-      /**
-       * slot: Slot, the slot of the block that was signed
-       * ```
-       * "81952"
-       * ```
-       */
-      slot: string;
-      /**
-       * signing_root: Root (optional) is compute_signing_root(block, domain), where:
-       * - block is the block that was signed as type BeaconBlock or equivalently BeaconBlockHeader
-       * - domain is equal to compute_domain(DOMAIN_BEACON_PROPOSER, fork, metadata.genesis_validators_root), where:
-       *   - metadata.genesis_validators_root is the genesis_validators_root from this interchange file
-       *   - fork: Version is the fork that the block was signed against
-       * ```
-       * "0x4ff6f743a43f3b4f95350831aeaf0a122a1a392922c45d804280284a69eb850b"
-       * ```
-       */
-      signing_root?: string;
-    }[];
-    /**
-     * signed_attestations is a list of objects with fields
-     */
-    signed_attestations: {
-      /**
-       * source_epoch: Epoch, the attestation.data.source.epoch of the signed attestation
-       * ```
-       * "2290"
-       * ```
-       */
-      source_epoch: string;
-      /**
-       * target_epoch: Epoch, the attestation.data.target.epoch of the signed attestation
-       * ```
-       * "3007"
-       * ```
-       */
-      target_epoch: string;
-      /**
-       * signing_root: Root (optional) is compute_signing_root(attestation, domain), where:
-       * - attestation is the attestation that was signed as type AttestationData
-       * - domain is equal to compute_domain(DOMAIN_BEACON_ATTESTER, fork, metadata.genesis_validators_root), where:
-       *   - metadata.genesis_validators_root is the genesis_validators_root from this interchange file
-       *   - fork: Version is the fork that the attestation was signed against
-       * ```
-       * "0x587d6a4f59a58fe24f406e0502413e77fe1babddee641fda30034ed37ecc884d"
-       * ```
-       */
-      signing_root?: string;
-    }[];
-  }[];
-};
-
-export function serializeInterchangeCompleteV4({
-  data,
-  genesisValidatorsRoot,
-}: InterchangeLodestar): InterchangeCompleteV4 {
-  return {
-    metadata: {
-      interchange_format: "complete",
-      interchange_format_version: "4",
-      genesis_validators_root: toRootHex(genesisValidatorsRoot),
-    },
-    data: data.map((validator) => ({
-      pubkey: toPubkeyHex(validator.pubkey),
-      signed_blocks: validator.signedBlocks.map((block) => ({
-        slot: numToString(block.slot),
-        signing_root: toOptionalHexString(block.signingRoot),
-      })),
-      signed_attestations: validator.signedAttestations.map((att) => ({
-        source_epoch: numToString(att.sourceEpoch),
-        target_epoch: numToString(att.targetEpoch),
-        signing_root: toOptionalHexString(att.signingRoot),
-      })),
-    })),
-  };
-}
-
-export function parseInterchangeCompleteV4(interchange: InterchangeCompleteV4): InterchangeLodestar {
-  return {
-    genesisValidatorsRoot: fromHex(interchange.metadata.genesis_validators_root),
-    data: interchange.data.map((validator) => ({
-      pubkey: fromHex(validator.pubkey),
-      signedBlocks: validator.signed_blocks.map((block) => ({
-        slot: parseInt(block.slot, 10),
-        signingRoot: fromOptionalHexString(block.signing_root),
-      })),
-      signedAttestations: validator.signed_attestations.map((att) => ({
-        sourceEpoch: parseInt(att.source_epoch, 10),
-        targetEpoch: parseInt(att.target_epoch, 10),
-        signingRoot: fromOptionalHexString(att.signing_root),
-      })),
-    })),
-  };
-}

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

@@ -1,7 +0,0 @@
-import {InterchangeCompleteV4} from "./completeV4.js";
-import {InterchangeV5} from "./v5.js";
-
-export type InterchangeFormat = {
-  v4: InterchangeCompleteV4;
-  v5: InterchangeV5;
-};

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

@@ -1,120 +0,0 @@
-import {fromHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
-import {fromOptionalHexString, numToString, toOptionalHexString} from "../../utils.js";
-import {InterchangeLodestar} from "../types.js";
-
-/**
- * A complete record of all blocks and attestations signed by a set of validators
- * Spec from: https://eips.ethereum.org/EIPS/eip-3076
- */
-export type InterchangeV5 = {
-  metadata: {
-    interchange_format_version: "5";
-    /**
-     * ```
-     * "0x04700007fabc8282644aed6d1c7c9e21d38a03a0c4ba193f3afe428824b3a673"
-     * ```
-     */
-    genesis_validators_root: string;
-  };
-  data: {
-    /**
-     * pubkey: BLSPubkey is the BLS public key of the validator encoded as 0x-prefixed hex
-     * ```
-     * "0xb845089a1457f811bfc000588fbb4e713669be8ce060ea6be3c6ece09afc3794106c91ca73acda5e5457122d58723bed"
-     * ```
-     */
-    pubkey: string;
-    /**
-     * signed_blocks is a list of objects with fields
-     */
-    signed_blocks: {
-      /**
-       * slot: Slot, the slot of the block that was signed
-       * ```
-       * "81952"
-       * ```
-       */
-      slot: string;
-      /**
-       * signing_root: Root (optional) is compute_signing_root(block, domain), where:
-       * - block is the block that was signed as type BeaconBlock or equivalently BeaconBlockHeader
-       * - domain is equal to compute_domain(DOMAIN_BEACON_PROPOSER, fork, metadata.genesis_validators_root), where:
-       *   - metadata.genesis_validators_root is the genesis_validators_root from this interchange file
-       *   - fork: Version is the fork that the block was signed against
-       * ```
-       * "0x4ff6f743a43f3b4f95350831aeaf0a122a1a392922c45d804280284a69eb850b"
-       * ```
-       */
-      signing_root?: string;
-    }[];
-    /**
-     * signed_attestations is a list of objects with fields
-     */
-    signed_attestations: {
-      /**
-       * source_epoch: Epoch, the attestation.data.source.epoch of the signed attestation
-       * ```
-       * "2290"
-       * ```
-       */
-      source_epoch: string;
-      /**
-       * target_epoch: Epoch, the attestation.data.target.epoch of the signed attestation
-       * ```
-       * "3007"
-       * ```
-       */
-      target_epoch: string;
-      /**
-       * signing_root: Root (optional) is compute_signing_root(attestation, domain), where:
-       * - attestation is the attestation that was signed as type AttestationData
-       * - domain is equal to compute_domain(DOMAIN_BEACON_ATTESTER, fork, metadata.genesis_validators_root), where:
-       *   - metadata.genesis_validators_root is the genesis_validators_root from this interchange file
-       *   - fork: Version is the fork that the attestation was signed against
-       * ```
-       * "0x587d6a4f59a58fe24f406e0502413e77fe1babddee641fda30034ed37ecc884d"
-       * ```
-       */
-      signing_root?: string;
-    }[];
-  }[];
-};
-
-export function serializeInterchangeV5({data, genesisValidatorsRoot}: InterchangeLodestar): InterchangeV5 {
-  return {
-    metadata: {
-      interchange_format_version: "5",
-      genesis_validators_root: toRootHex(genesisValidatorsRoot),
-    },
-    data: data.map((validator) => ({
-      pubkey: toPubkeyHex(validator.pubkey),
-      signed_blocks: validator.signedBlocks.map((block) => ({
-        slot: numToString(block.slot),
-        signing_root: toOptionalHexString(block.signingRoot),
-      })),
-      signed_attestations: validator.signedAttestations.map((att) => ({
-        source_epoch: numToString(att.sourceEpoch),
-        target_epoch: numToString(att.targetEpoch),
-        signing_root: toOptionalHexString(att.signingRoot),
-      })),
-    })),
-  };
-}
-
-export function parseInterchangeV5(interchange: InterchangeV5): InterchangeLodestar {
-  return {
-    genesisValidatorsRoot: fromHex(interchange.metadata.genesis_validators_root),
-    data: interchange.data.map((validator) => ({
-      pubkey: fromHex(validator.pubkey),
-      signedBlocks: validator.signed_blocks.map((block) => ({
-        slot: parseInt(block.slot, 10),
-        signingRoot: fromOptionalHexString(block.signing_root),
-      })),
-      signedAttestations: validator.signed_attestations.map((att) => ({
-        sourceEpoch: parseInt(att.source_epoch, 10),
-        targetEpoch: parseInt(att.target_epoch, 10),
-        signingRoot: fromOptionalHexString(att.signing_root),
-      })),
-    })),
-  };
-}

package/src/slashingProtection/interchange/index.ts

@@ -1,5 +0,0 @@
-export * from "./errors.js";
-export * from "./formats/index.js";
-export * from "./parseInterchange.js";
-export * from "./serializeInterchange.js";
-export * from "./types.js";

package/src/slashingProtection/interchange/parseInterchange.ts

@@ -1,55 +0,0 @@
-import {Root} from "@lodestar/types";
-import {isEqualRoot} from "../utils.js";
-import {InterchangeError, InterchangeErrorErrorCode} from "./errors.js";
-import {InterchangeCompleteV4, parseInterchangeCompleteV4} from "./formats/completeV4.js";
-import {InterchangeV5, parseInterchangeV5} from "./formats/v5.js";
-import {Interchange, InterchangeLodestar} from "./types.js";
-
-export function parseInterchange(interchange: Interchange, expectedGenesisValidatorsRoot: Root): InterchangeLodestar {
-  const format = (interchange as InterchangeCompleteV4)?.metadata?.interchange_format;
-  const version = interchange?.metadata?.interchange_format_version;
-
-  if (!format) {
-    // version >= v5.0.0
-    switch (version) {
-      case "5": {
-        const interchangeLodestar = parseInterchangeV5(interchange as InterchangeV5);
-        if (!isEqualRoot(interchangeLodestar.genesisValidatorsRoot, expectedGenesisValidatorsRoot)) {
-          throw new InterchangeError({
-            code: InterchangeErrorErrorCode.GENESIS_VALIDATOR_MISMATCH,
-            root: interchangeLodestar.genesisValidatorsRoot,
-            expectedRoot: expectedGenesisValidatorsRoot,
-          });
-        }
-        return interchangeLodestar;
-      }
-
-      default:
-        throw new InterchangeError({code: InterchangeErrorErrorCode.UNSUPPORTED_VERSION, version});
-    }
-  }
-
-  // version < v5.0.0 (older version)
-  switch (format) {
-    case "complete":
-      switch (version) {
-        case "4": {
-          const interchangeLodestar = parseInterchangeCompleteV4(interchange as InterchangeCompleteV4);
-          if (!isEqualRoot(interchangeLodestar.genesisValidatorsRoot, expectedGenesisValidatorsRoot)) {
-            throw new InterchangeError({
-              code: InterchangeErrorErrorCode.GENESIS_VALIDATOR_MISMATCH,
-              root: interchangeLodestar.genesisValidatorsRoot,
-              expectedRoot: expectedGenesisValidatorsRoot,
-            });
-          }
-          return interchangeLodestar;
-        }
-
-        default:
-          throw new InterchangeError({code: InterchangeErrorErrorCode.UNSUPPORTED_VERSION, version});
-      }
-
-    default:
-      throw new InterchangeError({code: InterchangeErrorErrorCode.UNSUPPORTED_FORMAT, format: format});
-  }
-}

package/src/slashingProtection/interchange/serializeInterchange.ts

@@ -1,35 +0,0 @@
-import {InterchangeError, InterchangeErrorErrorCode} from "./errors.js";
-import {serializeInterchangeCompleteV4} from "./formats/completeV4.js";
-import {serializeInterchangeV5} from "./formats/v5.js";
-import {Interchange, InterchangeFormatVersion, InterchangeLodestar} from "./types.js";
-
-export function serializeInterchange(
-  interchangeLodestar: InterchangeLodestar,
-  {format, version}: InterchangeFormatVersion
-): Interchange {
-  // version >= v5.0.0
-  if (!format) {
-    switch (version) {
-      case "5":
-        return serializeInterchangeV5(interchangeLodestar);
-
-      default:
-        throw new InterchangeError({code: InterchangeErrorErrorCode.UNSUPPORTED_VERSION, version});
-    }
-  }
-
-  // version < v5.0.0
-  switch (format) {
-    case "complete":
-      switch (version) {
-        case "4":
-          return serializeInterchangeCompleteV4(interchangeLodestar);
-
-        default:
-          throw new InterchangeError({code: InterchangeErrorErrorCode.UNSUPPORTED_VERSION, version});
-      }
-
-    default:
-      throw new InterchangeError({code: InterchangeErrorErrorCode.UNSUPPORTED_FORMAT, format});
-  }
-}

package/src/slashingProtection/interchange/types.ts

@@ -1,18 +0,0 @@
-import {BLSPubkey, Root} from "@lodestar/types";
-import {SlashingProtectionAttestation, SlashingProtectionBlock} from "../types.js";
-import {InterchangeCompleteV4} from "./formats/completeV4.js";
-import {InterchangeV5} from "./formats/v5.js";
-
-export type Interchange = InterchangeV5 | InterchangeCompleteV4;
-
-// `format` only for version < v5.0.0
-export type InterchangeFormatVersion = {format?: "complete"; version: "4" | "5"};
-
-export type InterchangeLodestar = {
-  genesisValidatorsRoot: Root;
-  data: {
-    pubkey: BLSPubkey;
-    signedBlocks: SlashingProtectionBlock[];
-    signedAttestations: SlashingProtectionAttestation[];
-  }[];
-};

package/src/slashingProtection/interface.ts

@@ -1,28 +0,0 @@
-import {BLSPubkey, Epoch, Root} from "@lodestar/types";
-import {Logger} from "@lodestar/utils";
-import {Interchange, InterchangeFormatVersion} from "./interchange/types.js";
-import {SlashingProtectionAttestation, SlashingProtectionBlock} from "./types.js";
-
-export interface ISlashingProtection {
-  /**
-   * Check a block proposal for slash safety, and if it is safe, record it in the database
-   */
-  checkAndInsertBlockProposal(pubKey: BLSPubkey, block: SlashingProtectionBlock): Promise<void>;
-  /**
-   * Check an attestation for slash safety, and if it is safe, record it in the database
-   */
-  checkAndInsertAttestation(pubKey: BLSPubkey, attestation: SlashingProtectionAttestation): Promise<void>;
-
-  /**
-   * Check whether a validator as identified by `pubKey` has attested in the specified `epoch`
-   */
-  hasAttestedInEpoch(pubKey: BLSPubkey, epoch: Epoch): Promise<boolean>;
-
-  importInterchange(interchange: Interchange, genesisValidatorsRoot: Uint8Array | Root, logger?: Logger): Promise<void>;
-  exportInterchange(
-    genesisValidatorsRoot: Uint8Array | Root,
-    pubkeys: BLSPubkey[],
-    formatVersion: InterchangeFormatVersion,
-    logger?: Logger
-  ): Promise<Interchange>;
-}

package/src/slashingProtection/minMaxSurround/distanceStoreRepository.ts

@@ -1,57 +0,0 @@
-import {Type} from "@chainsafe/ssz";
-import {DbReqOpts, encodeKey} from "@lodestar/db";
-import {BLSPubkey, Epoch, ssz} from "@lodestar/types";
-import {intToBytes} from "@lodestar/utils";
-import {Bucket, getBucketNameByValue} from "../../buckets.js";
-import {LodestarValidatorDatabaseController} from "../../types.js";
-import {DistanceEntry, IDistanceStore} from "./interface.js";
-
-/**
- * Manages validator db storage of min/max ranges for min/max surround vote slashing protection.
- */
-export class DistanceStoreRepository implements IDistanceStore {
-  minSpan: SpanDistanceRepository;
-  maxSpan: SpanDistanceRepository;
-
-  constructor(protected db: LodestarValidatorDatabaseController) {
-    this.minSpan = new SpanDistanceRepository(db, Bucket.slashingProtectionMinSpanDistance);
-    this.maxSpan = new SpanDistanceRepository(db, Bucket.slashingProtectionMaxSpanDistance);
-  }
-}
-
-class SpanDistanceRepository {
-  protected type: Type<Epoch>;
-  protected bucket: Bucket;
-
-  private readonly bucketId: string;
-  private readonly dbReqOpts: DbReqOpts;
-
-  constructor(
-    protected db: LodestarValidatorDatabaseController,
-    bucket: Bucket
-  ) {
-    this.type = ssz.Epoch;
-    this.bucket = bucket;
-    this.bucketId = getBucketNameByValue(bucket);
-    this.dbReqOpts = {bucketId: this.bucketId};
-  }
-
-  async get(pubkey: BLSPubkey, epoch: Epoch): Promise<Epoch | null> {
-    const distance = await this.db.get(this.encodeKey(pubkey, epoch), this.dbReqOpts);
-    return distance && this.type.deserialize(distance);
-  }
-
-  async setBatch(pubkey: BLSPubkey, values: DistanceEntry[]): Promise<void> {
-    await this.db.batchPut(
-      values.map((value) => ({
-        key: this.encodeKey(pubkey, value.source),
-        value: this.type.serialize(value.distance),
-      })),
-      this.dbReqOpts
-    );
-  }
-
-  private encodeKey(pubkey: BLSPubkey, epoch: Epoch): Uint8Array {
-    return encodeKey(this.bucket, Buffer.concat([pubkey, intToBytes(BigInt(epoch), 8, "be")]));
-  }
-}

package/src/slashingProtection/minMaxSurround/errors.ts

@@ -1,27 +0,0 @@
-import {LodestarError} from "@lodestar/utils";
-import {MinMaxSurroundAttestation} from "./interface.js";
-
-export enum SurroundAttestationErrorCode {
-  /**
-   * The provided attestation is surrounding at least another attestation from the store
-   */
-  IS_SURROUNDING = "ERR_SURROUND_ATTESTATION_IS_SURROUNDING",
-  /**
-   * The provided attestation is surrounded by at least another attestation from the store
-   */
-  IS_SURROUNDED = "ERR_SURROUND_ATTESTATION_IS_SURROUNDED",
-}
-
-type SurroundAttestationErrorType =
-  | {
-      code: SurroundAttestationErrorCode.IS_SURROUNDING;
-      attestation: MinMaxSurroundAttestation;
-      attestation2Target: number;
-    }
-  | {
-      code: SurroundAttestationErrorCode.IS_SURROUNDED;
-      attestation: MinMaxSurroundAttestation;
-      attestation2Target: number;
-    };
-
-export class SurroundAttestationError extends LodestarError<SurroundAttestationErrorType> {}

package/src/slashingProtection/minMaxSurround/index.ts

@@ -1,4 +0,0 @@
-export * from "./distanceStoreRepository.js";
-export * from "./errors.js";
-export * from "./interface.js";
-export * from "./minMaxSurround.js";

package/src/slashingProtection/minMaxSurround/interface.ts

@@ -1,23 +0,0 @@
-import {BLSPubkey, Epoch} from "@lodestar/types";
-
-export type MinMaxSurroundAttestation = {
-  targetEpoch: number;
-  sourceEpoch: number;
-};
-
-export interface IMinMaxSurround {
-  assertNoSurround(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void>;
-  insertAttestation(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void>;
-}
-
-export type DistanceEntry = {
-  source: Epoch;
-  distance: Epoch;
-};
-
-export type IDistanceStore = {
-  [P in "minSpan" | "maxSpan"]: {
-    get(pubKey: BLSPubkey, epoch: Epoch): Promise<Epoch | null>;
-    setBatch(pubKey: BLSPubkey, values: DistanceEntry[]): Promise<void>;
-  };
-};

package/src/slashingProtection/minMaxSurround/minMaxSurround.ts

@@ -1,104 +0,0 @@
-import {BLSPubkey} from "@lodestar/types";
-import {SurroundAttestationError, SurroundAttestationErrorCode} from "./errors.js";
-import {DistanceEntry, IDistanceStore, IMinMaxSurround, MinMaxSurroundAttestation} from "./interface.js";
-
-// surround vote checking with min-max surround
-// https://github.com/protolambda/eth2-surround#min-max-surround
-
-/**
- * Number of epochs in the past to check for surrounding attestations.
- *
- * This value can be limited to a reasonable high amount as Lodestar does not solely rely on this strategy but also
- * implements the minimal strategy which has been formally proven to be safe (https://github.com/michaelsproul/slashing-proofs).
- *
- * Limiting this value is required due to practical reasons as otherwise there would be a min-span DB read and write
- * for each validator from current epoch until genesis which massively increases DB size and causes I/O lag, resulting in
- * instability on first startup with an empty DB. See https://github.com/ChainSafe/lodestar/issues/5356 for more details.
- *
- * The value 4096 has been chosen as it is the default used by slashers (https://lighthouse-book.sigmaprime.io/slasher.html#history-length)
- * and is generally higher than the weak subjectivity period. However, it would still be risky if we just relied on min-max surround
- * for slashing protection, as slashers can be configured to collect slashable attestations over a longer period.
- */
-const DEFAULT_MAX_EPOCH_LOOKBACK = 4096;
-
-export class MinMaxSurround implements IMinMaxSurround {
-  private store: IDistanceStore;
-  private maxEpochLookback: number;
-
-  constructor(store: IDistanceStore, options?: {maxEpochLookback?: number}) {
-    this.store = store;
-    this.maxEpochLookback = options?.maxEpochLookback ?? DEFAULT_MAX_EPOCH_LOOKBACK;
-  }
-
-  async assertNoSurround(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void> {
-    await this.assertNotSurrounding(pubKey, attestation);
-    await this.assertNotSurrounded(pubKey, attestation);
-  }
-
-  async insertAttestation(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void> {
-    await this.updateMinSpan(pubKey, attestation);
-    await this.updateMaxSpan(pubKey, attestation);
-  }
-
-  // min span
-
-  private async updateMinSpan(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void> {
-    await this.assertNotSurrounding(pubKey, attestation);
-
-    const untilEpoch = Math.max(0, attestation.sourceEpoch - 1 - this.maxEpochLookback);
-
-    const values: DistanceEntry[] = [];
-    for (let epoch = attestation.sourceEpoch - 1; epoch >= untilEpoch; epoch--) {
-      const minSpan = await this.store.minSpan.get(pubKey, epoch);
-      const distance = attestation.targetEpoch - epoch;
-      if (minSpan === null || distance < minSpan) {
-        values.push({source: epoch, distance});
-      } else {
-        break;
-      }
-    }
-    await this.store.minSpan.setBatch(pubKey, values);
-  }
-
-  private async assertNotSurrounding(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void> {
-    const minSpan = await this.store.minSpan.get(pubKey, attestation.sourceEpoch);
-    const distance = attestation.targetEpoch - attestation.sourceEpoch;
-    if (minSpan != null && minSpan > 0 && minSpan < distance) {
-      throw new SurroundAttestationError({
-        code: SurroundAttestationErrorCode.IS_SURROUNDING,
-        attestation,
-        attestation2Target: attestation.sourceEpoch + minSpan,
-      });
-    }
-  }
-
-  // max span
-
-  private async updateMaxSpan(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void> {
-    await this.assertNotSurrounded(pubKey, attestation);
-
-    const values: DistanceEntry[] = [];
-    for (let epoch = attestation.sourceEpoch + 1; epoch < attestation.targetEpoch; epoch++) {
-      const maxSpan = await this.store.maxSpan.get(pubKey, epoch);
-      const distance = attestation.targetEpoch - epoch;
-      if (maxSpan === null || distance > maxSpan) {
-        values.push({source: epoch, distance});
-      } else {
-        break;
-      }
-    }
-    await this.store.maxSpan.setBatch(pubKey, values);
-  }
-
-  private async assertNotSurrounded(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void> {
-    const maxSpan = await this.store.maxSpan.get(pubKey, attestation.sourceEpoch);
-    const distance = attestation.targetEpoch - attestation.sourceEpoch;
-    if (maxSpan != null && maxSpan > 0 && maxSpan > distance) {
-      throw new SurroundAttestationError({
-        code: SurroundAttestationErrorCode.IS_SURROUNDED,
-        attestation: attestation,
-        attestation2Target: attestation.sourceEpoch + maxSpan,
-      });
-    }
-  }
-}

package/src/slashingProtection/types.ts

@@ -1,12 +0,0 @@
-import {Epoch, Root, Slot} from "@lodestar/types";
-
-export interface SlashingProtectionBlock {
-  slot: Slot;
-  signingRoot: Root;
-}
-
-export interface SlashingProtectionAttestation {
-  sourceEpoch: Epoch;
-  targetEpoch: Epoch;
-  signingRoot: Root;
-}

package/src/slashingProtection/utils.ts

@@ -1,42 +0,0 @@
-import {Epoch, Root, ssz} from "@lodestar/types";
-import {fromHex, toHex, toRootHex} from "@lodestar/utils";
-
-export const blsPubkeyLen = 48;
-export const ZERO_ROOT = ssz.Root.defaultValue();
-
-export function isEqualRoot(root1: Root, root2: Root): boolean {
-  return ssz.Root.equals(root1, root2);
-}
-
-export function isEqualNonZeroRoot(root1: Root, root2: Root): boolean {
-  return !isEqualRoot(root1, ZERO_ROOT) && isEqualRoot(root1, root2);
-}
-
-export function fromOptionalHexString(hex: string | undefined): Root {
-  return hex ? fromHex(hex) : ZERO_ROOT;
-}
-
-export function toOptionalHexString(root: Root): string | undefined {
-  return isEqualRoot(root, ZERO_ROOT) ? undefined : toRootHex(root);
-}
-
-/**
- * Typesafe wrapper around `String()`. The String constructor accepts any which is dangerous
- */
-export function numToString(num: number): string {
-  return String(num);
-}
-
-export function minEpoch(epochs: Epoch[]): Epoch | null {
-  return epochs.length > 0 ? epochs.reduce((minEpoch, epoch) => (minEpoch < epoch ? minEpoch : epoch)) : null;
-}
-
-export function uniqueVectorArr(buffers: Uint8Array[]): Uint8Array[] {
-  const bufferStr = new Set<string>();
-  return buffers.filter((buffer) => {
-    const str = toHex(buffer);
-    const seen = bufferStr.has(str);
-    bufferStr.add(str);
-    return !seen;
-  });
-}