@lodestar/validator 1.47.0 → 1.48.0-dev.042c96183c

package/src/services/validatorStore.ts

@@ -173,6 +173,32 @@ export const defaultOptions = {
 
 export const MAX_BUILDER_BOOST_FACTOR = 2n ** 64n - 1n;
 
+/** Pre-Gloas there is no in-protocol builder so the default is local-only, post-Gloas bids are used */
+export function getDefaultBuilderSelection(isPostGloas: boolean): routes.validator.BuilderSelection {
+  return isPostGloas ? defaultOptions.builderAliasSelection : defaultOptions.builderSelection;
+}
+
+/** Boost factor implied by a builder selection, `configuredBoostFactor` only applies to `maxprofit` */
+export function getBuilderBoostFactor(
+  selection: routes.validator.BuilderSelection,
+  configuredBoostFactor: bigint
+): bigint {
+  switch (selection) {
+    case routes.validator.BuilderSelection.Default:
+      // Default value slightly favors local block to improve censorship resistance of Ethereum
+      // The people have spoken and so it shall be https://x.com/lodestar_eth/status/1772679499928191044
+      return BigInt(90);
+    case routes.validator.BuilderSelection.MaxProfit:
+      return configuredBoostFactor;
+    case routes.validator.BuilderSelection.BuilderAlways:
+    case routes.validator.BuilderSelection.BuilderOnly:
+      return MAX_BUILDER_BOOST_FACTOR;
+    case routes.validator.BuilderSelection.ExecutionAlways:
+    case routes.validator.BuilderSelection.ExecutionOnly:
+      return BigInt(0);
+  }
+}
+
 /**
  * Service that sets up and handles validator attester duties.
  */
@@ -309,12 +335,12 @@ export class ValidatorStore {
 
   getBuilderSelectionParams(
     pubkeyHex: PubkeyHex,
-    slot?: Slot
+    slot: Slot
   ): {selection: routes.validator.BuilderSelection; boostFactor: bigint} {
     // Builder bids post-gloas are in-protocol, so the default strategy uses them regardless of
     // whether they are received over p2p or through a builder API. Pre-gloas there is no
     // in-protocol builder, so the default remains local-only (executiononly).
-    const isPostGloas = slot !== undefined && this.config.getForkSeq(slot) >= ForkSeq.gloas;
+    const isPostGloas = this.config.getForkSeq(slot) >= ForkSeq.gloas;
     return this.resolveBuilderSelectionParams(pubkeyHex, isPostGloas);
   }
 
@@ -323,7 +349,7 @@ export class ValidatorStore {
     isPostGloas: boolean
   ): {selection: routes.validator.BuilderSelection; boostFactor: bigint} {
     const validatorBuilder = this.validators.get(pubkeyHex)?.builder;
-    const defaultSelection = isPostGloas ? defaultOptions.builderAliasSelection : defaultOptions.builderSelection;
+    const defaultSelection = getDefaultBuilderSelection(isPostGloas);
     let selection = validatorBuilder?.selection ?? this.defaultProposerConfig.builder.selection ?? defaultSelection;
 
     // The standard per-key builder config directly controls the post-Gloas boost. It takes
@@ -343,27 +369,10 @@ export class ValidatorStore {
       }
     }
 
-    let boostFactor: bigint;
-    switch (selection) {
-      case routes.validator.BuilderSelection.Default:
-        // Default value slightly favors local block to improve censorship resistance of Ethereum
-        // The people have spoken and so it shall be https://x.com/lodestar_eth/status/1772679499928191044
-        boostFactor = BigInt(90);
-        break;
-
-      case routes.validator.BuilderSelection.MaxProfit:
-        boostFactor = validatorBuilder?.boostFactor ?? this.defaultProposerConfig.builder.boostFactor;
-        break;
-
-      case routes.validator.BuilderSelection.BuilderAlways:
-      case routes.validator.BuilderSelection.BuilderOnly:
-        boostFactor = MAX_BUILDER_BOOST_FACTOR;
-        break;
-
-      case routes.validator.BuilderSelection.ExecutionAlways:
-      case routes.validator.BuilderSelection.ExecutionOnly:
-        boostFactor = BigInt(0);
-    }
+    const boostFactor = getBuilderBoostFactor(
+      selection,
+      validatorBuilder?.boostFactor ?? this.defaultProposerConfig.builder.boostFactor
+    );
 
     return {selection, boostFactor};
   }
@@ -900,7 +909,7 @@ export class ValidatorStore {
     });
 
     const signableMessage: SignableMessage = {
-      type: SignableMessageType.PAYLOAD_ATTESTATION,
+      type: SignableMessageType.PAYLOAD_ATTESTATION_MESSAGE,
       data,
     };
 

