@lodestar/beacon-node 1.42.0-dev.7e96447c23 → 1.42.0-dev.84f3b9f030

package/src/network/interface.ts

@@ -38,7 +38,12 @@ import {
 import {BlockInputSource} from "../chain/blocks/blockInput/types.js";
 import {CustodyConfig} from "../util/dataColumns.js";
 import {PeerIdStr} from "../util/peerId.js";
-import {BeaconBlocksByRootRequest, BlobSidecarsByRootRequest, DataColumnSidecarsByRootRequest} from "../util/types.js";
+import {
+  BeaconBlocksByRootRequest,
+  BlobSidecarsByRootRequest,
+  DataColumnSidecarsByRootRequest,
+  ExecutionPayloadEnvelopesByRootRequest,
+} from "../util/types.js";
 import {INetworkCorePublic} from "./core/types.js";
 import {INetworkEventBus} from "./events.js";
 import {GossipType} from "./gossip/interface.js";
@@ -82,6 +87,14 @@ export interface INetwork extends INetworkCorePublic {
     peerId: PeerIdStr,
     request: DataColumnSidecarsByRootRequest
   ): Promise<fulu.DataColumnSidecar[]>;
+  sendExecutionPayloadEnvelopesByRange(
+    peerId: PeerIdStr,
+    request: gloas.ExecutionPayloadEnvelopesByRangeRequest
+  ): Promise<gloas.SignedExecutionPayloadEnvelope[]>;
+  sendExecutionPayloadEnvelopesByRoot(
+    peerId: PeerIdStr,
+    request: ExecutionPayloadEnvelopesByRootRequest
+  ): Promise<gloas.SignedExecutionPayloadEnvelope[]>;
 
   // Gossip
   publishBeaconBlock(signedBlock: SignedBeaconBlock): Promise<number>;

package/src/network/libp2p/index.ts

@@ -88,6 +88,9 @@ export async function createNodeJsLibp2p(
     );
   }
   if (networkOpts.quic) {
+    const quicMultiaddrs = localMultiaddrs.filter((ma) => ma.includes("/quic-v1"));
+    const hasIpv4Quic = quicMultiaddrs.some((ma) => ma.includes("/ip4/"));
+    const hasIpv6Quic = quicMultiaddrs.some((ma) => ma.includes("/ip6/"));
     transports.unshift(
       quic({
         handshakeTimeout: 5_000,
@@ -96,6 +99,8 @@ export async function createNodeJsLibp2p(
         maxConcurrentStreamLimit: 256,
         maxStreamData: 10_000_000,
         maxConnectionData: 15_000_000,
+        ipv4: hasIpv4Quic,
+        ipv6: hasIpv6Quic,
       })
     );
   }

package/src/network/network.ts

@@ -40,7 +40,12 @@ import {IClock} from "../util/clock.js";
 import {CustodyConfig} from "../util/dataColumns.js";
 import {PeerIdStr, peerIdToString} from "../util/peerId.js";
 import {promiseAllMaybeAsync} from "../util/promises.js";
-import {BeaconBlocksByRootRequest, BlobSidecarsByRootRequest, DataColumnSidecarsByRootRequest} from "../util/types.js";
+import {
+  BeaconBlocksByRootRequest,
+  BlobSidecarsByRootRequest,
+  DataColumnSidecarsByRootRequest,
+  ExecutionPayloadEnvelopesByRootRequest,
+} from "../util/types.js";
 import {INetworkCore, NetworkCore, WorkerNetworkCore} from "./core/index.js";
 import {INetworkEventBus, NetworkEvent, NetworkEventBus, NetworkEventData} from "./events.js";
 import {getActiveForkBoundaries} from "./forks.js";
@@ -636,6 +641,29 @@ export class Network implements INetwork {
     );
   }
 
