feat: implement epbs block production (#8838)

Notable changes
- implement epbs stateful block production (self-build only)
  - `GET /eth/v4/validator/blocks/{slot}` added
- `GET
/eth/v1/validator/execution_payload_envelope/{slot}/{beacon_block_root}`
added
  - `POST /eth/v1/beacon/execution_payload_envelope` added
  - `POST /eth/v2/beacon/blocks` updated
- implement envelope state root computation
- update block production cache for gloas (includes state root)
- add validator block production flow for gloas
- add envelope signing to validator store / remote signer
- data column sidecar changes required to wire up new gloas type
- update beacon-api spec to `v5.0.0-alpha.0`

see ethereum/beacon-APIs#580 for reference

Author: nflaig

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

@@ -3,11 +3,13 @@ import {ChainForkConfig} from "@lodestar/config";
 import {
   ForkName,
   ForkPostDeneb,
+  ForkPostGloas,
   ForkPreBellatrix,
   ForkPreDeneb,
   ForkPreElectra,
   isForkPostBellatrix,
   isForkPostDeneb,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   BeaconBlockBody,
@@ -17,11 +19,12 @@ import {
   SignedBlockContents,
   Slot,
   deneb,
+  gloas,
   ssz,
   sszTypesFor,
 } from "@lodestar/types";
 import {EmptyMeta, EmptyResponseCodec, EmptyResponseData, WithVersion} from "../../../utils/codecs.js";
-import {getPostBellatrixForkTypes, toForkName} from "../../../utils/fork.js";
+import {getPostBellatrixForkTypes, getPostGloasForkTypes, toForkName} from "../../../utils/fork.js";
 import {fromHeaders} from "../../../utils/headers.js";
 import {Endpoint, RequestCodec, RouteDefinitions, Schema} from "../../../utils/index.js";
 import {
@@ -209,6 +212,20 @@ export type Endpoints = {
     EmptyMeta
   >;
 
+  /**
+   * Publish signed execution payload envelope.
+   * Instructs the beacon node to broadcast a signed execution payload envelope to the network,
+   * to be gossiped for payload validation. A success response (20x) indicates that the envelope
+   * passed gossip validation and was successfully broadcast onto the network.
+   */
+  publishExecutionPayloadEnvelope: Endpoint<
+    "POST",
+    {signedExecutionPayloadEnvelope: gloas.SignedExecutionPayloadEnvelope},
+    {body: unknown; headers: {[MetaHeader.Version]: string}},
+    EmptyResponseData,
+    EmptyMeta
+  >;
+
   /**
    * Get block BlobSidecar
    * Retrieves BlobSidecar included in requested block.
@@ -406,11 +423,14 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
           const slot = signedBlockContents.signedBlock.message.slot;
           const fork = config.getForkName(slot);
           return {
-            body: isForkPostDeneb(fork)
-              ? sszTypesFor(fork).SignedBlockContents.toJson(signedBlockContents as SignedBlockContents<ForkPostDeneb>)
-              : sszTypesFor(fork).SignedBeaconBlock.toJson(
-                  signedBlockContents.signedBlock as SignedBeaconBlock<ForkPreDeneb>
-                ),
+            body:
+              isForkPostDeneb(fork) && !isForkPostGloas(fork)
+                ? sszTypesFor(fork).SignedBlockContents.toJson(
+                    signedBlockContents as SignedBlockContents<ForkPostDeneb>
+                  )
+                : sszTypesFor(fork).SignedBeaconBlock.toJson(
+                    signedBlockContents.signedBlock as SignedBeaconBlock<ForkPreDeneb | ForkPostGloas>
+                  ),
             headers: {
               [MetaHeader.Version]: fork,
             },
@@ -420,9 +440,10 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
         parseReqJson: ({body, headers, query}) => {
           const forkName = toForkName(fromHeaders(headers, MetaHeader.Version));
           return {
-            signedBlockContents: isForkPostDeneb(forkName)
-              ? sszTypesFor(forkName).SignedBlockContents.fromJson(body)
-              : {signedBlock: ssz[forkName].SignedBeaconBlock.fromJson(body)},
+            signedBlockContents:
+              isForkPostDeneb(forkName) && !isForkPostGloas(forkName)
+                ? sszTypesFor(forkName).SignedBlockContents.fromJson(body)
+                : {signedBlock: ssz[forkName].SignedBeaconBlock.fromJson(body)},
             broadcastValidation: query.broadcast_validation as BroadcastValidation,
           };
         },
@@ -431,13 +452,14 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
           const fork = config.getForkName(slot);
 
           return {
-            body: isForkPostDeneb(fork)
-              ? sszTypesFor(fork).SignedBlockContents.serialize(
-                  signedBlockContents as SignedBlockContents<ForkPostDeneb>
-                )
-              : sszTypesFor(fork).SignedBeaconBlock.serialize(
-                  signedBlockContents.signedBlock as SignedBeaconBlock<ForkPreDeneb>
-                ),
+            body:
+              isForkPostDeneb(fork) && !isForkPostGloas(fork)
+                ? sszTypesFor(fork).SignedBlockContents.serialize(
+                    signedBlockContents as SignedBlockContents<ForkPostDeneb>
+                  )
+                : sszTypesFor(fork).SignedBeaconBlock.serialize(
+                    signedBlockContents.signedBlock as SignedBeaconBlock<ForkPreDeneb | ForkPostGloas>
+                  ),
             headers: {
               [MetaHeader.Version]: fork,
             },
@@ -447,9 +469,10 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
         parseReqSsz: ({body, headers, query}) => {
           const forkName = toForkName(fromHeaders(headers, MetaHeader.Version));
           return {
-            signedBlockContents: isForkPostDeneb(forkName)
-              ? sszTypesFor(forkName).SignedBlockContents.deserialize(body)
-              : {signedBlock: ssz[forkName].SignedBeaconBlock.deserialize(body)},
+            signedBlockContents:
+              isForkPostDeneb(forkName) && !isForkPostGloas(forkName)
+                ? sszTypesFor(forkName).SignedBlockContents.deserialize(body)
+                : {signedBlock: ssz[forkName].SignedBeaconBlock.deserialize(body)},
             broadcastValidation: query.broadcast_validation as BroadcastValidation,
           };
         },
@@ -566,6 +589,51 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
         requestWireFormat: WireFormat.ssz,
       },
     },
+    publishExecutionPayloadEnvelope: {
+      url: "/eth/v1/beacon/execution_payload_envelope",
+      method: "POST",
+      req: {
+        writeReqJson: ({signedExecutionPayloadEnvelope}) => {
+          const fork = config.getForkName(signedExecutionPayloadEnvelope.message.slot);
+          return {
+            body: getPostGloasForkTypes(fork).SignedExecutionPayloadEnvelope.toJson(signedExecutionPayloadEnvelope),
+            headers: {
+              [MetaHeader.Version]: fork,
+            },
+          };
+        },
+        parseReqJson: ({body, headers}) => {
+          const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            signedExecutionPayloadEnvelope: getPostGloasForkTypes(fork).SignedExecutionPayloadEnvelope.fromJson(body),
+          };
+        },
+        writeReqSsz: ({signedExecutionPayloadEnvelope}) => {
+          const fork = config.getForkName(signedExecutionPayloadEnvelope.message.slot);
+          return {
+            body: getPostGloasForkTypes(fork).SignedExecutionPayloadEnvelope.serialize(signedExecutionPayloadEnvelope),
+            headers: {
+              [MetaHeader.Version]: fork,
+            },
+          };
+        },
+        parseReqSsz: ({body, headers}) => {
+          const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
+          return {
+            signedExecutionPayloadEnvelope:
+              getPostGloasForkTypes(fork).SignedExecutionPayloadEnvelope.deserialize(body),
+          };
+        },
+        schema: {
+          body: Schema.Object,
+          headers: {[MetaHeader.Version]: Schema.String},
+        },
+      },
+      resp: EmptyResponseCodec,
+      init: {
+        requestWireFormat: WireFormat.ssz,
+      },
+    },
     getBlobSidecars: {
       url: "/eth/v1/beacon/blob_sidecars/{block_id}",
       method: "GET",

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

@@ -2,6 +2,7 @@ import {ContainerType, Type, ValueOf} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";
 import {
   ForkPostDeneb,
+  ForkPostGloas,
   ForkPreDeneb,
   VALIDATOR_REGISTRY_LIMIT,
   isForkPostDeneb,
@@ -22,6 +23,7 @@ import {
   UintBn64,
   ValidatorIndex,
   altair,
+  gloas,
   phase0,
   ssz,
   sszTypesFor,
@@ -36,7 +38,7 @@ import {
   JsonOnlyReq,
   WithVersion,
 } from "../../utils/codecs.js";
-import {getPostBellatrixForkTypes, toForkName} from "../../utils/fork.js";
+import {getPostBellatrixForkTypes, getPostGloasForkTypes, toForkName} from "../../utils/fork.js";
 import {fromHeaders} from "../../utils/headers.js";
 import {Endpoint, RouteDefinitions, Schema} from "../../utils/index.js";
 import {
@@ -89,6 +91,17 @@ export type ProduceBlockV3Meta = ValueOf<typeof ProduceBlockV3MetaType> & {
   executionPayloadSource: ProducedBlockSource;
 };
 
+export const ProduceBlockV4MetaType = new ContainerType(
+  {
+    ...VersionType.fields,
+    /** Consensus rewards paid to the proposer for this block, in Wei */
+    consensusBlockValue: ssz.UintBn64,
+  },
+  {jsonCase: "eth2"}
+);
+
+export type ProduceBlockV4Meta = ValueOf<typeof ProduceBlockV4MetaType>;
+
 export const AttesterDutyType = new ContainerType(
   {
     /** The validator's public key, uniquely identifying them */
@@ -357,6 +370,59 @@ export type Endpoints = {
     ProduceBlockV3Meta
   >;
 
+  /**
+   * Requests a beacon node to produce a valid block, which can then be signed by a validator.
+   *
+   * Post-Gloas, proposers submit execution payload bids rather than full execution payloads,
+   * so there is no longer a concept of blinded or unblinded blocks. Builders release the payload later.
+   * This endpoint is specific to the post-Gloas forks and is not backwards compatible with previous forks.
+   */
+  produceBlockV4: Endpoint<
+    "GET",
+    {
+      /** The slot for which the block should be proposed */
+      slot: Slot;
+      /** The validator's randao reveal value */
+      randaoReveal: BLSSignature;
+      /** Arbitrary data validator wants to include in block */
+      graffiti?: string;
+      skipRandaoVerification?: boolean;
+      builderBoostFactor?: UintBn64;
+    } & Omit<ExtraProduceBlockOpts, "blindedLocal">,
+    {
+      params: {slot: number};
+      query: {
+        randao_reveal: string;
+        graffiti?: string;
+        skip_randao_verification?: string;
+        fee_recipient?: string;
+        builder_selection?: string;
+        builder_boost_factor?: string;
+        strict_fee_recipient_check?: boolean;
+      };
+    },
+    BeaconBlock<ForkPostGloas>,
+    ProduceBlockV4Meta
+  >;
+
+  /**
+   * Get execution payload envelope.
+   * Retrieves execution payload envelope for a given slot and beacon block root.
+   * The envelope contains the full execution payload along with associated metadata.
+   */
+  getExecutionPayloadEnvelope: Endpoint<
+    "GET",
+    {
+      /** Slot for which the execution payload envelope is requested */
+      slot: Slot;
+      /** Root of the beacon block that this envelope is for */
+      beaconBlockRoot: Root;
+    },
+    {params: {slot: Slot; beacon_block_root: string}},
+    gloas.ExecutionPayloadEnvelope,
+    VersionMeta
+  >;
+
   /**
    * Produce an attestation data
    * Requests that the beacon node produce an AttestationData.
@@ -763,6 +829,96 @@ export function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoi
         },
       },
     },
+    produceBlockV4: {
+      url: "/eth/v4/validator/blocks/{slot}",
+      method: "GET",
+      req: {
+        writeReq: ({
+          slot,
+          randaoReveal,
+          graffiti,
+          skipRandaoVerification,
+          feeRecipient,
+          builderSelection,
+          builderBoostFactor,
+          strictFeeRecipientCheck,
+        }) => ({
+          params: {slot},
+          query: {
+            randao_reveal: toHex(randaoReveal),
+            graffiti: toGraffitiHex(graffiti),
+            skip_randao_verification: writeSkipRandaoVerification(skipRandaoVerification),
+            fee_recipient: feeRecipient,
+            builder_selection: builderSelection,
+            builder_boost_factor: builderBoostFactor?.toString(),
+            strict_fee_recipient_check: strictFeeRecipientCheck,
+          },
+        }),
+        parseReq: ({params, query}) => ({
+          slot: params.slot,
+          randaoReveal: fromHex(query.randao_reveal),
+          graffiti: fromGraffitiHex(query.graffiti),
+          skipRandaoVerification: parseSkipRandaoVerification(query.skip_randao_verification),
+          feeRecipient: query.fee_recipient,
+          builderSelection: query.builder_selection as BuilderSelection,
+          builderBoostFactor: parseBuilderBoostFactor(query.builder_boost_factor),
+          strictFeeRecipientCheck: query.strict_fee_recipient_check,
+        }),
+        schema: {
+          params: {slot: Schema.UintRequired},
+          query: {
+            randao_reveal: Schema.StringRequired,
+            graffiti: Schema.String,
+            skip_randao_verification: Schema.String,
+            fee_recipient: Schema.String,
+            builder_selection: Schema.String,
+            builder_boost_factor: Schema.String,
+            strict_fee_recipient_check: Schema.Boolean,
+          },
+        },
+      },
+      resp: {
+        data: WithVersion((fork) => getPostGloasForkTypes(fork).BeaconBlock),
+        meta: {
+          toJson: (meta) => ProduceBlockV4MetaType.toJson(meta),
+          fromJson: (val) => ProduceBlockV4MetaType.fromJson(val),
+          toHeadersObject: (meta) => ({
+            [MetaHeader.Version]: meta.version,
+            [MetaHeader.ConsensusBlockValue]: meta.consensusBlockValue.toString(),
+          }),
+          fromHeaders: (headers) => ({
+            version: toForkName(headers.getRequired(MetaHeader.Version)),
+            consensusBlockValue: BigInt(headers.getRequired(MetaHeader.ConsensusBlockValue)),
+          }),
+        },
+      },
+    },
+    getExecutionPayloadEnvelope: {
+      url: "/eth/v1/validator/execution_payload_envelope/{slot}/{beacon_block_root}",
+      method: "GET",
+      req: {
+        writeReq: ({slot, beaconBlockRoot}) => ({
+          params: {
+            slot,
+            beacon_block_root: toRootHex(beaconBlockRoot),
+          },
+        }),
+        parseReq: ({params}) => ({
+          slot: params.slot,
+          beaconBlockRoot: fromHex(params.beacon_block_root),
+        }),
+        schema: {
+          params: {
+            slot: Schema.UintRequired,
+            beacon_block_root: Schema.StringRequired,
+          },
+        },
+      },
+      resp: {
+        data: ssz.gloas.ExecutionPayloadEnvelope,
+        meta: VersionCodec,
+      },
+    },
     produceAttestationData: {
       url: "/eth/v1/validator/attestation_data",
       method: "GET",

packages/api/src/utils/fork.ts

@@ -3,9 +3,11 @@ import {
   ForkPostAltair,
   ForkPostBellatrix,
   ForkPostDeneb,
+  ForkPostGloas,
   isForkPostAltair,
   isForkPostBellatrix,
   isForkPostDeneb,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {SSZTypesFor, sszTypesFor} from "@lodestar/types";
 
@@ -42,3 +44,11 @@ export function getPostDenebForkTypes(fork: ForkName): SSZTypesFor<ForkPostDeneb
 
   return sszTypesFor(fork);
 }
+
+export function getPostGloasForkTypes(fork: ForkName): SSZTypesFor<ForkPostGloas> {
+  if (!isForkPostGloas(fork)) {
+    throw Error(`Invalid fork=${fork} for post-gloas fork types`);
+  }
+
+  return sszTypesFor(fork);
+}