@lodestar/validator 1.45.0-dev.51a1c44b27 → 1.45.0-dev.6568180f96

package/src/services/block.ts

@@ -1,6 +1,6 @@
 import {ApiClient, routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
-import {BUILDER_INDEX_SELF_BUILD, isForkPostGloas} from "@lodestar/params";
+import {BUILDER_INDEX_SELF_BUILD, ForkPostGloas, isForkPostGloas} from "@lodestar/params";
 import {
   BLSPubkey,
   BLSSignature,
@@ -39,6 +39,7 @@ type DebugLogCtx = {debugLogCtx: Record<string, string | boolean | undefined>};
 type BlockProposalOpts = {
   broadcastValidation: routes.beacon.BroadcastValidation;
   blindedLocal: boolean;
+  payloadLocal: boolean;
 };
 /**
  * Service that sets up and handles validator block proposal duties.
@@ -166,11 +167,19 @@ export class BlockProposingService {
   }
 
   /**
-   * Gloas stateful block production flow:
-   * 1. Produce beacon block with execution payload bid
-   * 2. Sign and publish the beacon block
-   * 3. Get the execution payload envelope
-   * 4. Sign and publish the envelope
+   * Gloas block production flow:
+   * 1. Produce the beacon block, which commits to an execution payload bid. When self-building with
+   *    the stateless flow (`payloadLocal=false`), the response also includes the full block contents
+   *    (execution payload envelope, KZG proofs and blobs).
+   * 2. Sign and publish the beacon block.
+   * 3. Reveal the execution payload envelope:
+   *    - Self-build: the proposer signs and publishes the envelope
+   *      - Stateless (`payloadLocal=false`): envelope and blobs are already available from step 1,
+   *        publish `SignedExecutionPayloadEnvelopeContents` which can be sent via any beacon node
+   *      - Stateful (`payloadLocal=true`): fetch the envelope from the beacon node that produced the
+   *        block, then publish the bare `SignedExecutionPayloadEnvelope` back to it; that node
+   *        attaches the cached blobs and KZG proofs
+   *    - Builder bid: the builder reveals the envelope, so the proposer does nothing further
    */
   private async createAndPublishBlockGloas(pubkey: BLSPubkey, slot: Slot): Promise<void> {
     const pubkeyHex = toPubkeyHex(pubkey);
@@ -180,8 +189,11 @@ export class BlockProposingService {
     const randaoReveal = await this.validatorStore.signRandao(pubkey, slot);
     const graffiti = this.validatorStore.getGraffiti(pubkeyHex);
     const feeRecipient = this.validatorStore.getFeeRecipient(pubkeyHex);
+    const {broadcastValidation, payloadLocal} = this.opts;
+    const {selection: builderSelection, boostFactor: builderBoostFactor} =
+      this.validatorStore.getBuilderSelectionParams(pubkeyHex, slot);
 
-    this.logger.debug("Producing block", {...debugLogCtx, feeRecipient});
+    this.logger.debug("Producing block", {...debugLogCtx, feeRecipient, payloadLocal, builderSelection});
     this.metrics?.proposerStepCallProduceBlock.observe(this.clock.secFromSlot(slot));
 
     // Step 1: Produce beacon block with execution payload bid
@@ -191,19 +203,29 @@ export class BlockProposingService {
         randaoReveal,
         graffiti,
         feeRecipient,
+        includePayload: !payloadLocal,
+        builderSelection,
+        builderBoostFactor,
       })
       .catch((e: Error) => {
         this.metrics?.blockProposingErrors.inc({error: "produce"});
         throw extendError(e, "Failed to produce block");
       });
-    const block = blockRes.value();
+    const blockOrContents = blockRes.value();
     const blockMeta = blockRes.meta();
+    const {executionPayloadIncluded} = blockMeta;
+    const block = executionPayloadIncluded
+      ? (blockOrContents as BlockContents<ForkPostGloas>).block
+      : (blockOrContents as BeaconBlock<ForkPostGloas>);
     const beaconBlockRoot = this.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block);
     const blockRootHex = toRootHex(beaconBlockRoot);
 
     this.logger.debug("Produced block", {
       ...debugLogCtx,
+      executionPayloadValue: prettyWeiToEth(blockMeta.executionPayloadValue),
       consensusBlockValue: prettyWeiToEth(blockMeta.consensusBlockValue),
+      totalBlockValue: prettyWeiToEth(blockMeta.executionPayloadValue + blockMeta.consensusBlockValue),
+      executionPayloadIncluded,
       blockRoot: blockRootHex,
     });
     this.metrics?.blocksProduced.inc();
@@ -211,8 +233,6 @@ export class BlockProposingService {
     // Step 2: Sign and publish the beacon block
     const signedBlock = await this.validatorStore.signBlock(pubkey, block, slot, this.logger);
 
-    const {broadcastValidation} = this.opts;
-
     // Publish the block first so it propagates as soon as possible. This reduces the chance other nodes
     // see the payload envelope before the block over gossip and have to queue it. There's also plenty of
     // time left in the slot to propagate the payload, so publishing it in parallel is unnecessary.
@@ -224,63 +244,105 @@ export class BlockProposingService {
         })
         .catch((e: Error) => {
           this.metrics?.blockProposingErrors.inc({error: "publish"});
-          throw extendError(e, "Failed to publish block");
+          throw extendError(e, `Failed to publish block slot=${slot} blockRoot=${blockRootHex}`);
         })
     ).assertOk();
 
-    this.logger.debug("Published beacon block", {...debugLogCtx, broadcastValidation});
+    this.logger.info("Published beacon block", {
+      ...logCtx,
+      graffiti,
+      executionPayloadValue: prettyWeiToEth(blockMeta.executionPayloadValue),
+      consensusBlockValue: prettyWeiToEth(blockMeta.consensusBlockValue),
+      totalBlockValue: prettyWeiToEth(blockMeta.executionPayloadValue + blockMeta.consensusBlockValue),
+      blockRoot: blockRootHex,
+      broadcastValidation,
+    });
+    this.metrics?.proposerStepCallPublishBlock.observe(this.clock.secFromSlot(slot));
+    this.metrics?.blocksPublished.inc();
 
     const isSelfBuild = block.body.signedExecutionPayloadBid.message.builderIndex === BUILDER_INDEX_SELF_BUILD;
 
     if (isSelfBuild) {
       // Self-build: proposer is responsible for building and publishing the execution payload envelope
-      // Step 3: Get the execution payload envelope
-      const envelopeRes = await this.api.validator.getExecutionPayloadEnvelope({
-        slot,
-        beaconBlockRoot,
-      });
-      const envelope = envelopeRes.value();
-
-      this.logger.debug("Retrieved execution payload envelope", debugLogCtx);
-
-      // Step 4: Sign and publish the envelope
-      const signedEnvelope = await this.validatorStore.signExecutionPayloadEnvelope(
-        pubkey,
-        envelope,
-        slot,
-        this.logger
-      );
-
-      (
-        await this.api.beacon
-          .publishExecutionPayloadEnvelope({
-            signedExecutionPayloadEnvelope: signedEnvelope,
+      const flow = executionPayloadIncluded ? "stateless" : "stateful";
+      if (executionPayloadIncluded) {
+        // Stateless flow: envelope and blobs are already available from block production
+        const {executionPayloadEnvelope, kzgProofs, blobs} = blockOrContents as BlockContents<ForkPostGloas>;
+
+        // Step 3: Sign and publish the envelope with blobs and KZG proofs
+        const signedEnvelope = await this.validatorStore.signExecutionPayloadEnvelope(
+          pubkey,
+          executionPayloadEnvelope,
+          slot,
+          this.logger
+        );
+
+        (
+          await this.api.beacon
+            .publishExecutionPayloadEnvelope({
+              signedEnvelopeOrContents: {signedExecutionPayloadEnvelope: signedEnvelope, kzgProofs, blobs},
+              broadcastValidation,
+            })
+            .catch((e: Error) => {
+              this.metrics?.payloadEnvelopeProposingErrors.inc({error: "publish"});
+              throw extendError(
+                e,
+                `Failed to publish execution payload envelope slot=${slot} blockRoot=${blockRootHex} flow=${flow}`
+              );
+            })
+        ).assertOk();
+      } else {
+        // Stateful flow: fetch the envelope from the same beacon node that produced the block
+        const envelopeRes = await this.api.validator
+          .getExecutionPayloadEnvelope({
+            slot,
+            beaconBlockRoot,
           })
           .catch((e: Error) => {
-            this.metrics?.blockProposingErrors.inc({error: "publish"});
-            throw extendError(e, "Failed to publish execution payload envelope");
-          })
-      ).assertOk();
+            this.metrics?.payloadEnvelopeProposingErrors.inc({error: "produce"});
+            throw extendError(e, `Failed to get execution payload envelope slot=${slot} blockRoot=${blockRootHex}`);
+          });
+        const envelope = envelopeRes.value();
+
+        this.logger.debug("Retrieved execution payload envelope", debugLogCtx);
+
+        // Step 3: Sign and publish the envelope, beacon node attaches blobs and KZG proofs from its cache
+        const signedEnvelope = await this.validatorStore.signExecutionPayloadEnvelope(
+          pubkey,
+          envelope,
+          slot,
+          this.logger
+        );
+
+        (
+          await this.api.beacon
+            .publishExecutionPayloadEnvelope({
+              signedEnvelopeOrContents: signedEnvelope,
+              broadcastValidation,
+            })
+            .catch((e: Error) => {
+              this.metrics?.payloadEnvelopeProposingErrors.inc({error: "publish"});
+              throw extendError(
+                e,
+                `Failed to publish execution payload envelope slot=${slot} blockRoot=${blockRootHex} flow=${flow}`
+              );
+            })
+        ).assertOk();
+      }
 
-      this.logger.info("Published block and execution payload envelope", {
+      this.logger.info("Published execution payload envelope", {
         ...logCtx,
-        graffiti,
-        consensusBlockValue: prettyWeiToEth(blockMeta.consensusBlockValue),
         blockRoot: blockRootHex,
+        flow,
       });
     } else {
-      // Builder is responsible for broadcasting the execution payload envelope
-      this.logger.info("Published block with builder bid, envelope expected from builder", {
+      // Committed to a builder bid, the builder is responsible for revealing the execution payload envelope
+      this.logger.info("Execution payload envelope to be revealed by builder", {
         ...logCtx,
-        graffiti,
         builderIndex: block.body.signedExecutionPayloadBid.message.builderIndex,
-        consensusBlockValue: prettyWeiToEth(blockMeta.consensusBlockValue),
         blockRoot: blockRootHex,
       });
     }
-
-    this.metrics?.proposerStepCallPublishBlock.observe(this.clock.secFromSlot(slot));
-    this.metrics?.blocksPublished.inc();
   }
 
   private publishBlockWrapper = async (
@@ -353,10 +415,8 @@ function parseProduceBlockResponse(
   const executionPayloadSource = response.executionPayloadSource;
 
   if (
-    (builderSelection === routes.validator.BuilderSelection.BuilderOnly &&
-      executionPayloadSource === ProducedBlockSource.engine) ||
-    (builderSelection === routes.validator.BuilderSelection.ExecutionOnly &&
-      executionPayloadSource === ProducedBlockSource.builder)
+    builderSelection === routes.validator.BuilderSelection.ExecutionOnly &&
+    executionPayloadSource === ProducedBlockSource.builder
   ) {
     throw Error(
       `Block not produced as per desired builderSelection=${builderSelection} executionPayloadSource=${executionPayloadSource}`

package/src/services/emitter.ts

@@ -50,25 +50,4 @@ export class ValidatorEventEmitter extends (EventEmitter as {
       this.on(ValidatorEvent.chainHead, headListener);
     });
   }
-
-  /**
-   * Wait for the first execution payload availability event to come with slot >= provided slot.
-   */
-  async waitForExecutionPayloadAvailableSlot(slot: Slot): Promise<void> {
-    let payloadListener: (payload: ExecutionPayloadAvailableEventData) => void;
-
-    const onDone = (): void => {
-      this.off(ValidatorEvent.executionPayloadAvailable, payloadListener);
-    };
-
-    return new Promise((resolve) => {
-      payloadListener = (payload): void => {
-        if (payload.slot >= slot) {
-          onDone();
-          resolve();
-        }
-      };
-      this.on(ValidatorEvent.executionPayloadAvailable, payloadListener);
-    });
-  }
 }

package/src/services/proposerPreferences.ts

@@ -29,7 +29,10 @@ type SubmittedAtEpoch = {dependentRoot: RootHex; slots: Set<Slot>};
  * dependent root for an epoch shifts (e.g. after a reorg) — detected by comparing the cached
  * `dependentRoot` reported by `BlockDutiesService` against the one we last submitted under.
  *
- * No-op pre-gloas.
+ * Proposers should broadcast their preferences before the fork so the proposer preference caches
+ * of beacon nodes and builders are warm for the first Gloas slots. We start submitting
+ * as soon as a duty's proposal slot is in Gloas, which is up to `SUBMIT_BEFORE_PROPOSAL_SLOTS`
+ * before the fork, so only the first few Gloas slots are affected by this pre-fork submission.
  */
 export class ProposerPreferencesService {
   private readonly submitted = new Map<Epoch, SubmittedAtEpoch>();
@@ -44,10 +47,14 @@ export class ProposerPreferencesService {
     _metrics: Metrics | null
   ) {
     clock.runEverySlot(this.runProposerPreferencesTask);
+    clock.runEveryEpoch(this.pruneSubmitted);
   }
 
   private runProposerPreferencesTask = async (slot: Slot): Promise<void> => {
-    if (!isForkPostGloas(this.config.getForkName(slot))) {
+    // Start running once the submission window (`slot + SUBMIT_BEFORE_PROPOSAL_SLOTS`) reaches
+    // Gloas, i.e. already in the epoch before the fork. This allows builders to prepare and
+    // submit bids for the first Gloas slots.
+    if (!isForkPostGloas(this.config.getForkName(slot + SUBMIT_BEFORE_PROPOSAL_SLOTS))) {
       return;
     }
 
@@ -82,6 +89,7 @@ export class ProposerPreferencesService {
       for (const duty of dutiesAtEpoch.data) {
         if (duty.slot <= slot) continue;
         if (duty.slot > slot + SUBMIT_BEFORE_PROPOSAL_SLOTS) continue;
+        if (!isForkPostGloas(this.config.getForkName(duty.slot))) continue;
         if (submission.slots.has(duty.slot)) continue;
 
         try {
@@ -110,7 +118,7 @@ export class ProposerPreferencesService {
     }
 
     try {
-      await this.api.beacon.submitSignedProposerPreferences({signedProposerPreferences: batch});
+      await this.api.validator.submitProposerPreferences({signedProposerPreferences: batch});
       // Only mark as submitted after the API call succeeds; a thrown error leaves the
       // slot eligible for retry on the next tick.
       for (const {submission, slot: submittedSlot} of pending) {
@@ -121,4 +129,13 @@ export class ProposerPreferencesService {
       this.logger.error("Error submitting signed proposer preferences", {count: batch.length}, e as Error);
     }
   };
+
+  /** Drop tracking for past epochs; only currentEpoch and currentEpoch + 1 are ever processed. */
+  private pruneSubmitted = async (epoch: Epoch): Promise<void> => {
+    for (const trackedEpoch of this.submitted.keys()) {
+      if (trackedEpoch < epoch) {
+        this.submitted.delete(trackedEpoch);
+      }
+    }
+  };
 }

package/src/services/ptc.ts

@@ -1,4 +1,4 @@
-import {ApiClient, HttpStatusCode, routes} from "@lodestar/api";
+import {ApiClient, routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {isForkPostGloas} from "@lodestar/params";
 import {Slot, gloas} from "@lodestar/types";
@@ -7,7 +7,7 @@ import {Metrics} from "../metrics.js";
 import {PubkeyHex} from "../types.js";
 import {IClock, LoggerVc} from "../util/index.js";
 import {ChainHeaderTracker} from "./chainHeaderTracker.js";
-import {ValidatorEventEmitter} from "./emitter.js";
+import {ExecutionPayloadAvailableEventData, ValidatorEvent, ValidatorEventEmitter} from "./emitter.js";
 import {PtcDutiesService} from "./ptcDuties.js";
 import {SyncingStatusTracker} from "./syncingStatusTracker.js";
 import {ValidatorStore} from "./validatorStore.js";
@@ -25,7 +25,7 @@ export class PtcService {
     private readonly clock: IClock,
     private readonly validatorStore: ValidatorStore,
     private readonly emitter: ValidatorEventEmitter,
-    chainHeadTracker: ChainHeaderTracker,
+    private readonly chainHeadTracker: ChainHeaderTracker,
     syncingStatusTracker: SyncingStatusTracker,
     private readonly metrics: Metrics | null
   ) {
@@ -59,19 +59,26 @@ export class PtcService {
     }
 
     const payloadAttestationDueMs = this.config.getSlotComponentDurationMs(this.config.PAYLOAD_ATTESTATION_DUE_BPS);
-    await Promise.race([
-      sleep(payloadAttestationDueMs - this.clock.msFromSlot(slot), signal),
-      this.emitter.waitForExecutionPayloadAvailableSlot(slot),
-    ]);
+    // Submit as soon as the canonical head block's payload is available, or at the deadline
+    const payloadAvailable = new AbortController();
+    try {
+      await Promise.race([
+        sleep(payloadAttestationDueMs - this.clock.msFromSlot(slot), signal),
+        this.waitForCanonicalPayload(slot, payloadAvailable.signal),
+      ]);
+    } finally {
+      payloadAvailable.abort();
+    }
 
     this.metrics?.ptcStepCallProducePayloadAttestation.observe(
       this.clock.secFromSlot(slot) - payloadAttestationDueMs / 1000
     );
 
     try {
-      const payloadAttestationData = await this.producePayloadAttestationData(slot);
+      // No canonical block at slot resolves to `undefined`
+      const payloadAttestationData = (await this.api.validator.producePayloadAttestationData({slot})).value();
       // If no beacon block was seen for the assigned slot, do not submit a payload attestation
-      if (payloadAttestationData === null) {
+      if (!payloadAttestationData) {
         this.logger.debug("Skipping payload attestation, no beacon block seen for slot", {slot});
         return;
       }
@@ -81,12 +88,25 @@ export class PtcService {
     }
   };
 
-  private async producePayloadAttestationData(slot: Slot): Promise<gloas.PayloadAttestationData | null> {
-    const res = await this.api.validator.producePayloadAttestationData({slot});
-    if (!res.ok && res.status === HttpStatusCode.NOT_FOUND) {
-      return null;
-    }
-    return res.value();
+  /**
+   * Resolve when the payload for the canonical head block at `slot` is available
+   */
+  private waitForCanonicalPayload(slot: Slot, signal: AbortSignal): Promise<void> {
+    return new Promise((resolve) => {
+      const onPayloadAvailable = (payload: ExecutionPayloadAvailableEventData): void => {
+        const head = this.chainHeadTracker.getCurrentChainHead(slot);
+        if (payload.slot === slot && head !== null && payload.blockRoot === toRootHex(head)) {
+          this.emitter.off(ValidatorEvent.executionPayloadAvailable, onPayloadAvailable);
+          resolve();
+        }
+      };
+      signal.addEventListener(
+        "abort",
+        () => this.emitter.off(ValidatorEvent.executionPayloadAvailable, onPayloadAvailable),
+        {once: true}
+      );
+      this.emitter.on(ValidatorEvent.executionPayloadAvailable, onPayloadAvailable);
+    });
   }
 
   private async signAndPublishPayloadAttestations(

package/src/services/validatorStore.ts

@@ -81,7 +81,8 @@ type DefaultProposerConfig = {
   feeRecipient: ExecutionAddress;
   builder: {
     gasLimit: number;
-    selection: routes.validator.BuilderSelection;
+    // Left undefined when not configured so the fork-appropriate default can be resolved per slot
+    selection?: routes.validator.BuilderSelection;
     boostFactor: bigint;
   };
 };
@@ -182,7 +183,7 @@ export class ValidatorStore {
       feeRecipient: defaultConfig.feeRecipient ?? defaultOptions.suggestedFeeRecipient,
       builder: {
         gasLimit: defaultConfig.builder?.gasLimit ?? defaultOptions.defaultGasLimit,
-        selection: defaultConfig.builder?.selection ?? defaultOptions.builderSelection,
+        selection: defaultConfig.builder?.selection,
         boostFactor: builderBoostFactor,
       },
     };
@@ -278,9 +279,21 @@ export class ValidatorStore {
     delete validatorData.graffiti;
   }
 
-  getBuilderSelectionParams(pubkeyHex: PubkeyHex): {selection: routes.validator.BuilderSelection; boostFactor: bigint} {
+  getBuilderSelectionParams(
+    pubkeyHex: PubkeyHex,
+    slot?: Slot
+  ): {selection: routes.validator.BuilderSelection; boostFactor: bigint} {
+    // Builder bids post-gloas are in-protocol over p2p, so the default strategy uses them
+    // (as if `--builder` was set), unless the validator explicitly opted out. Pre-gloas
+    // there is no in-protocol builder, so the default remains local-only (executiononly).
+    const defaultSelection =
+      slot !== undefined && this.config.getForkSeq(slot) >= ForkSeq.gloas
+        ? defaultOptions.builderAliasSelection
+        : defaultOptions.builderSelection;
     const selection =
-      this.validators.get(pubkeyHex)?.builder?.selection ?? this.defaultProposerConfig.builder.selection;
+      this.validators.get(pubkeyHex)?.builder?.selection ??
+      this.defaultProposerConfig.builder.selection ??
+      defaultSelection;
 
     let boostFactor: bigint;
     switch (selection) {
@@ -607,9 +620,11 @@ export class ValidatorStore {
     const signingSlot = aggregate.data.slot;
     const domain = this.config.getDomain(signingSlot, DOMAIN_AGGREGATE_AND_PROOF);
     const isPostElectra = this.config.getForkSeq(signingSlot) >= ForkSeq.electra;
-    const signingRoot = isPostElectra
-      ? computeSigningRoot(ssz.electra.AggregateAndProof, aggregateAndProof, domain)
-      : computeSigningRoot(ssz.phase0.AggregateAndProof, aggregateAndProof, domain);
+    const signingRoot = computeSigningRoot(
+      this.config.getForkTypes(signingSlot).AggregateAndProof,
+      aggregateAndProof,
+      domain
+    );
 
     const signableMessage: SignableMessage = {
       type: isPostElectra ? SignableMessageType.AGGREGATE_AND_PROOF_V2 : SignableMessageType.AGGREGATE_AND_PROOF,

package/src/util/params.ts

@@ -326,9 +326,12 @@ function getSpecCriticalParams(localConfig: ChainConfig): Record<keyof ConfigWit
     MAX_PAYLOAD_ATTESTATIONS: gloasForkRelevant,
     MAX_BUILDER_DEPOSIT_REQUESTS_PER_PAYLOAD: gloasForkRelevant,
     MAX_BUILDER_EXIT_REQUESTS_PER_PAYLOAD: gloasForkRelevant,
-    BUILDER_REGISTRY_LIMIT: gloasForkRelevant,
-    BUILDER_PENDING_WITHDRAWALS_LIMIT: gloasForkRelevant,
     MAX_BUILDERS_PER_WITHDRAWALS_SWEEP: gloasForkRelevant,
+    MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE: false,
+    MAX_ATTESTER_SLASHING_SIZE: false,
+    MAX_DATA_COLUMN_SIDECAR_SIZE: false,
+    MAX_PARTIAL_DATA_COLUMN_SIDECAR_SIZE: false,
+    MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE: false,
     MIN_BUILDER_WITHDRAWABILITY_DELAY: gloasForkRelevant,
 
     // FastConfirmationRule

package/src/validator.ts

@@ -66,6 +66,7 @@ export type ValidatorOptions = {
   distributed?: boolean;
   broadcastValidation?: routes.beacon.BroadcastValidation;
   blindedLocal?: boolean;
+  payloadLocal?: boolean;
   externalSigner?: ExternalSignerOptions;
   clock?: ClockOptions;
 };
@@ -256,6 +257,9 @@ export class Validator {
       {
         broadcastValidation: opts.broadcastValidation ?? defaultOptions.broadcastValidation,
         blindedLocal: opts.blindedLocal ?? defaultOptions.blindedLocal,
+        // Default to keeping the payload local to the beacon node if only a single node is
+        // configured, with multiple nodes the stateless flow allows publishing via any of them
+        payloadLocal: opts.payloadLocal ?? api.httpClient.urlsInits.length <= 1,
       }
     );