De-couple block production

packages/api/src/beacon/routes/beacon/block.ts

@@ -2,7 +2,6 @@ import {ContainerType} from "@chainsafe/ssz";
 import {ForkName} from "@lodestar/params";
 import {IChainForkConfig} from "@lodestar/config";
 import {phase0, allForks, Slot, Root, ssz, RootHex} from "@lodestar/types";
-import {SignedBeaconBlockAndBlobsSidecar} from "@lodestar/types/eip4844";
 
 import {
   RoutesData,
@@ -111,8 +110,6 @@ export type Api = {
    * transactions beacon node gets in response.
    */
   publishBlindedBlock(block: allForks.SignedBlindedBeaconBlock): Promise<void>;
-
-  publishBlockWithBlobs(blockWithBlobs: SignedBeaconBlockAndBlobsSidecar): Promise<void>;
 };
 
 /**
@@ -126,7 +123,6 @@ export const routesData: RoutesData<Api> = {
   getBlockHeaders: {url: "/eth/v1/beacon/headers", method: "GET"},
   getBlockRoot: {url: "/eth/v1/beacon/blocks/{block_id}/root", method: "GET"},
   publishBlock: {url: "/eth/v1/beacon/blocks", method: "POST"},
-  publishBlockWithBlobs: {url: "/eth/v1/beacon/blocksWithBlobs", method: "POST"},
   publishBlindedBlock: {url: "/eth/v1/beacon/blinded_blocks", method: "POST"},
 };
 
@@ -142,7 +138,6 @@ export type ReqTypes = {
   getBlockHeaders: {query: {slot?: number; parent_root?: string}};
   getBlockRoot: BlockIdOnlyReq;
   publishBlock: {body: unknown};
-  publishBlockWithBlobs: {body: unknown};
   publishBlindedBlock: {body: unknown};
 };
 
@@ -162,12 +157,6 @@ export function getReqSerializers(config: IChainForkConfig): ReqSerializers<Api,
     fromJson: (data) => getSignedBeaconBlockType((data as unknown) as allForks.SignedBeaconBlock).fromJson(data),
   };
 
-  const BlockWithBlobsSsz = ssz.eip4844.SignedBeaconBlockAndBlobsSidecar;
-  const SignedBeaconBlockWithBlobs: TypeJson<SignedBeaconBlockAndBlobsSidecar> = {
-    toJson: (data) => BlockWithBlobsSsz.toJson(data),
-    fromJson: (data) => BlockWithBlobsSsz.fromJson(data),
-  };
-
   const getSignedBlindedBeaconBlockType = (
     data: allForks.SignedBlindedBeaconBlock
   ): allForks.AllForksBlindedSSZTypes["SignedBeaconBlock"] =>
@@ -191,7 +180,6 @@ export function getReqSerializers(config: IChainForkConfig): ReqSerializers<Api,
     },
     getBlockRoot: blockIdOnlyReq,
     publishBlock: reqOnlyBody(AllForksSignedBeaconBlock, Schema.Object),
-    publishBlockWithBlobs: reqOnlyBody(SignedBeaconBlockWithBlobs, Schema.Object),
     publishBlindedBlock: reqOnlyBody(AllForksSignedBlindedBeaconBlock, Schema.Object),
   };
 }

packages/api/src/beacon/routes/validator.ts

@@ -9,7 +9,6 @@ import {
   Epoch,
   phase0,
   bellatrix,
-  eip4844,
   Root,
   Slot,
   ssz,
@@ -24,7 +23,6 @@ import {
   ArrayOf,
   ContainerData,
   Schema,
-  WithBlobs,
   WithVersion,
   reqOnlyBody,
   ReqSerializers,
@@ -167,12 +165,6 @@ export type Api = {
     graffiti: string
   ): Promise<{data: allForks.BeaconBlock; version: ForkName}>;
 
-  produceBlockWithBlobs(
-    slot: Slot,
-    randaoReveal: BLSSignature,
-    graffiti: string
-  ): Promise<{data: allForks.BeaconBlock; version: ForkName; blobs: eip4844.Blobs}>;
-
   produceBlindedBlock(
     slot: Slot,
     randaoReveal: BLSSignature,
@@ -253,7 +245,6 @@ export const routesData: RoutesData<Api> = {
   getSyncCommitteeDuties: {url: "/eth/v1/validator/duties/sync/{epoch}", method: "POST"},
   produceBlock: {url: "/eth/v1/validator/blocks/{slot}", method: "GET"},
   produceBlockV2: {url: "/eth/v2/validator/blocks/{slot}", method: "GET"},
-  produceBlockWithBlobs: {url: "/eth/v3/validator/blocks/{slot}", method: "GET"},
   produceBlindedBlock: {url: "/eth/v1/validator/blinded_blocks/{slot}", method: "GET"},
   produceAttestationData: {url: "/eth/v1/validator/attestation_data", method: "GET"},
   produceSyncCommitteeContribution: {url: "/eth/v1/validator/sync_committee_contribution", method: "GET"},
@@ -274,7 +265,6 @@ export type ReqTypes = {
   getSyncCommitteeDuties: {params: {epoch: Epoch}; body: U64Str[]};
   produceBlock: {params: {slot: number}; query: {randao_reveal: string; graffiti: string}};
   produceBlockV2: {params: {slot: number}; query: {randao_reveal: string; graffiti: string}};
-  produceBlockWithBlobs: {params: {slot: number}; query: {randao_reveal: string; graffiti: string}};
   produceBlindedBlock: {params: {slot: number}; query: {randao_reveal: string; graffiti: string}};
   produceAttestationData: {query: {slot: number; committee_index: number}};
   produceSyncCommitteeContribution: {query: {slot: number; subcommittee_index: number; beacon_block_root: string}};
@@ -350,7 +340,6 @@ export function getReqSerializers(): ReqSerializers<Api, ReqTypes> {
 
     produceBlock: produceBlock,
     produceBlockV2: produceBlock,
-    produceBlockWithBlobs: produceBlock,
     produceBlindedBlock: produceBlock,
 
     produceAttestationData: {
@@ -454,7 +443,6 @@ export function getReturnTypes(): ReturnTypes<Api> {
     getSyncCommitteeDuties: ContainerDataExecutionOptimistic(ArrayOf(SyncDuty)),
     produceBlock: ContainerData(ssz.phase0.BeaconBlock),
     produceBlockV2: WithVersion((fork: ForkName) => ssz[fork].BeaconBlock),
-    produceBlockWithBlobs: WithBlobs(WithVersion((fork: ForkName) => ssz[fork].BeaconBlock)),
     produceBlindedBlock: WithVersion((fork: ForkName) => {
       if (fork === ForkName.phase0 || fork === ForkName.altair) {
         throw Error(`No BlindedBlock for fork ${fork} previous to bellatrix`);

packages/beacon-node/src/api/impl/beacon/blocks/index.ts

@@ -202,27 +202,5 @@ export function getBeaconBlockApi({
         }),
       ]);
     },
-
-    async publishBlockWithBlobs(signedBeaconBlockAndBlobsSidecar) {
-      const {beaconBlock} = signedBeaconBlockAndBlobsSidecar;
-      const {message} = beaconBlock;
-
-      const seenTimestampSec = Date.now() / 1000;
-      await waitForSlot(message.slot);
-
-      metrics?.registerBeaconBlock(OpSource.api, seenTimestampSec, message);
-
-      await Promise.all([
-        network.gossip.publishSignedBeaconBlockAndBlobsSidecar(signedBeaconBlockAndBlobsSidecar),
-        // TODO EIP-4844 processBlock for signedBeaconBlockAndBlobsSidecar
-        // We need to save the blob?
-        chain.processBlock(beaconBlock).catch((e) => {
-          if (e instanceof BlockError && e.type.code === BlockErrorCode.PARENT_UNKNOWN) {
-            network.events.emit(NetworkEvent.unknownBlockParent, beaconBlock, network.peerId.toString());
-          }
-          throw e;
-        }),
-      ]);
-    },
   };
 }

packages/beacon-node/src/api/impl/validator/index.ts

@@ -237,40 +237,9 @@ export function getValidatorApi({chain, config, logger, metrics, network, sync}:
     }
   };
 
-  const produceBlockWithBlobs: routes.validator.Api["produceBlockWithBlobs"] = async function produceBlock(
-    slot,
-    randaoReveal,
-    graffiti
-  ) {
-    let timer;
-    metrics?.blockProductionRequests.inc();
-    try {
-      notWhileSyncing();
-      await waitForSlot(slot); // Must never request for a future slot > currentSlot
-
-      // Process the queued attestations in the forkchoice for correct head estimation
-      // forkChoice.updateTime() might have already been called by the onSlot clock
-      // handler, in which case this should just return.
-      chain.forkChoice.updateTime(slot);
-      chain.recomputeForkChoiceHead();
-
-      timer = metrics?.blockProductionTime.startTimer();
-      const {block, blobs} = await chain.produceBlockWithBlobs({
-        slot,
-        randaoReveal,
-        graffiti: toGraffitiBuffer(graffiti || ""),
-      });
-      metrics?.blockProductionSuccess.inc();
-      return {data: block, version: config.getForkName(block.slot), blobs};
-    } finally {
-      if (timer) timer();
-    }
-  };
-
   return {
     produceBlock: produceBlock,
     produceBlockV2: produceBlock,
-    produceBlockWithBlobs,
     produceBlindedBlock,
 
     async produceAttestationData(committeeIndex, slot) {

packages/beacon-node/src/chain/chain.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import {computeAggregateKzgProof} from "c-kzg";
 import {
   BeaconStateAllForks,
   CachedBeaconStateAllForks,
@@ -60,7 +61,7 @@ import {SeenBlockAttesters} from "./seenCache/seenBlockAttesters.js";
 import {BeaconProposerCache} from "./beaconProposerCache.js";
 import {CheckpointBalancesCache} from "./balancesCache.js";
 import {AssembledBlockType, BlockType} from "./produceBlock/index.js";
-import {BlockAttributes, produceBlockBody} from "./produceBlock/produceBlockBody.js";
+import {BlobsResultType, BlockAttributes, produceBlockBody} from "./produceBlock/produceBlockBody.js";
 import {computeNewStateRoot} from "./produceBlock/computeNewStateRoot.js";
 
 export class BeaconChain implements IBeaconChain {
@@ -118,6 +119,8 @@ export class BeaconChain implements IBeaconChain {
   private successfulExchangeTransition = false;
   private readonly exchangeTransitionConfigurationEverySlots: number;
 
+  private readonly producedBlobsCache = new Map<RootHex, eip4844.Blobs>();
+
   private readonly faultInspectionWindow: number;
   private readonly allowedFaults: number;
   private processShutdownCallback: ProcessShutdownCallback;
@@ -340,26 +343,18 @@ export class BeaconChain implements IBeaconChain {
     return await this.db.block.get(fromHexString(block.blockRoot));
   }
 
-  async produceBlock(blockAttributes: BlockAttributes): Promise<allForks.BeaconBlock> {
-    const {block} = await this.produceBlockWrapper<BlockType.Full>(BlockType.Full, blockAttributes);
-    return block;
-  }
-
-  async produceBlockWithBlobs(
-    blockAttributes: BlockAttributes
-  ): Promise<{block: allForks.BeaconBlock; blobs: eip4844.Blobs}> {
+  produceBlock(blockAttributes: BlockAttributes): Promise<allForks.BeaconBlock> {
     return this.produceBlockWrapper<BlockType.Full>(BlockType.Full, blockAttributes);
   }
 
-  async produceBlindedBlock(blockAttributes: BlockAttributes): Promise<allForks.BlindedBeaconBlock> {
-    const {block} = await this.produceBlockWrapper<BlockType.Blinded>(BlockType.Blinded, blockAttributes);
-    return block;
+  produceBlindedBlock(blockAttributes: BlockAttributes): Promise<allForks.BlindedBeaconBlock> {
+    return this.produceBlockWrapper<BlockType.Blinded>(BlockType.Blinded, blockAttributes);
   }
 
   async produceBlockWrapper<T extends BlockType>(
     blockType: T,
     {randaoReveal, graffiti, slot}: BlockAttributes
-  ): Promise<{block: AssembledBlockType<T>; blobs: eip4844.Blobs}> {
+  ): Promise<AssembledBlockType<T>> {
     const head = this.forkChoice.getHead();
     const state = await this.regen.getBlockSlotState(head.blockRoot, slot, RegenCaller.produceBlock);
     const parentBlockRoot = fromHexString(head.blockRoot);
@@ -386,7 +381,36 @@ export class BeaconChain implements IBeaconChain {
 
     block.stateRoot = computeNewStateRoot(this.metrics, state, block);
 
-    return {block, blobs: blobs ?? []};
+    // Cache for latter broadcasting
+    if (blobs.type === BlobsResultType.produced) {
+      this.producedBlobsCache.set(blobs.blockRoot, blobs.blobs);
+    }
+
+    return block;
+  }
+
+  /**
+   * https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/validator.md#sidecar
+   * def get_blobs_sidecar(block: BeaconBlock, blobs: Sequence[Blob]) -> BlobsSidecar:
+   *   return BlobsSidecar(
+   *       beacon_block_root=hash_tree_root(block),
+   *       beacon_block_slot=block.slot,
+   *       blobs=blobs,
+   *       kzg_aggregated_proof=compute_proof_from_blobs(blobs),
+   *   )
+   */
+  getBlobsSidecar(beaconBlockRoot: RootHex): eip4844.BlobsSidecar {
+    const blobs = this.producedBlobsCache.get(beaconBlockRoot);
+    if (!blobs) {
+      throw Error(`No blobs for beaconBlockRoot ${beaconBlockRoot}`);
+    }
+
+    return {
+      beaconBlockRoot: beaconBlockRoot,
+      beaconBlockSlot: blobs.slot,
+      blobs: blobs,
+      kzgAggregatedProof: computeAggregateKzgProof(blobs),
+    };
   }
 
   async processBlock(block: allForks.SignedBeaconBlock, opts?: ImportBlockOpts): Promise<void> {

packages/beacon-node/src/chain/interface.ts

@@ -109,7 +109,6 @@ export interface IBeaconChain {
   getCanonicalBlockAtSlot(slot: Slot): Promise<allForks.SignedBeaconBlock | null>;
 
   produceBlock(blockAttributes: BlockAttributes): Promise<allForks.BeaconBlock>;
-  produceBlockWithBlobs(blockAttributes: BlockAttributes): Promise<{block: allForks.BeaconBlock; blobs: eip4844.Blobs}>;
   produceBlindedBlock(blockAttributes: BlockAttributes): Promise<allForks.BlindedBeaconBlock>;
 
   /** Process a block until complete */

packages/beacon-node/src/chain/options.ts

@@ -20,6 +20,7 @@ export type IChainOptions = BlockProcessOpts &
     faultInspectionWindow?: number;
     /** Number of missed slots allowed in the faultInspectionWindow for builder circuit*/
     allowedFaults?: number;
+    sanityCheckExecutionEngineBlocks?: boolean;
   };
 
 export type BlockProcessOpts = {