package/src/slashingProtection/attestation/attestationByTargetRepository.ts

@@ -41,6 +41,18 @@ export class AttestationByTargetRepository {
     return attestations.map((attestation) => this.type.deserialize(attestation));
   }
 
+  /** Attestation with the highest target epoch recorded for `pubkey`, or null if none */
+  async getLatest(pubkey: BLSPubkey): Promise<SlashingProtectionAttestation | null> {
+    const [att] = await this.db.values({
+      gte: this.encodeKey(pubkey, 0),
+      lt: this.encodeKey(pubkey, Number.MAX_SAFE_INTEGER),
+      reverse: true,
+      limit: 1,
+      bucketId: this.bucketId,
+    });
+    return att ? this.type.deserialize(att) : null;
+  }
+
   async get(pubkey: BLSPubkey, targetEpoch: Epoch): Promise<SlashingProtectionAttestation | null> {
     const att = await this.db.get(this.encodeKey(pubkey, targetEpoch), this.dbReqOpts);
     return att && this.type.deserialize(att);

package/src/slashingProtection/attestation/errors.ts

@@ -29,6 +29,11 @@ export enum InvalidAttestationErrorCode {
    * bound on target epochs for this validator.
    */
   TARGET_LESS_THAN_OR_EQ_LOWER_BOUND = "ERR_INVALID_ATTESTATION_TARGET_LESS_THAN_OR_EQ_LOWER_BOUND",
+  /**
+   * The attestation is invalid because its source epoch is below the min-max span lookback window of the
+   * latest attestation of this validator, where a surround vote could not be detected.
+   */
+  SOURCE_BELOW_MIN_SPAN_LOOKBACK = "ERR_INVALID_ATTESTATION_SOURCE_BELOW_MIN_SPAN_LOOKBACK",
 }
 
 type InvalidAttestationErrorType =
@@ -61,6 +66,11 @@ type InvalidAttestationErrorType =
       code: InvalidAttestationErrorCode.TARGET_LESS_THAN_OR_EQ_LOWER_BOUND;
       targetEpoch: Epoch;
       minTargetEpoch: Epoch;
+    }
+  | {
+      code: InvalidAttestationErrorCode.SOURCE_BELOW_MIN_SPAN_LOOKBACK;
+      sourceEpoch: Epoch;
+      minSourceEpoch: Epoch;
     };
 
 export class InvalidAttestationError extends LodestarError<InvalidAttestationErrorType> {}

package/src/slashingProtection/attestation/index.ts

@@ -56,9 +56,16 @@ export class SlashingProtectionAttestationService {
       throw new InvalidAttestationError({code: InvalidAttestationErrorCode.SOURCE_EXCEEDS_TARGET});
     }
 
+    const latestAtt = await this.attestationByTarget.getLatest(pubKey);
+
     // Check for a double vote. Namely, an existing attestation with the same target epoch,
-    // and a different signing root.
-    const sameTargetAtt = await this.attestationByTarget.get(pubKey, attestation.targetEpoch);
+    // and a different signing root. No db read needed if the latest attestation has a lower target epoch.
+    let sameTargetAtt: SlashingProtectionAttestation | null = null;
+    if (latestAtt && latestAtt.targetEpoch === attestation.targetEpoch) {
+      sameTargetAtt = latestAtt;
+    } else if (latestAtt && latestAtt.targetEpoch > attestation.targetEpoch) {
+      sameTargetAtt = await this.attestationByTarget.get(pubKey, attestation.targetEpoch);
+    }
     if (sameTargetAtt) {
       // Interchange format allows for attestations without signing_root, then assume root is equal
       if (isEqualNonZeroRoot(sameTargetAtt.signingRoot, attestation.signingRoot)) {
@@ -71,6 +78,20 @@ export class SlashingProtectionAttestationService {
       });
     }
 
