@lodestar/builder 1.50.0-dev.f2d839a25c → 1.50.0-dev.f2fb26d453

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,
+  };
+}

package/src/services/proposerPreferencesTracker.ts

@@ -1,6 +1,5 @@
-import {ApiClient, routes} from "@lodestar/api";
 import type {RootHex, Slot, gloas} from "@lodestar/types";
-import {Logger, MapDef, toRootHex} from "@lodestar/utils";
+import {MapDef, toRootHex} from "@lodestar/utils";
 
 /** Retains validated proposer preferences by the branch-specific identity used for bid validation. */
 export class ProposerPreferencesTracker {
@@ -8,40 +7,6 @@ export class ProposerPreferencesTracker {
     () => new Map()
   );
 
-  constructor(
-    private readonly api: ApiClient,
-    private readonly logger: Logger
-  ) {}
-
-  start(signal: AbortSignal): void {
-    if (signal.aborted) return;
-
-    this.logger.verbose("Subscribing to proposer preferences");
-    this.api.events
-      .eventstream({
-        topics: [routes.events.EventType.proposerPreferences],
-        signal,
-        onEvent: (event) => {
-          if (!signal.aborted && event.type === routes.events.EventType.proposerPreferences) {
-            this.onProposerPreferences(event.message.data);
-          }
-        },
-        onError: (error) => {
-          if (!signal.aborted) this.logger.error("Failed to receive proposer preferences", {}, error);
-        },
-        onClose: () => {
-          if (signal.aborted) {
-            this.logger.verbose("Closed proposer preferences stream");
-          } else {
-            this.logger.error("Proposer preferences stream closed unexpectedly", {});
-          }
-        },
-      })
-      .catch((error: Error) => {
-        if (!signal.aborted) this.logger.error("Failed to subscribe to proposer preferences", {}, error);
-      });
-  }
-
   onProposerPreferences(signedProposerPreferences: gloas.SignedProposerPreferences): boolean {
     const {proposalSlot, dependentRoot} = signedProposerPreferences.message;
     const dependentRootHex = toRootHex(dependentRoot);