+  async sendExecutionPayloadEnvelopesByRange(
+    peerId: PeerIdStr,
+    request: gloas.ExecutionPayloadEnvelopesByRangeRequest
+  ): Promise<gloas.SignedExecutionPayloadEnvelope[]> {
+    return collectMaxResponseTyped(
+      this.sendReqRespRequest(peerId, ReqRespMethod.ExecutionPayloadEnvelopesByRange, [Version.V1], request),
+      request.count,
+      responseSszTypeByMethod[ReqRespMethod.ExecutionPayloadEnvelopesByRange]
+    );
+  }
+
+  async sendExecutionPayloadEnvelopesByRoot(
+    peerId: PeerIdStr,
+    request: ExecutionPayloadEnvelopesByRootRequest
+  ): Promise<gloas.SignedExecutionPayloadEnvelope[]> {
+    return collectMaxResponseTyped(
+      this.sendReqRespRequest(peerId, ReqRespMethod.ExecutionPayloadEnvelopesByRoot, [Version.V1], request),
+      request.length,
+      responseSszTypeByMethod[ReqRespMethod.ExecutionPayloadEnvelopesByRoot],
+      this.chain.serializedCache
+    );
+  }
+
   private sendReqRespRequest<Req>(
     peerId: PeerIdStr,
     method: ReqRespMethod,

package/src/network/processor/gossipHandlers.ts

@@ -841,16 +841,17 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       seenTimestampSec,
     }: GossipHandlerParamGeneric<GossipType.execution_payload>) => {
       const {serializedData} = gossipData;
-      const executionPayloadEnvelope = sszDeserialize(topic, serializedData);
+      const signedEnvelope = sszDeserialize(topic, serializedData);
+      const envelope = signedEnvelope.message;
       // TODO GLOAS: handle BLOCK_ROOT_UNKNOWN error to trigger sync
-      await validateGossipExecutionPayloadEnvelope(chain, executionPayloadEnvelope);
+      await validateGossipExecutionPayloadEnvelope(chain, signedEnvelope);
 
-      const slot = executionPayloadEnvelope.message.slot;
+      const slot = envelope.slot;
       const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
       metrics?.gossipExecutionPayloadEnvelope.elapsedTimeTillReceived.observe({source: OpSource.gossip}, delaySec);
-      chain.validatorMonitor?.registerExecutionPayloadEnvelope(OpSource.gossip, delaySec, executionPayloadEnvelope);
+      chain.validatorMonitor?.registerExecutionPayloadEnvelope(OpSource.gossip, delaySec, signedEnvelope);
 
-      const blockRootHex = toRootHex(executionPayloadEnvelope.message.beaconBlockRoot);
+      const blockRootHex = toRootHex(envelope.beaconBlockRoot);
       const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
 
       if (!payloadInput) {
@@ -861,16 +862,23 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
         });
       }
 
-      chain.serializedCache.set(executionPayloadEnvelope, serializedData);
+      chain.serializedCache.set(signedEnvelope, serializedData);
 
       payloadInput.addPayloadEnvelope({
-        envelope: executionPayloadEnvelope,
+        envelope: signedEnvelope,
         source: PayloadEnvelopeInputSource.gossip,
         seenTimestampSec,
         peerIdStr,
       });
 
-      // TODO GLOAS: Emit execution_payload_gossip event for gossip receipt.
+      chain.emitter.emit(routes.events.EventType.executionPayloadGossip, {
+        slot,
+        builderIndex: envelope.builderIndex,
+        blockHash: toRootHex(envelope.payload.blockHash),
+        blockRoot: blockRootHex,
+        stateRoot: toRootHex(envelope.stateRoot),
+      });
+
       chain.processExecutionPayload(payloadInput, {validSignature: true}).catch((e) => {
         chain.logger.debug("Error processing execution payload from gossip", {slot, root: blockRootHex}, e as Error);
       });

package/src/network/reqresp/ReqRespBeaconNode.ts

@@ -297,6 +297,19 @@ export class ReqRespBeaconNode extends ReqResp {
       );
     }
 