+    // Min-span entries only exist within the lookback window below each recorded source epoch, a surround vote
+    // with an older source epoch is undetectable by min-max surround and must be rejected outright. Recorded
+    // attestations are surround-free, so the latest one has the highest source epoch and the widest window.
+    if (latestAtt) {
+      const minSourceEpoch = this.minMaxSurround.minSpanCoverageStart(latestAtt.sourceEpoch);
+      if (attestation.sourceEpoch < minSourceEpoch) {
+        throw new InvalidAttestationError({
+          code: InvalidAttestationErrorCode.SOURCE_BELOW_MIN_SPAN_LOOKBACK,
+          sourceEpoch: attestation.sourceEpoch,
+          minSourceEpoch,
+        });
+      }
+    }
+
     // Check for a surround vote
     try {
       await this.minMaxSurround.assertNoSurround(pubKey, attestation);
@@ -143,6 +164,26 @@ export class SlashingProtectionAttestationService {
    * Interchange import / export functionality
    */
   async importAttestations(pubkey: BLSPubkey, attestations: SlashingProtectionAttestation[]): Promise<void> {
+    // Min-max surround misses a surround vote beyond its lookback, require the highest target attestation to
+    // have the highest source epoch as `checkAttestation` relies on it
+    let latestAtt = await this.attestationByTarget.getLatest(pubkey);
+    let maxSourceAtt = latestAtt;
+    for (const attestation of attestations) {
+      if (latestAtt === null || attestation.targetEpoch >= latestAtt.targetEpoch) {
+        latestAtt = attestation;
+      }
+      if (maxSourceAtt === null || attestation.sourceEpoch > maxSourceAtt.sourceEpoch) {
+        maxSourceAtt = attestation;
+      }
+    }
+    if (latestAtt && maxSourceAtt && latestAtt.sourceEpoch < maxSourceAtt.sourceEpoch) {
+      throw new InvalidAttestationError({
+        code: InvalidAttestationErrorCode.NEW_SURROUNDS_PREV,
+        attestation: latestAtt,
+        prev: maxSourceAtt,
+      });
+    }
+
     await this.attestationByTarget.set(pubkey, attestations);
 
     // Pre-compute spans for all attestations

package/src/slashingProtection/minMaxSurround/minMaxSurround.ts

@@ -1,4 +1,4 @@
-import {BLSPubkey} from "@lodestar/types";
+import {BLSPubkey, Epoch} from "@lodestar/types";
 import {SurroundAttestationError, SurroundAttestationErrorCode} from "./errors.js";
 import {DistanceEntry, IDistanceStore, IMinMaxSurround, MinMaxSurroundAttestation} from "./interface.js";
 
@@ -9,7 +9,8 @@ import {DistanceEntry, IDistanceStore, IMinMaxSurround, MinMaxSurroundAttestatio
  * 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).
+ * rejects any source epoch below `minSpanCoverageStart` of the latest recorded attestation, which is the minimal
+ * strategy (formally proven safe, https://github.com/michaelsproul/slashing-proofs) relaxed by this lookback.
  *
  * 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
@@ -30,6 +31,11 @@ export class MinMaxSurround implements IMinMaxSurround {
     this.maxEpochLookback = options?.maxEpochLookback ?? DEFAULT_MAX_EPOCH_LOOKBACK;
   }
 
+  /** Lowest epoch with a min-span entry after inserting an attestation with `sourceEpoch` */
+  minSpanCoverageStart(sourceEpoch: Epoch): Epoch {
+    return Math.max(0, sourceEpoch - 1 - this.maxEpochLookback);
+  }
+
   async assertNoSurround(pubKey: BLSPubkey, attestation: MinMaxSurroundAttestation): Promise<void> {
     await this.assertNotSurrounding(pubKey, attestation);
     await this.assertNotSurrounded(pubKey, attestation);
@@ -45,7 +51,7 @@ export class MinMaxSurround implements IMinMaxSurround {
   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 untilEpoch = this.minSpanCoverageStart(attestation.sourceEpoch);
 
     const values: DistanceEntry[] = [];
     for (let epoch = attestation.sourceEpoch - 1; epoch >= untilEpoch; epoch--) {

package/src/util/externalSignerClient.ts

@@ -1,6 +1,6 @@
 import {ContainerType, ValueOf} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
-import {ForkName, ForkPreBellatrix, ForkSeq, isForkPostDeneb} from "@lodestar/params";
+import {ForkName, ForkPostGloas, ForkPreBellatrix, ForkSeq, isForkPostDeneb} from "@lodestar/params";
 import {blindedOrFullBlockToHeader, computeEpochAtSlot} from "@lodestar/state-transition";
 import {
   AggregateAndProof,
@@ -34,7 +34,7 @@ export enum SignableMessageType {
   SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF = "SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF",
   VALIDATOR_REGISTRATION = "VALIDATOR_REGISTRATION",
   EXECUTION_PAYLOAD_ENVELOPE = "EXECUTION_PAYLOAD_ENVELOPE",
-  PAYLOAD_ATTESTATION = "PAYLOAD_ATTESTATION",
+  PAYLOAD_ATTESTATION_MESSAGE = "PAYLOAD_ATTESTATION_MESSAGE",
   PROPOSER_PREFERENCES = "PROPOSER_PREFERENCES",
   BUILDER_REQUEST_AUTH = "BUILDER_REQUEST_AUTH",
 }
@@ -87,7 +87,7 @@ export type SignableMessage =
   | {type: SignableMessageType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF; data: altair.ContributionAndProof}
   | {type: SignableMessageType.VALIDATOR_REGISTRATION; data: ValidatorRegistrationV1}
   | {type: SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE; data: gloas.ExecutionPayloadEnvelope}
-  | {type: SignableMessageType.PAYLOAD_ATTESTATION; data: gloas.PayloadAttestationData}
+  | {type: SignableMessageType.PAYLOAD_ATTESTATION_MESSAGE; data: gloas.PayloadAttestationData}
   | {type: SignableMessageType.PROPOSER_PREFERENCES; data: gloas.ProposerPreferences}
   | {type: SignableMessageType.BUILDER_REQUEST_AUTH; data: gloas.BuilderRequestAuth};
 
@@ -105,7 +105,7 @@ const requiresForkInfo: Record<SignableMessageType, boolean> = {
   [SignableMessageType.SYNC_COMMITTEE_CONTRIBUTION_AND_PROOF]: true,
   [SignableMessageType.VALIDATOR_REGISTRATION]: false,
   [SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE]: true,
-  [SignableMessageType.PAYLOAD_ATTESTATION]: true,
+  [SignableMessageType.PAYLOAD_ATTESTATION_MESSAGE]: true,
   [SignableMessageType.PROPOSER_PREFERENCES]: true,
   [SignableMessageType.BUILDER_REQUEST_AUTH]: false,
 };
@@ -280,17 +280,45 @@ function serializerSignableMessagePayload(config: BeaconConfig, payload: Signabl
     case SignableMessageType.VALIDATOR_REGISTRATION:
       return {validator_registration: ssz.bellatrix.ValidatorRegistrationV1.toJson(payload.data)};
 
-    case SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE:
-      return {execution_payload_envelope: ssz.gloas.ExecutionPayloadEnvelope.toJson(payload.data)};
+    case SignableMessageType.EXECUTION_PAYLOAD_ENVELOPE: {
+      const slot = payload.data.payload.slotNumber;
+      return {
+        execution_payload_envelope: {
+          version: config.getForkName(slot).toUpperCase(),
+          data: config.getForkTypes<ForkPostGloas>(slot).ExecutionPayloadEnvelope.toJson(payload.data),
+        },
+      };
+    }
 
-    case SignableMessageType.PAYLOAD_ATTESTATION:
-      return {payload_attestation: ssz.gloas.PayloadAttestationData.toJson(payload.data)};
+    case SignableMessageType.PAYLOAD_ATTESTATION_MESSAGE: {
+      const slot = payload.data.slot;
+      return {
+        payload_attestation_message: {
+          version: config.getForkName(slot).toUpperCase(),
+          data: config.getForkTypes<ForkPostGloas>(slot).PayloadAttestationData.toJson(payload.data),
+        },
+      };
+    }
 
-    case SignableMessageType.PROPOSER_PREFERENCES:
-      return {proposer_preferences: ssz.gloas.ProposerPreferences.toJson(payload.data)};
+    case SignableMessageType.PROPOSER_PREFERENCES: {
+      const slot = payload.data.proposalSlot;
+      return {
+        proposer_preferences: {
+          version: config.getForkName(slot).toUpperCase(),
+          data: config.getForkTypes<ForkPostGloas>(slot).ProposerPreferences.toJson(payload.data),
+        },
+      };
+    }
 
-    case SignableMessageType.BUILDER_REQUEST_AUTH:
-      return {builder_request_auth: ssz.gloas.BuilderRequestAuth.toJson(payload.data)};
+    case SignableMessageType.BUILDER_REQUEST_AUTH: {
+      const slot = payload.data.slot;
+      return {
+        builder_request_auth: {
+          version: config.getForkName(slot).toUpperCase(),
+          data: config.getForkTypes<ForkPostGloas>(slot).BuilderRequestAuth.toJson(payload.data),
+        },
+      };
+    }
   }
 }
 

package/src/validator.ts

@@ -9,7 +9,7 @@ import {
 import {Clock, ClockOptions, IClock, computeEpochAtSlot, getCurrentSlot} from "@lodestar/state-transition";
 import {BLSPubkey, phase0, ssz} from "@lodestar/types";
 import {Genesis} from "@lodestar/types/phase0";
-import {Logger, toPrintableUrl, toRootHex} from "@lodestar/utils";
+import {Logger, prettyGweiToEth, toPrintableUrl, toRootHex} from "@lodestar/utils";
 import {waitForGenesis} from "./genesis.js";
 import {Metrics} from "./metrics.js";
 import {MetaDataRepository} from "./repositories/metaDataRepository.js";
@@ -27,7 +27,14 @@ import {ProposerPreferencesService} from "./services/proposerPreferences.js";
 import {PtcService} from "./services/ptc.js";
 import {SyncCommitteeService} from "./services/syncCommittee.js";
 import {SyncingStatusTracker} from "./services/syncingStatusTracker.js";
-import {Signer, ValidatorProposerConfig, ValidatorStore, defaultOptions} from "./services/validatorStore.js";
+import {
+  Signer,
+  ValidatorProposerConfig,
+  ValidatorStore,
+  defaultOptions,
+  getBuilderBoostFactor,
+  getDefaultBuilderSelection,
+} from "./services/validatorStore.js";
 import {ISlashingProtection, Interchange, InterchangeFormatVersion} from "./slashingProtection/index.js";
 import {LodestarValidatorDatabaseController, ProcessShutdownCallback, PubkeyHex} from "./types.js";
 import {getLoggerVc} from "./util/index.js";
@@ -369,8 +376,9 @@ export class Validator {
     logger.info("Verified connected beacon node and validator have the same genesisValidatorRoot");
 
     const {broadcastValidation = defaultOptions.broadcastValidation, valProposerConfig} = opts;
+    const gloasScheduled = config.GLOAS_FORK_EPOCH !== Infinity;
     const defaultBuilderSelection =
-      valProposerConfig?.defaultConfig.builder?.selection ?? defaultOptions.builderSelection;
+      valProposerConfig?.defaultConfig.builder?.selection ?? getDefaultBuilderSelection(gloasScheduled);
     const strictFeeRecipientCheck = valProposerConfig?.defaultConfig.strictFeeRecipientCheck ?? false;
     const suggestedFeeRecipient = valProposerConfig?.defaultConfig.feeRecipient ?? defaultOptions.suggestedFeeRecipient;
 
@@ -383,6 +391,23 @@ export class Validator {
 
     metrics?.defaultConfiguration.set({builderSelection: defaultBuilderSelection, broadcastValidation}, 1);
 
+    if (gloasScheduled) {
+      const defaultBuilderConfig = valProposerConfig?.defaultConfig.builder;
+      const defaultBuilders = defaultBuilderConfig?.builders ?? [];
+
+      logger.info("Builder config", {
+        builders: defaultBuilders.map((entry) => toPrintableUrl(entry.url)).join(",") || "p2p only",
+        boostFactor: getBuilderBoostFactor(
+          defaultBuilderSelection,
+          defaultBuilderConfig?.boostFactor ?? defaultOptions.builderBoostFactor
+        ),
+        minBid: prettyGweiToEth(defaultBuilderConfig?.minBid ?? defaultOptions.builderMinBid),
+        maxExecutionPayment: prettyGweiToEth(
+          defaultBuilderConfig?.maxExecutionPayment ?? defaultOptions.builderMaxExecutionPayment
+        ),
+      });
+    }
+
     // Instantiates block and attestation services and runs them once the chain has been started.
     return Validator.init(opts, genesis, metrics);
   }