@lodestar/builder 1.50.0-dev.033e6b7138 → 1.50.0-dev.1f129c79a1

package/src/services/bidLedger.ts

@@ -32,6 +32,7 @@ type MutableBidLedgerRecord = SubmittedBid & {
 export enum BidLedgerErrorCode {
   INVALID_BID_VALUE = "BID_LEDGER_ERROR_INVALID_BID_VALUE",
   DUPLICATE_BID = "BID_LEDGER_ERROR_DUPLICATE_BID",
+  BID_TOO_OLD = "BID_LEDGER_ERROR_BID_TOO_OLD",
   REVEAL_CONFLICT = "BID_LEDGER_ERROR_REVEAL_CONFLICT",
   UNSETTLED_VALUE_OVERFLOW = "BID_LEDGER_ERROR_UNSETTLED_VALUE_OVERFLOW",
 }
@@ -47,6 +48,11 @@ export type BidLedgerErrorType =
       parentBlockHash: RootHex;
       parentBlockRoot: RootHex;
     }
+  | {
+      code: BidLedgerErrorCode.BID_TOO_OLD;
+      slot: Slot;
+      pruneCutoffSlot: Slot;
+    }
   | {
       code: BidLedgerErrorCode.REVEAL_CONFLICT;
       blockRoot: RootHex;
@@ -69,11 +75,28 @@ const KEEP_SLOTS = RECORD_RETENTION_EPOCHS * SLOTS_PER_EPOCH;
 export class BidLedger {
   private readonly bidsBySlot = new Map<Slot, Map<string, MutableBidLedgerRecord>>();
   private readonly revealedPayloadByBlockRoot = new Map<RootHex, RevealedPayload>();
+  private pruneCutoffSlot = 0;
 
   hasSubmitted(slot: Slot, parentBlockHash: RootHex, parentBlockRoot: RootHex): boolean {
     return this.bidsBySlot.get(slot)?.has(tupleKey(parentBlockHash, parentBlockRoot)) ?? false;
   }
 
+  assertCanRecordBid({
+    slot,
+    parentBlockHash,
+    parentBlockRoot,
+  }: Pick<SubmittedBid, "slot" | "parentBlockHash" | "parentBlockRoot">): void {
+    if (slot < this.pruneCutoffSlot) {
+      throw new BidLedgerError({code: BidLedgerErrorCode.BID_TOO_OLD, slot, pruneCutoffSlot: this.pruneCutoffSlot});
+    }
+    if (this.hasSubmitted(slot, parentBlockHash, parentBlockRoot)) {
+      throw new BidLedgerError(
+        {code: BidLedgerErrorCode.DUPLICATE_BID, slot, parentBlockHash, parentBlockRoot},
+        `Bid already recorded slot=${slot} parentBlockHash=${parentBlockHash} parentBlockRoot=${parentBlockRoot}`
+      );
+    }
+  }
+
   recordBid(bid: SubmittedBid): BidLedgerRecord {
     if (!Number.isSafeInteger(bid.valueGwei) || bid.valueGwei < 0) {
       throw new BidLedgerError(
@@ -82,6 +105,7 @@ export class BidLedger {
       );
     }
 
+    this.assertCanRecordBid(bid);
     let bidsForSlot = this.bidsBySlot.get(bid.slot);
     if (bidsForSlot === undefined) {
       bidsForSlot = new Map();
@@ -89,18 +113,6 @@ export class BidLedger {
     }
 
     const key = tupleKey(bid.parentBlockHash, bid.parentBlockRoot);
-    if (bidsForSlot.has(key)) {
-      throw new BidLedgerError(
-        {
-          code: BidLedgerErrorCode.DUPLICATE_BID,
-          slot: bid.slot,
-          parentBlockHash: bid.parentBlockHash,
-          parentBlockRoot: bid.parentBlockRoot,
-        },
-        `Bid already recorded slot=${bid.slot} parentBlockHash=${bid.parentBlockHash} parentBlockRoot=${bid.parentBlockRoot}`
-      );
-    }
-
     const record = {...bid, wonBlockRoots: new Set<RootHex>(), paymentSettled: false};
     bidsForSlot.set(key, record);
     return toRecord(record);
@@ -198,9 +210,11 @@ export class BidLedger {
   }
 
   prune(currentSlot: Slot): number {
+    // Pruning must not make an expired slot eligible for another submission.
+    this.pruneCutoffSlot = Math.max(this.pruneCutoffSlot, currentSlot - KEEP_SLOTS);
     let removed = 0;
     for (const [slot, bidsForSlot] of this.bidsBySlot) {
-      if (slot >= currentSlot - KEEP_SLOTS) {
+      if (slot >= this.pruneCutoffSlot) {
         continue;
       }
 
@@ -216,7 +230,7 @@ export class BidLedger {
     }
 
     for (const [blockRoot, revealedPayload] of this.revealedPayloadByBlockRoot) {
-      if (revealedPayload.slot < currentSlot - KEEP_SLOTS) {
+      if (revealedPayload.slot < this.pruneCutoffSlot) {
         this.revealedPayloadByBlockRoot.delete(blockRoot);
       }
     }

package/src/services/bidPublisher.ts

@@ -0,0 +1,95 @@
+import type {ApiClient} from "@lodestar/api";
+import type {ChainForkConfig} from "@lodestar/config";
+import {isForkPostGloas} from "@lodestar/params";
+import type {BuilderIndex, RootHex, Slot, gloas, heze} from "@lodestar/types";
+import {sszTypesFor} from "@lodestar/types";
+import {LodestarError, toRootHex} from "@lodestar/utils";
+import type {BidIdentity, BidLedger} from "./bidLedger.js";
+import type {BuilderSigner} from "./builderSigner.js";
+
+export type BidPublisherModules = {
+  api: ApiClient;
+  config: ChainForkConfig;
+  signer: BuilderSigner;
+  ledger: BidLedger;
+  builderIndex: BuilderIndex;
+  hasPayload: (identity: BidIdentity) => boolean;
+};
+
+export enum BidPublisherErrorCode {
+  BUILDER_INDEX_MISMATCH = "BID_PUBLISHER_ERROR_BUILDER_INDEX_MISMATCH",
+  PAYLOAD_NOT_RETAINED = "BID_PUBLISHER_ERROR_PAYLOAD_NOT_RETAINED",
+  PRE_GLOAS_BID = "BID_PUBLISHER_ERROR_PRE_GLOAS_BID",
+}
+
+export type BidPublisherErrorType =
+  | {
+      code: BidPublisherErrorCode.PRE_GLOAS_BID;
+      slot: Slot;
+    }
+  | {
+      code: BidPublisherErrorCode.BUILDER_INDEX_MISMATCH;
+      builderIndex: BuilderIndex;
+      bidBuilderIndex: BuilderIndex;
+    }
+  | {
+      code: BidPublisherErrorCode.PAYLOAD_NOT_RETAINED;
+      slot: Slot;
+      parentBlockHash: RootHex;
+      parentBlockRoot: RootHex;
+      blockHash: RootHex;
+    };
+
+export class BidPublisherError extends LodestarError<BidPublisherErrorType> {}
+
+/** Signs and submits a bid only if its payload is retained locally. */
+export class BidPublisher {
+  constructor(private readonly modules: BidPublisherModules) {}
+
+  publish(bid: heze.ExecutionPayloadBid, signal: AbortSignal): Promise<heze.SignedExecutionPayloadBid>;
+  publish(bid: gloas.ExecutionPayloadBid, signal: AbortSignal): Promise<gloas.SignedExecutionPayloadBid>;
+  async publish(bid: gloas.ExecutionPayloadBid, signal: AbortSignal): Promise<gloas.SignedExecutionPayloadBid> {
+    signal.throwIfAborted();
+
+    const {api, config, builderIndex, hasPayload, ledger, signer} = this.modules;
+    const fork = config.getForkName(bid.slot);
+    if (!isForkPostGloas(fork)) {
+      throw new BidPublisherError({code: BidPublisherErrorCode.PRE_GLOAS_BID, slot: bid.slot});
+    }
+    if (bid.builderIndex !== builderIndex) {
+      throw new BidPublisherError(
+        {
+          code: BidPublisherErrorCode.BUILDER_INDEX_MISMATCH,
+          builderIndex,
+          bidBuilderIndex: bid.builderIndex,
+        },
+        `Bid builder index does not match local builder index builderIndex=${builderIndex} bidBuilderIndex=${bid.builderIndex}`
+      );
+    }
+
+    const identity: BidIdentity = {
+      slot: bid.slot,
+      parentBlockHash: toRootHex(bid.parentBlockHash),
+      parentBlockRoot: toRootHex(bid.parentBlockRoot),
+      blockHash: toRootHex(bid.blockHash),
+    };
+    if (!hasPayload(identity)) {
+      throw new BidPublisherError(
+        {code: BidPublisherErrorCode.PAYLOAD_NOT_RETAINED, ...identity},
+        `Bid payload is not retained slot=${identity.slot} parentBlockHash=${identity.parentBlockHash} parentBlockRoot=${identity.parentBlockRoot} blockHash=${identity.blockHash}`
+      );
+    }
+
+    ledger.assertCanRecordBid(identity);
+
+    const signedExecutionPayloadBid = signer.signExecutionPayloadBid(bid);
+    const signedBidRoot = toRootHex(
+      sszTypesFor(fork, "SignedExecutionPayloadBid").hashTreeRoot(signedExecutionPayloadBid)
+    );
+    ledger.recordBid({...identity, valueGwei: bid.value, signedBidRoot});
+
+    const response = await api.beacon.publishExecutionPayloadBid({signedExecutionPayloadBid}, {signal});
+    response.assertOk();
+    return signedExecutionPayloadBid;
+  }
+}

package/src/services/bidSelector.ts

@@ -0,0 +1,138 @@
+import type {ChainForkConfig} from "@lodestar/config";
+import type {ForkPostGloas} from "@lodestar/params";
+import type {BuilderIndex, RootHex, SignedBeaconBlock, Slot} from "@lodestar/types";
+import {sszTypesFor} from "@lodestar/types";
+import {LodestarError, toRootHex} from "@lodestar/utils";
+import type {BidIdentity, BidLedger, BidLedgerRecord} from "./bidLedger.js";
+
+export type ObservedPostGloasBlock = {
+  blockRoot: RootHex;
+  slot: Slot;
+  version: ForkPostGloas;
+  block: SignedBeaconBlock<ForkPostGloas>;
+};
+
+export type BidSelectorModules = {
+  config: ChainForkConfig;
+  ledger: BidLedger;
+  builderIndex: BuilderIndex;
+};
+
+export enum BidSelectionIgnoreReason {
+  FOREIGN_BUILDER = "foreign_builder",
+}
+
+export type BidSelectionResult =
+  | {
+      status: "selected";
+      blockRoot: RootHex;
+      bid: BidLedgerRecord;
+    }
+  | {
+      status: "ignored";
+      reason: BidSelectionIgnoreReason;
+    };
+
+export enum BidSelectorErrorCode {
+  BLOCK_ROOT_MISMATCH = "BID_SELECTOR_ERROR_BLOCK_ROOT_MISMATCH",
+  BLOCK_SLOT_MISMATCH = "BID_SELECTOR_ERROR_BLOCK_SLOT_MISMATCH",
+  BLOCK_FORK_MISMATCH = "BID_SELECTOR_ERROR_BLOCK_FORK_MISMATCH",
+  BID_SLOT_MISMATCH = "BID_SELECTOR_ERROR_BID_SLOT_MISMATCH",
+  UNKNOWN_BID = "BID_SELECTOR_ERROR_UNKNOWN_BID",
+}
+
+export type BidSelectorErrorType =
+  | {
+      code: BidSelectorErrorCode.BLOCK_ROOT_MISMATCH;
+      blockRoot: RootHex;
+      computedBlockRoot: RootHex;
+    }
+  | {
+      code: BidSelectorErrorCode.BLOCK_SLOT_MISMATCH;
+      slot: Slot;
+      blockSlot: Slot;
+    }
+  | {
+      code: BidSelectorErrorCode.BLOCK_FORK_MISMATCH;
+      version: ForkPostGloas;
+      blockFork: string;
+    }
+  | {
+      code: BidSelectorErrorCode.BID_SLOT_MISMATCH;
+      slot: Slot;
+      bidSlot: Slot;
+    }
+  | {
+      code: BidSelectorErrorCode.UNKNOWN_BID;
+      slot: Slot;
+      parentBlockHash: RootHex;
+      parentBlockRoot: RootHex;
+      blockHash: RootHex;
+      signedBidRoot: RootHex;
+    };
+
+export class BidSelectorError extends LodestarError<BidSelectorErrorType> {}
+
+/** Matches an imported post-Gloas block to an exact local bid and records the win. */
+export class BidSelector {
+  constructor(private readonly modules: BidSelectorModules) {}
+
+  match(observed: ObservedPostGloasBlock): BidSelectionResult {
+    const {block, blockRoot, slot, version} = observed;
+    const {builderIndex, config, ledger} = this.modules;
+    const blockSlot = block.message.slot;
+
+    if (blockSlot !== slot) {
+      throw new BidSelectorError(
+        {code: BidSelectorErrorCode.BLOCK_SLOT_MISMATCH, slot, blockSlot},
+        `Observed block slot does not match fetched block slot=${slot} blockSlot=${blockSlot}`
+      );
+    }
+
+    const blockFork = config.getForkName(slot);
+    if (blockFork !== version) {
+      throw new BidSelectorError(
+        {code: BidSelectorErrorCode.BLOCK_FORK_MISMATCH, version, blockFork},
+        `Observed block fork does not match configured fork version=${version} blockFork=${blockFork}`
+      );
+    }
+
+    const computedBlockRoot = toRootHex(config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block.message));
+    if (computedBlockRoot !== blockRoot) {
+      throw new BidSelectorError(
+        {code: BidSelectorErrorCode.BLOCK_ROOT_MISMATCH, blockRoot, computedBlockRoot},
+        `Observed block root does not match fetched block blockRoot=${blockRoot} computedBlockRoot=${computedBlockRoot}`
+      );
+    }
+
+    const bid = block.message.body.signedExecutionPayloadBid.message;
+    if (bid.slot !== slot) {
+      throw new BidSelectorError(
+        {code: BidSelectorErrorCode.BID_SLOT_MISMATCH, slot, bidSlot: bid.slot},
+        `Selected bid slot does not match block slot=${slot} bidSlot=${bid.slot}`
+      );
+    }
+    if (bid.builderIndex !== builderIndex) {
+      return {status: "ignored", reason: BidSelectionIgnoreReason.FOREIGN_BUILDER};
+    }
+
+    const identity: BidIdentity = {
+      slot,
+      parentBlockHash: toRootHex(bid.parentBlockHash),
+      parentBlockRoot: toRootHex(bid.parentBlockRoot),
+      blockHash: toRootHex(bid.blockHash),
+    };
+    const signedBidRoot = toRootHex(
+      sszTypesFor(version, "SignedExecutionPayloadBid").hashTreeRoot(block.message.body.signedExecutionPayloadBid)
+    );
+    const localBid = ledger.recordWin({...identity, signedBidRoot}, blockRoot);
+    if (localBid === null) {
+      throw new BidSelectorError(
+        {code: BidSelectorErrorCode.UNKNOWN_BID, ...identity, signedBidRoot},
+        `Selected bid is not in the local ledger slot=${slot} blockHash=${identity.blockHash} signedBidRoot=${signedBidRoot}`
+      );
+    }
+
+    return {status: "selected", blockRoot, bid: localBid};
+  }
+}

package/src/services/blockObserver.ts

@@ -47,55 +47,17 @@ export class BlockObserver {
     this.retries = retries;
     this.retryDelay = retryDelay;
     this.maxSeenBlockRoots = maxSeenBlockRoots;
+    this.logger.info("Block observer initialized", {retries, retryDelay, maxSeenBlockRoots});
   }
 
   /**
-   * Register a block consumer. Consumers that require complete observation must register before {@link start}, because
+   * Register a block consumer. Consumers that require complete observation must register before event delivery, because
    * roots observed before registration remain consumed until normal FIFO eviction.
    */
   runOnBlock(fn: RunOnBlockFn): void {
     this.fns.push(fn);
   }
 
-  start(signal: AbortSignal): void {
-    this.logger.info("Subscribing to block events", {
-      retries: this.retries,
-      retryDelay: this.retryDelay,
-      maxSeenBlockRoots: this.maxSeenBlockRoots,
-    });
-
-    this.api.events
-      .eventstream({
-        topics: [EventType.block],
-        signal,
-        onEvent: (event) => {
-          if (event.type !== EventType.block) {
-            this.logger.debug("Ignoring unexpected beacon event", {eventType: event.type});
-            return;
-          }
-
-          void this.processBlockEvent(event.message, signal);
-        },
-        onError: (error) => {
-          this.logger.error("Failed to receive block event", {}, error);
-        },
-        onClose: () => {
-          if (signal.aborted) {
-            this.logger.debug("Closed stream for block events");
-          } else {
-            this.logger.error("Block event stream closed unexpectedly", {});
-          }
-        },
-      })
-      .catch((error: unknown) => {
-        this.logger.error(
-          "Failed to subscribe to block events",
-          {},
-          error instanceof Error ? error : Error(String(error))
-        );
-      });
-  }
-
   async processBlockEvent(event: BlockEvent, signal: AbortSignal): Promise<void> {
     try {
       const {slot, block: blockRoot, executionOptimistic} = event;
@@ -145,7 +107,7 @@ export class BlockObserver {
         return null;
       });
 
-      if (response === null) {
+      if (response === null || signal.aborted) {
         return;
       }
 

package/src/services/builderSigner.ts

@@ -1,7 +1,7 @@
 import {PublicKey, SecretKey} from "@chainsafe/lodestar-z/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {getExecutionPayloadBidSigningRoot, getExecutionPayloadEnvelopeSigningRoot} from "@lodestar/state-transition";
-import {gloas} from "@lodestar/types";
+import {gloas, heze} from "@lodestar/types";
 
 export type Keypair = {publicKey: PublicKey; secretKey: SecretKey};
 
@@ -23,6 +23,8 @@ export class BuilderSigner {
     };
   }
 
+  signExecutionPayloadBid(bid: heze.ExecutionPayloadBid): heze.SignedExecutionPayloadBid;
+  signExecutionPayloadBid(bid: gloas.ExecutionPayloadBid): gloas.SignedExecutionPayloadBid;
   signExecutionPayloadBid(bid: gloas.ExecutionPayloadBid): gloas.SignedExecutionPayloadBid {
     const signingRoot = getExecutionPayloadBidSigningRoot(this.config, bid);
 

package/src/services/executionPayloadBid.ts

@@ -0,0 +1,125 @@
+import {ForkName, type ForkPostGloas, INCLUSION_LIST_COMMITTEE_SIZE, isForkPostHeze} from "@lodestar/params";
+import type {
+  BuilderIndex,
+  Bytes32,
+  ExecutionAddress,
+  ExecutionPayloadBid,
+  Root,
+  RootHex,
+  Slot,
+  gloas,
+  heze,
+} from "@lodestar/types";
+import {sszTypesFor} from "@lodestar/types";
+import {LodestarError, byteArrayEquals, toRootHex} from "@lodestar/utils";
+import type {BuiltPayload} from "./payloadSource.js";
+
+type CommonBidInput<F extends ForkPostGloas> = {
+  slot: Slot;
+  parentBlockRoot: Root;
+  /** Expected value from the BN payload attributes used for this build. */
+  prevRandao: Bytes32;
+  builderIndex: BuilderIndex;
+  feeRecipient: ExecutionAddress;
+  /** Bid value in gwei */
+  value: number;
+  payload: BuiltPayload & {fork: F};
+};
+
+export type GloasBidInput = CommonBidInput<ForkName.gloas>;
+
+export type HezeBidInput = CommonBidInput<ForkName.heze> & {
+  inclusionListBits: heze.ExecutionPayloadBid["inclusionListBits"];
+};
+
+export type ExecutionPayloadBidInput = GloasBidInput | HezeBidInput;
+
+export enum ExecutionPayloadBidErrorCode {
+  INVALID_VALUE = "EXECUTION_PAYLOAD_BID_ERROR_INVALID_VALUE",
+  INVALID_GAS_LIMIT = "EXECUTION_PAYLOAD_BID_ERROR_INVALID_GAS_LIMIT",
+  SLOT_MISMATCH = "EXECUTION_PAYLOAD_BID_ERROR_SLOT_MISMATCH",
+  BLOCK_HASH_EQUALS_PARENT = "EXECUTION_PAYLOAD_BID_ERROR_BLOCK_HASH_EQUALS_PARENT",
+  INVALID_INCLUSION_LIST_BITS = "EXECUTION_PAYLOAD_BID_ERROR_INVALID_INCLUSION_LIST_BITS",
+  PREV_RANDAO_MISMATCH = "EXECUTION_PAYLOAD_BID_ERROR_PREV_RANDAO_MISMATCH",
+}
+
+export type ExecutionPayloadBidErrorType =
+  | {code: ExecutionPayloadBidErrorCode.INVALID_GAS_LIMIT; gasLimit: number}
+  | {code: ExecutionPayloadBidErrorCode.SLOT_MISMATCH; slot: Slot; payloadSlot: Slot}
+  | {code: ExecutionPayloadBidErrorCode.BLOCK_HASH_EQUALS_PARENT}
+  | {code: ExecutionPayloadBidErrorCode.INVALID_INCLUSION_LIST_BITS; bitLen: number | undefined}
+  | {
+      code: ExecutionPayloadBidErrorCode.PREV_RANDAO_MISMATCH;
+      expectedPrevRandao: RootHex;
+      payloadPrevRandao: RootHex;
+    }
+  | {
+      code: ExecutionPayloadBidErrorCode.INVALID_VALUE;
+      value: number;
+    };
+
+export class ExecutionPayloadBidError extends LodestarError<ExecutionPayloadBidErrorType> {}
+
+export function createExecutionPayloadBid(input: GloasBidInput): gloas.ExecutionPayloadBid;
+export function createExecutionPayloadBid(input: HezeBidInput): heze.ExecutionPayloadBid;
+export function createExecutionPayloadBid(input: ExecutionPayloadBidInput): ExecutionPayloadBid;
+export function createExecutionPayloadBid(input: ExecutionPayloadBidInput): ExecutionPayloadBid {
+  if (!Number.isSafeInteger(input.value) || input.value < 0) {
+    throw new ExecutionPayloadBidError(
+      {code: ExecutionPayloadBidErrorCode.INVALID_VALUE, value: input.value},
+      `Invalid bid value value=${input.value}`
+    );
+  }
+
+  const {fork, executionPayload, executionRequests, blobsBundle} = input.payload;
+  if (executionPayload.gasLimit > Number.MAX_SAFE_INTEGER) {
+    throw new ExecutionPayloadBidError({
+      code: ExecutionPayloadBidErrorCode.INVALID_GAS_LIMIT,
+      gasLimit: executionPayload.gasLimit,
+    });
+  }
+  if (executionPayload.slotNumber !== input.slot) {
+    throw new ExecutionPayloadBidError({
+      code: ExecutionPayloadBidErrorCode.SLOT_MISMATCH,
+      slot: input.slot,
+      payloadSlot: executionPayload.slotNumber,
+    });
+  }
+  if (byteArrayEquals(executionPayload.blockHash, executionPayload.parentHash)) {
+    throw new ExecutionPayloadBidError({code: ExecutionPayloadBidErrorCode.BLOCK_HASH_EQUALS_PARENT});
+  }
+  if (!byteArrayEquals(executionPayload.prevRandao, input.prevRandao)) {
+    throw new ExecutionPayloadBidError({
+      code: ExecutionPayloadBidErrorCode.PREV_RANDAO_MISMATCH,
+      expectedPrevRandao: toRootHex(input.prevRandao),
+      payloadPrevRandao: toRootHex(executionPayload.prevRandao),
+    });
+  }
+  const bid: gloas.ExecutionPayloadBid = {
+    parentBlockHash: executionPayload.parentHash,
+    parentBlockRoot: input.parentBlockRoot,
+    blockHash: executionPayload.blockHash,
+    prevRandao: input.prevRandao,
+    feeRecipient: input.feeRecipient,
+    gasLimit: BigInt(executionPayload.gasLimit),
+    builderIndex: input.builderIndex,
+    slot: input.slot,
+    value: input.value,
+    executionPayment: 0n,
+    blobKzgCommitments: blobsBundle.commitments,
+    executionRequestsRoot: sszTypesFor(fork).ExecutionRequests.hashTreeRoot(executionRequests),
+  };
+
+  if (isForkPostHeze(fork)) {
+    const inclusionListBits = "inclusionListBits" in input ? input.inclusionListBits : undefined;
+    if (inclusionListBits?.bitLen !== INCLUSION_LIST_COMMITTEE_SIZE) {
+      throw new ExecutionPayloadBidError({
+        code: ExecutionPayloadBidErrorCode.INVALID_INCLUSION_LIST_BITS,
+        bitLen: inclusionListBits?.bitLen,
+      });
+    }
+    return {...bid, inclusionListBits};
+  }
+
+  return bid;
+}

package/src/services/executionPayloadEnvelope.ts

@@ -0,0 +1,156 @@
+import type {BuilderIndex, RootHex, Slot, deneb, gloas} from "@lodestar/types";
+import {ssz} from "@lodestar/types";
+import {LodestarError, byteArrayEquals, fromHex, toRootHex} from "@lodestar/utils";
+import type {StoredPayload} from "./payloadStore.js";
+
+export type ExecutionPayloadEnvelopeInput = {
+  blockRoot: RootHex;
+  builderIndex: BuilderIndex;
+  selectedBid: gloas.ExecutionPayloadBid;
+  storedPayload: StoredPayload;
+};
+
+export type ExecutionPayloadEnvelopeContents = {
+  envelope: gloas.ExecutionPayloadEnvelope;
+  kzgProofs: deneb.KZGProofs;
+  blobs: deneb.Blobs;
+};
+
+export enum ExecutionPayloadEnvelopeErrorCode {
+  SLOT_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_SLOT_MISMATCH",
+  PARENT_BLOCK_ROOT_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_PARENT_BLOCK_ROOT_MISMATCH",
+  PARENT_BLOCK_HASH_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_PARENT_BLOCK_HASH_MISMATCH",
+  BLOCK_HASH_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BLOCK_HASH_MISMATCH",
+  BUILDER_INDEX_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BUILDER_INDEX_MISMATCH",
+  BLOB_KZG_COMMITMENTS_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_BLOB_KZG_COMMITMENTS_MISMATCH",
+  EXECUTION_REQUESTS_ROOT_MISMATCH = "EXECUTION_PAYLOAD_ENVELOPE_ERROR_EXECUTION_REQUESTS_ROOT_MISMATCH",
+}
+
+export type ExecutionPayloadEnvelopeErrorType =
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.BUILDER_INDEX_MISMATCH;
+      builderIndex: BuilderIndex;
+      bidBuilderIndex: BuilderIndex;
+    }
+  | {code: ExecutionPayloadEnvelopeErrorCode.BLOB_KZG_COMMITMENTS_MISMATCH}
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.EXECUTION_REQUESTS_ROOT_MISMATCH;
+      bidExecutionRequestsRoot: RootHex;
+      payloadExecutionRequestsRoot: RootHex;
+    }
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.PARENT_BLOCK_ROOT_MISMATCH;
+      bidParentBlockRoot: RootHex;
+      storedParentBlockRoot: RootHex;
+    }
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.SLOT_MISMATCH;
+      bidSlot: Slot;
+      payloadSlot: Slot;
+    }
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.PARENT_BLOCK_HASH_MISMATCH;
+      bidParentBlockHash: RootHex;
+      payloadParentBlockHash: RootHex;
+    }
+  | {
+      code: ExecutionPayloadEnvelopeErrorCode.BLOCK_HASH_MISMATCH;
+      bidBlockHash: RootHex;
+      payloadBlockHash: RootHex;
+    };
+
+export class ExecutionPayloadEnvelopeError extends LodestarError<ExecutionPayloadEnvelopeErrorType> {}
+
+/** The caller must have matched the selected bid to its local ledger record. */
+export function createExecutionPayloadEnvelopeContents({
+  blockRoot,
+  builderIndex,
+  selectedBid,
+  storedPayload,
+}: ExecutionPayloadEnvelopeInput): ExecutionPayloadEnvelopeContents {
+  if (builderIndex !== selectedBid.builderIndex) {
+    throw new ExecutionPayloadEnvelopeError({
+      code: ExecutionPayloadEnvelopeErrorCode.BUILDER_INDEX_MISMATCH,
+      builderIndex,
+      bidBuilderIndex: selectedBid.builderIndex,
+    });
+  }
+
+  const bidParentBlockRoot = toRootHex(selectedBid.parentBlockRoot);
+  const storedParentBlockRoot = toRootHex(storedPayload.parentBlockRoot);
+  if (storedParentBlockRoot !== bidParentBlockRoot) {
+    throw new ExecutionPayloadEnvelopeError(
+      {
+        code: ExecutionPayloadEnvelopeErrorCode.PARENT_BLOCK_ROOT_MISMATCH,
+        bidParentBlockRoot,
+        storedParentBlockRoot,
+      },
+      `Selected bid beacon parent does not match retained payload bidParentBlockRoot=${bidParentBlockRoot} storedParentBlockRoot=${storedParentBlockRoot}`
+    );
+  }
+
+  const {payload} = storedPayload;
+  const payloadSlot = payload.executionPayload.slotNumber;
+  if (payloadSlot !== selectedBid.slot) {
+    throw new ExecutionPayloadEnvelopeError(
+      {code: ExecutionPayloadEnvelopeErrorCode.SLOT_MISMATCH, bidSlot: selectedBid.slot, payloadSlot},
+      `Selected bid slot does not match payload slot bidSlot=${selectedBid.slot} payloadSlot=${payloadSlot}`
+    );
+  }
+
+  const payloadParentBlockHash = toRootHex(payload.executionPayload.parentHash);
+  const bidParentBlockHash = toRootHex(selectedBid.parentBlockHash);
+  if (payloadParentBlockHash !== bidParentBlockHash) {
+    throw new ExecutionPayloadEnvelopeError(
+      {
+        code: ExecutionPayloadEnvelopeErrorCode.PARENT_BLOCK_HASH_MISMATCH,
+        bidParentBlockHash,
+        payloadParentBlockHash,
+      },
+      `Selected bid parent does not match payload parent bidParentBlockHash=${bidParentBlockHash} payloadParentBlockHash=${payloadParentBlockHash}`
+    );
+  }
+
+  const payloadBlockHash = toRootHex(payload.executionPayload.blockHash);
+  const bidBlockHash = toRootHex(selectedBid.blockHash);
+  if (payloadBlockHash !== bidBlockHash) {
+    throw new ExecutionPayloadEnvelopeError(
+      {
+        code: ExecutionPayloadEnvelopeErrorCode.BLOCK_HASH_MISMATCH,
+        bidBlockHash,
+        payloadBlockHash,
+      },
+      `Selected bid block hash does not match payload bidBlockHash=${bidBlockHash} payloadBlockHash=${payloadBlockHash}`
+    );
+  }
+
+  if (
+    !ssz.gloas.ExecutionPayloadBid.fields.blobKzgCommitments.equals(
+      selectedBid.blobKzgCommitments,
+      payload.blobsBundle.commitments
+    )
+  ) {
+    throw new ExecutionPayloadEnvelopeError({code: ExecutionPayloadEnvelopeErrorCode.BLOB_KZG_COMMITMENTS_MISMATCH});
+  }
+
+  const executionRequestsRoot = ssz.gloas.ExecutionRequests.hashTreeRoot(payload.executionRequests);
+  if (!byteArrayEquals(executionRequestsRoot, selectedBid.executionRequestsRoot)) {
+    throw new ExecutionPayloadEnvelopeError({
+      code: ExecutionPayloadEnvelopeErrorCode.EXECUTION_REQUESTS_ROOT_MISMATCH,
+      bidExecutionRequestsRoot: toRootHex(selectedBid.executionRequestsRoot),
+      payloadExecutionRequestsRoot: toRootHex(executionRequestsRoot),
+    });
+  }
+
+  return {
+    envelope: {
+      payload: payload.executionPayload,
+      executionRequests: payload.executionRequests,
+      builderIndex,
+      beaconBlockRoot: fromHex(blockRoot),
+      parentBeaconBlockRoot: selectedBid.parentBlockRoot,
+    },
+    kzgProofs: payload.blobsBundle.proofs,
+    blobs: payload.blobsBundle.blobs,
+  };
+}