+    if (ForkSeq[fork] >= ForkSeq.gloas) {
+      protocolsAtFork.push(
+        [
+          protocols.ExecutionPayloadEnvelopesByRoot(fork, this.config),
+          this.getHandler(ReqRespMethod.ExecutionPayloadEnvelopesByRoot),
+        ],
+        [
+          protocols.ExecutionPayloadEnvelopesByRange(fork, this.config),
+          this.getHandler(ReqRespMethod.ExecutionPayloadEnvelopesByRange),
+        ]
+      );
+    }
+
     return protocolsAtFork;
   }
 

package/src/network/reqresp/handlers/executionPayloadEnvelopesByRange.ts

@@ -0,0 +1,94 @@
+import {ChainConfig} from "@lodestar/config";
+import {PayloadStatus} from "@lodestar/fork-choice";
+import {GENESIS_SLOT} from "@lodestar/params";
+import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {gloas} from "@lodestar/types";
+import {IBeaconChain} from "../../../chain/index.js";
+import {IBeaconDb} from "../../../db/index.js";
+
+export async function* onExecutionPayloadEnvelopesByRange(
+  request: gloas.ExecutionPayloadEnvelopesByRangeRequest,
+  chain: IBeaconChain,
+  db: IBeaconDb
+): AsyncIterable<ResponseOutgoing> {
+  const {startSlot, count} = validateExecutionPayloadEnvelopesByRangeRequest(chain.config, request);
+  const endSlot = startSlot + count;
+
+  if (startSlot < chain.earliestAvailableSlot) {
+    return;
+  }
+
+  const finalized = db.executionPayloadEnvelopeArchive;
+  const finalizedSlot = chain.forkChoice.getFinalizedCheckpointSlot();
+
+  // Finalized range of envelopes
+  if (startSlot <= finalizedSlot) {
+    for await (const {key, value: envelopeBytes} of finalized.binaryEntriesStream({
+      gte: startSlot,
+      lt: endSlot,
+    })) {
+      const slot = finalized.decodeKey(key);
+      yield {
+        data: envelopeBytes,
+        boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(slot)),
+      };
+    }
+  }
+
+  // Non-finalized range of envelopes
+  if (endSlot > finalizedSlot) {
+    const headBlock = chain.forkChoice.getHead();
+    const headRoot = headBlock.blockRoot;
+    const headChain = chain.forkChoice.getAllAncestorBlocks(headRoot, headBlock.payloadStatus);
+
+    // Iterate head chain with ascending block numbers
+    for (let i = headChain.length - 1; i >= 0; i--) {
+      const block = headChain[i];
+
+      if (block.slot >= startSlot && block.slot < endSlot) {
+        // Skip EMPTY blocks
+        if (block.payloadStatus !== PayloadStatus.FULL) {
+          continue;
+        }
+
+        const envelopeBytes = await chain.getSerializedExecutionPayloadEnvelope(block.slot, block.blockRoot);
+        if (!envelopeBytes) {
+          throw new ResponseError(
+            RespStatus.SERVER_ERROR,
+            `No envelope for root ${block.blockRoot} slot ${block.slot}, startSlot=${startSlot} endSlot=${endSlot} finalizedSlot=${finalizedSlot}`
+          );
+        }
+
+        yield {
+          data: envelopeBytes,
+          boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(block.slot)),
+        };
+      } else if (block.slot >= endSlot) {
+        break;
+      }
+    }
+  }
+}
+
+export function validateExecutionPayloadEnvelopesByRangeRequest(
+  config: ChainConfig,
+  request: gloas.ExecutionPayloadEnvelopesByRangeRequest
+): gloas.ExecutionPayloadEnvelopesByRangeRequest {
+  const {startSlot} = request;
+  let {count} = request;
+
+  if (count < 1) {
+    throw new ResponseError(RespStatus.INVALID_REQUEST, "count < 1");
+  }
+  // TODO: validate against MIN_EPOCHS_FOR_BLOCK_REQUESTS
+  if (startSlot < GENESIS_SLOT) {
+    throw new ResponseError(RespStatus.INVALID_REQUEST, "startSlot < genesis");
+  }
+
+  if (count > config.MAX_REQUEST_BLOCKS_DENEB) {
+    count = config.MAX_REQUEST_BLOCKS_DENEB;
+  }
+
+  return {startSlot, count};
+}

package/src/network/reqresp/handlers/executionPayloadEnvelopesByRoot.ts

@@ -0,0 +1,43 @@
+import {ResponseOutgoing} from "@lodestar/reqresp";
+import {computeEpochAtSlot} from "@lodestar/state-transition";
+import {toRootHex} from "@lodestar/utils";
+import {IBeaconChain} from "../../../chain/index.js";
+import {IBeaconDb} from "../../../db/index.js";
+import {ExecutionPayloadEnvelopesByRootRequest} from "../../../util/types.js";
+
+export async function* onExecutionPayloadEnvelopesByRoot(
+  requestBody: ExecutionPayloadEnvelopesByRootRequest,
+  chain: IBeaconChain,
+  db: IBeaconDb
+): AsyncIterable<ResponseOutgoing> {
+  // Spec: [max(GLOAS_FORK_EPOCH, current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS), current_epoch]
+  const currentEpoch = chain.clock.currentEpoch;
+  const minimumRequestEpoch = Math.max(
+    currentEpoch - chain.config.MIN_EPOCHS_FOR_BLOCK_REQUESTS,
+    chain.config.GLOAS_FORK_EPOCH
+  );
+
+  for (const root of requestBody) {
+    const rootHex = toRootHex(root);
+    const block = chain.forkChoice.getBlockHexDefaultStatus(rootHex);
+    // If the block is not in fork choice, it may be finalized. Attempt to find its slot in block archive
+    const slot = block ? block.slot : await db.blockArchive.getSlotByRoot(root);
+
+    if (slot === null) {
+      continue;
+    }
+
+    const requestedEpoch = computeEpochAtSlot(slot);
+    if (requestedEpoch < minimumRequestEpoch) {
+      continue;
+    }
+
+    const envelopeBytes = await chain.getSerializedExecutionPayloadEnvelope(slot, rootHex);
+    if (envelopeBytes) {
+      yield {
+        data: envelopeBytes,
+        boundary: chain.config.getForkBoundaryAtEpoch(requestedEpoch),
+      };
+    }
+  }
+}

package/src/network/reqresp/handlers/index.ts

@@ -6,6 +6,7 @@ import {
   BeaconBlocksByRootRequestType,
   BlobSidecarsByRootRequestType,
   DataColumnSidecarsByRootRequestType,
+  ExecutionPayloadEnvelopesByRootRequestType,
 } from "../../../util/types.js";
 import {GetReqRespHandlerFn, ReqRespMethod} from "../types.js";
 import {onBeaconBlocksByRange} from "./beaconBlocksByRange.js";
@@ -14,6 +15,8 @@ import {onBlobSidecarsByRange} from "./blobSidecarsByRange.js";
 import {onBlobSidecarsByRoot} from "./blobSidecarsByRoot.js";
 import {onDataColumnSidecarsByRange} from "./dataColumnSidecarsByRange.js";
 import {onDataColumnSidecarsByRoot} from "./dataColumnSidecarsByRoot.js";
+import {onExecutionPayloadEnvelopesByRange} from "./executionPayloadEnvelopesByRange.js";
+import {onExecutionPayloadEnvelopesByRoot} from "./executionPayloadEnvelopesByRoot.js";
 import {onLightClientBootstrap} from "./lightClientBootstrap.js";
 import {onLightClientFinalityUpdate} from "./lightClientFinalityUpdate.js";
 import {onLightClientOptimisticUpdate} from "./lightClientOptimisticUpdate.js";
@@ -62,6 +65,15 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
       return onDataColumnSidecarsByRoot(body, chain, db, peerId, peerClient);
     },
 
+    [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: (req) => {
+      const body = ExecutionPayloadEnvelopesByRootRequestType(chain.config).deserialize(req.data);
+      return onExecutionPayloadEnvelopesByRoot(body, chain, db);
+    },
+    [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: (req) => {
+      const body = ssz.gloas.ExecutionPayloadEnvelopesByRangeRequest.deserialize(req.data);
+      return onExecutionPayloadEnvelopesByRange(body, chain, db);
+    },
+
     [ReqRespMethod.LightClientBootstrap]: (req) => {
       const body = ssz.Root.deserialize(req.data);
       return onLightClientBootstrap(body, chain);

package/src/network/reqresp/protocols.ts

@@ -94,6 +94,18 @@ export const DataColumnSidecarsByRoot = toProtocol({
   contextBytesType: ContextBytesType.ForkDigest,
 });
 
+export const ExecutionPayloadEnvelopesByRoot = toProtocol({
+  method: ReqRespMethod.ExecutionPayloadEnvelopesByRoot,
+  version: Version.V1,
+  contextBytesType: ContextBytesType.ForkDigest,
+});
+
+export const ExecutionPayloadEnvelopesByRange = toProtocol({
+  method: ReqRespMethod.ExecutionPayloadEnvelopesByRange,
+  version: Version.V1,
+  contextBytesType: ContextBytesType.ForkDigest,
+});
+
 export const LightClientBootstrap = toProtocol({
   method: ReqRespMethod.LightClientBootstrap,
   version: Version.V1,

package/src/network/reqresp/rateLimit.ts

@@ -73,6 +73,24 @@ export const rateLimitQuotas: (fork: ForkName, config: BeaconConfig) => Record<R
       req.reduce((total, item) => total + item.columns.length, 0)
     ),
   },
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: {
+    byPeer: {quota: config.MAX_REQUEST_PAYLOADS, quotaTimeMs: 10_000},
+    getRequestCount: getRequestCountFn(
+      fork,
+      config,
+      ReqRespMethod.ExecutionPayloadEnvelopesByRoot,
+      (req) => req.length
+    ),
+  },
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: {
+    byPeer: {quota: config.MAX_REQUEST_BLOCKS_DENEB, quotaTimeMs: 10_000},
+    getRequestCount: getRequestCountFn(
+      fork,
+      config,
+      ReqRespMethod.ExecutionPayloadEnvelopesByRange,
+      (req) => req.count
+    ),
+  },
   [ReqRespMethod.LightClientBootstrap]: {
     // As similar in the nature of `Status` protocol so we use the same rate limits.
     byPeer: {quota: 5, quotaTimeMs: 15_000},

package/src/network/reqresp/score.ts

@@ -46,6 +46,8 @@ export function onOutgoingReqRespError(e: RequestError, method: ReqRespMethod):
           return PeerAction.LowToleranceError;
         case ReqRespMethod.BeaconBlocksByRange:
         case ReqRespMethod.BeaconBlocksByRoot:
+        case ReqRespMethod.ExecutionPayloadEnvelopesByRoot:
+        case ReqRespMethod.ExecutionPayloadEnvelopesByRange:
           return PeerAction.MidToleranceError;
         default:
           return null;

package/src/network/reqresp/types.ts

@@ -14,6 +14,7 @@ import {
   altair,
   deneb,
   fulu,
+  gloas,
   phase0,
   ssz,
   sszTypesFor,
@@ -25,6 +26,8 @@ import {
   BlobSidecarsByRootRequestType,
   DataColumnSidecarsByRootRequest,
   DataColumnSidecarsByRootRequestType,
+  ExecutionPayloadEnvelopesByRootRequest,
+  ExecutionPayloadEnvelopesByRootRequestType,
 } from "../../util/types.js";
 
 export type ProtocolNoHandler = Omit<Protocol, "handler">;
@@ -42,6 +45,8 @@ export enum ReqRespMethod {
   BlobSidecarsByRoot = "blob_sidecars_by_root",
   DataColumnSidecarsByRange = "data_column_sidecars_by_range",
   DataColumnSidecarsByRoot = "data_column_sidecars_by_root",
+  ExecutionPayloadEnvelopesByRoot = "execution_payload_envelopes_by_root",
+  ExecutionPayloadEnvelopesByRange = "execution_payload_envelopes_by_range",
   LightClientBootstrap = "light_client_bootstrap",
   LightClientUpdatesByRange = "light_client_updates_by_range",
   LightClientFinalityUpdate = "light_client_finality_update",
@@ -60,6 +65,8 @@ export type RequestBodyByMethod = {
   [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequest;
   [ReqRespMethod.DataColumnSidecarsByRange]: fulu.DataColumnSidecarsByRangeRequest;
   [ReqRespMethod.DataColumnSidecarsByRoot]: DataColumnSidecarsByRootRequest;
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: ExecutionPayloadEnvelopesByRootRequest;
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: gloas.ExecutionPayloadEnvelopesByRangeRequest;
   [ReqRespMethod.LightClientBootstrap]: Root;
   [ReqRespMethod.LightClientUpdatesByRange]: altair.LightClientUpdatesByRange;
   [ReqRespMethod.LightClientFinalityUpdate]: null;
@@ -78,6 +85,8 @@ type ResponseBodyByMethod = {
   [ReqRespMethod.BlobSidecarsByRoot]: deneb.BlobSidecar;
   [ReqRespMethod.DataColumnSidecarsByRange]: fulu.DataColumnSidecar;
   [ReqRespMethod.DataColumnSidecarsByRoot]: fulu.DataColumnSidecar;
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: gloas.SignedExecutionPayloadEnvelope;
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: gloas.SignedExecutionPayloadEnvelope;
 
   [ReqRespMethod.LightClientBootstrap]: LightClientBootstrap;
   [ReqRespMethod.LightClientUpdatesByRange]: LightClientUpdate;
@@ -105,6 +114,8 @@ export const requestSszTypeByMethod: (
   [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequestType(fork, config),
   [ReqRespMethod.DataColumnSidecarsByRange]: ssz.fulu.DataColumnSidecarsByRangeRequest,
   [ReqRespMethod.DataColumnSidecarsByRoot]: DataColumnSidecarsByRootRequestType(config),
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: ExecutionPayloadEnvelopesByRootRequestType(config),
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: ssz.gloas.ExecutionPayloadEnvelopesByRangeRequest,
 
   [ReqRespMethod.LightClientBootstrap]: ssz.Root,
   [ReqRespMethod.LightClientUpdatesByRange]: ssz.altair.LightClientUpdatesByRange,
@@ -137,6 +148,8 @@ export const responseSszTypeByMethod: {[K in ReqRespMethod]: ResponseTypeGetter<
   [ReqRespMethod.LightClientFinalityUpdate]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientFinalityUpdate,
   [ReqRespMethod.DataColumnSidecarsByRange]: () => ssz.fulu.DataColumnSidecar,
   [ReqRespMethod.DataColumnSidecarsByRoot]: () => ssz.fulu.DataColumnSidecar,
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRoot]: () => ssz.gloas.SignedExecutionPayloadEnvelope,
+  [ReqRespMethod.ExecutionPayloadEnvelopesByRange]: () => ssz.gloas.SignedExecutionPayloadEnvelope,
   [ReqRespMethod.LightClientOptimisticUpdate]: (fork) =>
     sszTypesFor(onlyPostAltairFork(fork)).LightClientOptimisticUpdate,
 };

package/src/util/types.ts

@@ -29,3 +29,9 @@ export type BlobSidecarsByRootRequest = ValueOf<ReturnType<typeof BlobSidecarsBy
 export const DataColumnSidecarsByRootRequestType = (config: BeaconConfig) =>
   new ListCompositeType(ssz.fulu.DataColumnsByRootIdentifier, config.MAX_REQUEST_BLOCKS_DENEB);
 export type DataColumnSidecarsByRootRequest = ValueOf<ReturnType<typeof DataColumnSidecarsByRootRequestType>>;
+
+export const ExecutionPayloadEnvelopesByRootRequestType = (config: BeaconConfig) =>
+  new ListCompositeType(ssz.Root, config.MAX_REQUEST_PAYLOADS);
+export type ExecutionPayloadEnvelopesByRootRequest = ValueOf<
+  ReturnType<typeof ExecutionPayloadEnvelopesByRootRequestType>
+>;