@lodestar/beacon-node 1.48.0-dev.e9c9b8835d → 1.48.0-dev.fd70e5fc15

package/src/chain/blocks/writeBlockInputToDb.ts

@@ -1,6 +1,6 @@
-import {ForkPostDeneb, ForkPostFulu, isForkPostDeneb} from "@lodestar/params";
+import {ForkPostDeneb, isForkPostDeneb} from "@lodestar/params";
 import {SignedBeaconBlock} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
+import {fromHex, toRootHex} from "@lodestar/utils";
 import {getBlobKzgCommitments} from "../../util/dataColumns.js";
 import {BeaconChain} from "../chain.js";
 import {IBlockInput, IDataColumnsInput, isBlockInputBlobs, isBlockInputColumns} from "./blockInput/index.js";
@@ -76,6 +76,7 @@ async function writeBlockAndBlobsToDb(this: BeaconChain, blockInput: IBlockInput
  */
 export async function writeDataColumnsToDb(this: BeaconChain, blockInput: IDataColumnsInput): Promise<void> {
   const {slot, blockRootHex} = blockInput;
+  const blockRoot = fromHex(blockRootHex);
 
   if (!blockInput.hasComputedAllData()) {
     // Supernodes may only have a subset of the data columns by the time the block begins to be imported
@@ -88,19 +89,25 @@ export async function writeDataColumnsToDb(this: BeaconChain, blockInput: IDataC
 
   const {custodyColumns} = this.custodyConfig;
   const dataColumnSidecars = blockInput.getCustodyColumns();
-  const dataColumnSidecarType = this.config.getForkTypes<ForkPostFulu>(slot).DataColumnSidecar;
 
-  const binaryColumns: {index: number; data: Uint8Array}[] = [];
+  const binaryPuts: {key: number; value: Uint8Array}[] = [];
+  const nonbinaryPuts = [];
   for (const dataColumnSidecar of dataColumnSidecars) {
+    // skip reserializing column if we already have it
     const serialized = this.serializedCache.get(dataColumnSidecar);
-    binaryColumns.push({
-      index: dataColumnSidecar.index,
-      data: serialized ?? dataColumnSidecarType.serialize(dataColumnSidecar),
-    });
+    if (serialized) {
+      binaryPuts.push({key: dataColumnSidecar.index, value: serialized});
+    } else {
+      nonbinaryPuts.push(dataColumnSidecar);
+    }
   }
-  await this.db.dataColumns.putManyBinary({slot, blockRoot: blockRootHex}, binaryColumns);
 
-  this.logger.debug("Persisted dataColumnSidecars", {
+  await Promise.all([
+    this.db.dataColumnSidecar.putManyBinary(blockRoot, binaryPuts),
+    this.db.dataColumnSidecar.putMany(blockRoot, nonbinaryPuts),
+  ]);
+
+  this.logger.debug("Persisted dataColumnSidecars to hot DB", {
     slot,
     root: blockRootHex,
     dataColumnSidecars: dataColumnSidecars.length,

package/src/chain/chain.ts

@@ -268,7 +268,6 @@ export class BeaconChain implements IBeaconChain {
       db,
       dbName,
       dataDir,
-      dataColumnDir,
       logger,
       processShutdownCallback,
       clock,
@@ -286,7 +285,6 @@ export class BeaconChain implements IBeaconChain {
       db: IBeaconDb;
       dbName: string;
       dataDir: string;
-      dataColumnDir?: string;
       logger: Logger;
       processShutdownCallback: ProcessShutdownCallback;
       /** Used for testing to supply fake clock */
@@ -507,12 +505,7 @@ export class BeaconChain implements IBeaconChain {
 
     this.archiveStore = new ArchiveStore(
       {db, chain: this, logger: logger as LoggerNode, metrics},
-      {
-        ...opts,
-        dbName,
-        dataColumnDir: dataColumnDir ?? path.join(dataDir, "data_columns"),
-        anchorState: {finalizedCheckpoint: anchorState.finalizedCheckpoint},
-      },
+      {...opts, dbName, anchorState: {finalizedCheckpoint: anchorState.finalizedCheckpoint}},
       signal
     );
 
@@ -976,15 +969,12 @@ export class BeaconChain implements IBeaconChain {
 
   async getDataColumnSidecars(blockSlot: Slot, blockRootHex: string): Promise<DataColumnSidecar[]> {
     const fork = this.config.getForkName(blockSlot);
-    const sidecarsByIndex = new Map<number, DataColumnSidecar>();
 
     if (isForkPostGloas(fork)) {
       // After gloas, columns are tracked in PayloadEnvelopeInput
       const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
       if (payloadInput) {
-        for (const sidecar of payloadInput.getAllColumns()) {
-          sidecarsByIndex.set(sidecar.index, sidecar);
-        }
+        return payloadInput.getAllColumns();
       }
     } else {
       // Before gloas, columns are tracked in BlockInput
@@ -993,17 +983,16 @@ export class BeaconChain implements IBeaconChain {
         if (!isBlockInputColumns(blockInput)) {
           throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
         }
-        for (const sidecar of blockInput.getAllColumns()) {
-          sidecarsByIndex.set(sidecar.index, sidecar);
-        }
+        return blockInput.getAllColumns();
       }
     }
 
-    for (const sidecar of await this.db.dataColumns.getAll({slot: blockSlot, blockRoot: blockRootHex})) {
-      if (!sidecarsByIndex.has(sidecar.index)) sidecarsByIndex.set(sidecar.index, sidecar);
+    const sidecarsUnfinalized = await this.db.dataColumnSidecar.values(fromHex(blockRootHex));
+    if (sidecarsUnfinalized.length > 0) {
+      return sidecarsUnfinalized;
     }
-
-    return [...sidecarsByIndex.values()].sort((a, b) => a.index - b.index);
+    const sidecarsFinalized = await this.db.dataColumnSidecarArchive.values(blockSlot);
+    return sidecarsFinalized;
   }
 
   async getSerializedDataColumnSidecars(
@@ -1012,25 +1001,22 @@ export class BeaconChain implements IBeaconChain {
     indices: number[]
   ): Promise<(Uint8Array | undefined)[]> {
     const fork = this.config.getForkName(blockSlot);
-    const dataColumnSidecars: (Uint8Array | undefined)[] = indices.map(() => undefined);
 
     if (isForkPostGloas(fork)) {
       // After gloas, columns are tracked in PayloadEnvelopeInput
       const payloadInput = this.seenPayloadEnvelopeInputCache.get(blockRootHex);
       if (payloadInput) {
-        for (let i = 0; i < indices.length; i++) {
-          const index = indices[i];
+        return indices.map((index) => {
           const sidecar = payloadInput.getColumn(index);
           if (!sidecar) {
-            continue;
+            return undefined;
           }
           const serialized = this.serializedCache.get(sidecar);
           if (serialized) {
-            dataColumnSidecars[i] = serialized;
-          } else {
-            dataColumnSidecars[i] = sszTypesFor(fork as ForkPostGloas).DataColumnSidecar.serialize(sidecar);
+            return serialized;
           }
-        }
+          return sszTypesFor(fork as ForkPostGloas).DataColumnSidecar.serialize(sidecar);
+        });
       }
     } else {
       // Before gloas, columns are tracked in BlockInput
@@ -1039,42 +1025,26 @@ export class BeaconChain implements IBeaconChain {
         if (!isBlockInputColumns(blockInput)) {
           throw new Error(`Expected block input to have columns: slot=${blockSlot} root=${blockRootHex}`);
         }
-        for (let i = 0; i < indices.length; i++) {
-          const index = indices[i];
+        return indices.map((index) => {
           const sidecar = blockInput.getColumn(index);
           if (!sidecar) {
-            continue;
+            return undefined;
           }
           const serialized = this.serializedCache.get(sidecar);
           if (serialized) {
-            dataColumnSidecars[i] = serialized;
-          } else {
-            dataColumnSidecars[i] = sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(
-              sidecar
-            );
+            return serialized;
           }
-        }
+          return sszTypesFor(blockInput.forkName as ForkPostFulu).DataColumnSidecar.serialize(sidecar);
+        });
       }
     }
 
-    const missingPositions = dataColumnSidecars
-      .map((sidecar, position) => (sidecar === undefined ? position : -1))
-      .filter((position) => position !== -1);
-
-    if (missingPositions.length > 0) {
-      const persistedSidecars = await this.db.dataColumns.getManyBinary(
-        {slot: blockSlot, blockRoot: blockRootHex},
-        missingPositions.map((position) => indices[position])
-      );
-      for (let i = 0; i < missingPositions.length; i++) {
-        const sidecar = persistedSidecars[i];
-        if (sidecar !== undefined) {
-          dataColumnSidecars[missingPositions[i]] = sidecar;
-        }
-      }
+    const sidecarsUnfinalized = await this.db.dataColumnSidecar.getManyBinary(fromHex(blockRootHex), indices);
+    if (sidecarsUnfinalized.some((sidecar) => sidecar != null)) {
+      return sidecarsUnfinalized;
     }
-
-    return dataColumnSidecars;
+    const sidecarsFinalized = await this.db.dataColumnSidecarArchive.getManyBinary(blockSlot, indices);
+    return sidecarsFinalized;
   }
 
   async produceCommonBlockBody(blockAttributes: BlockAttributes): Promise<CommonBlockBody> {
@@ -1417,15 +1387,10 @@ export class BeaconChain implements IBeaconChain {
     const slot = data.slot;
     if (isBlindedBeaconBlock(data)) {
       const sszType = this.config.getPostBellatrixForkTypes(slot).BlindedBeaconBlock;
-      void this.persistSszObject(
-        "BlindedBeaconBlock",
-        sszType.serialize(data),
-        toRootHex(sszType.hashTreeRoot(data)),
-        suffix
-      );
+      void this.persistSszObject("BlindedBeaconBlock", sszType.serialize(data), sszType.hashTreeRoot(data), suffix);
     } else {
       const sszType = this.config.getForkTypes(slot).BeaconBlock;
-      void this.persistSszObject("BeaconBlock", sszType.serialize(data), toRootHex(sszType.hashTreeRoot(data)), suffix);
+      void this.persistSszObject("BeaconBlock", sszType.serialize(data), sszType.hashTreeRoot(data), suffix);
     }
   }
 
@@ -1446,39 +1411,33 @@ export class BeaconChain implements IBeaconChain {
       this.persistSszObject(
         `SignedBeaconBlock_slot_${blockSlot}`,
         blockType.serialize(block),
-        toRootHex(this.config.getForkTypes(blockSlot).BeaconBlock.hashTreeRoot(block.message)),
+        blockType.hashTreeRoot(block),
         `${logStr}_block`
       ),
       this.persistSszObject(
         `preState_slot_${preState.slot}_BeaconState`,
         preState.serialize(),
-        toRootHex(preState.hashTreeRoot()),
+        preState.hashTreeRoot(),
         `${logStr}_pre_state`
       ),
       this.persistSszObject(
         `postState_slot_${postState.slot}_BeaconState`,
         postState.serialize(),
-        toRootHex(postStateRoot),
+        postState.hashTreeRoot(),
         `${logStr}_post_state`
       ),
     ]);
   }
 
-  persistInvalidSszValue<T>(type: Type<T>, sszObject: T, suffix?: string, rootHex?: RootHex): void {
+  persistInvalidSszValue<T>(type: Type<T>, sszObject: T, suffix?: string): void {
     if (this.opts.persistInvalidSszObjects) {
-      void this.persistSszObject(
-        type.typeName,
-        type.serialize(sszObject),
-        // in SignedBeaconBlock case, we want to use BeaconBlock root instead
-        rootHex ?? toRootHex(type.hashTreeRoot(sszObject)),
-        suffix
-      );
+      void this.persistSszObject(type.typeName, type.serialize(sszObject), type.hashTreeRoot(sszObject), suffix);
     }
   }
 
-  persistInvalidSszBytes(typeName: string, sszBytes: Uint8Array, rootHex: RootHex, suffix?: string): void {
+  persistInvalidSszBytes(typeName: string, sszBytes: Uint8Array, suffix?: string): void {
     if (this.opts.persistInvalidSszObjects) {
-      void this.persistSszObject(typeName, sszBytes, rootHex, suffix);
+      void this.persistSszObject(typeName, sszBytes, sszBytes, suffix);
     }
   }
 
@@ -1609,14 +1568,14 @@ export class BeaconChain implements IBeaconChain {
     return {state: blockState, stateId: "block_state_any_epoch", shouldWarn: true};
   }
 
-  private async persistSszObject(prefix: string, bytes: Uint8Array, rootHex: RootHex, logStr?: string): Promise<void> {
+  private async persistSszObject(prefix: string, bytes: Uint8Array, root: Uint8Array, logStr?: string): Promise<void> {
     const now = new Date();
     // yyyy-MM-dd
     const dateStr = now.toISOString().split("T")[0];
 
     // by default store to lodestar_archive of current dir
     const dirpath = path.join(this.opts.persistInvalidSszObjectsDir ?? "invalid_ssz_objects", dateStr);
-    const filepath = path.join(dirpath, `${prefix}_${rootHex}.ssz`);
+    const filepath = path.join(dirpath, `${prefix}_${toRootHex(root)}.ssz`);
 
     await ensureDir(dirpath);
 

package/src/chain/errors/blockError.ts

@@ -120,9 +120,9 @@ export type BlockErrorType =
   | {code: BlockErrorCode.ALREADY_KNOWN; root: RootHex}
   | {code: BlockErrorCode.REPEAT_PROPOSAL; proposerIndex: ValidatorIndex; root: RootHex}
   | {code: BlockErrorCode.BLOCK_SLOT_LIMIT_REACHED}
-  | {code: BlockErrorCode.INCORRECT_PROPOSER; slot: Slot; root: RootHex; proposerIndex: ValidatorIndex}
-  | {code: BlockErrorCode.PROPOSAL_SIGNATURE_INVALID; slot: Slot; root: RootHex}
-  | {code: BlockErrorCode.UNKNOWN_PROPOSER; slot: Slot; root: RootHex; proposerIndex: ValidatorIndex}
+  | {code: BlockErrorCode.INCORRECT_PROPOSER; proposerIndex: ValidatorIndex}
+  | {code: BlockErrorCode.PROPOSAL_SIGNATURE_INVALID; blockSlot: Slot}
+  | {code: BlockErrorCode.UNKNOWN_PROPOSER; proposerIndex: ValidatorIndex}
   | {code: BlockErrorCode.INVALID_SIGNATURE; state: IBeaconStateView}
   | {
       code: BlockErrorCode.INVALID_STATE_ROOT;
@@ -132,7 +132,7 @@ export type BlockErrorType =
       postState: IBeaconStateView;
     }
   | {code: BlockErrorCode.NOT_FINALIZED_DESCENDANT; parentRoot: RootHex}
-  | {code: BlockErrorCode.NOT_LATER_THAN_PARENT; slot: Slot; root: RootHex; parentSlot: Slot}
+  | {code: BlockErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
   | {code: BlockErrorCode.NON_LINEAR_PARENT_ROOTS}
   | {code: BlockErrorCode.NON_LINEAR_SLOTS}
   | {code: BlockErrorCode.ENVELOPE_BLOCK_ROOT_MISMATCH; envelopeBlockRoot: RootHex; blockRoot: RootHex}
@@ -140,7 +140,7 @@ export type BlockErrorType =
   | {code: BlockErrorCode.BEACON_CHAIN_ERROR; error: Error}
   | {code: BlockErrorCode.KNOWN_BAD_BLOCK}
   | {code: BlockErrorCode.BLACKLISTED_BLOCK}
-  | {code: BlockErrorCode.INCORRECT_TIMESTAMP; slot: Slot; root: RootHex; timestamp: number; expectedTimestamp: number}
+  | {code: BlockErrorCode.INCORRECT_TIMESTAMP; timestamp: number; expectedTimestamp: number}
   | {code: BlockErrorCode.TOO_MUCH_GAS_USED; gasUsed: number; gasLimit: number}
   | {code: BlockErrorCode.SAME_PARENT_HASH; blockHash: RootHex}
   | {code: BlockErrorCode.TRANSACTIONS_TOO_BIG; size: number; max: number}
@@ -151,21 +151,9 @@ export type BlockErrorType =
       errorMessage: string;
     }
   | {code: BlockErrorCode.DATA_UNAVAILABLE}
-  | {
-      code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS;
-      slot: Slot;
-      root: RootHex;
-      blobKzgCommitmentsLen: number;
-      commitmentLimit: number;
-    }
-  | {
-      code: BlockErrorCode.BID_PARENT_ROOT_MISMATCH;
-      slot: Slot;
-      root: RootHex;
-      bidParentRoot: RootHex;
-      blockParentRoot: RootHex;
-    }
-  | {code: BlockErrorCode.NON_ZERO_DEPOSITS; slot: Slot; root: RootHex; count: number}
+  | {code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS; blobKzgCommitmentsLen: number; commitmentLimit: number}
+  | {code: BlockErrorCode.BID_PARENT_ROOT_MISMATCH; bidParentRoot: RootHex; blockParentRoot: RootHex}
+  | {code: BlockErrorCode.NON_ZERO_DEPOSITS; count: number}
   | {code: BlockErrorCode.PARENT_EXECUTION_INVALID; parentRoot: RootHex}
   | {code: BlockErrorCode.PARENT_PAYLOAD_UNKNOWN; parentRoot: RootHex; parentBlockHash: RootHex}
   | {code: BlockErrorCode.NON_LINEAR_PAYLOAD_ROOTS; parentBlockHash: RootHex; expectedBlockHash: RootHex};

package/src/chain/errors/dataColumnSidecarError.ts

@@ -47,12 +47,10 @@ export enum DataColumnSidecarErrorCode {
 }
 
 export type DataColumnSidecarErrorType =
-  | {code: DataColumnSidecarErrorCode.INVALID_INDEX; slot: Slot; root: RootHex; columnIndex: number}
-  | {code: DataColumnSidecarErrorCode.NO_COMMITMENTS; slot: Slot; root: RootHex; columnIndex: number}
+  | {code: DataColumnSidecarErrorCode.INVALID_INDEX; slot: Slot; columnIndex: number}
+  | {code: DataColumnSidecarErrorCode.NO_COMMITMENTS; slot: Slot; columnIndex: number}
   | {
       code: DataColumnSidecarErrorCode.MISMATCHED_LENGTHS;
-      slot: Slot;
-      root: RootHex;
       columnLength: number;
       commitmentsLength: number;
       proofsLength: number;
@@ -63,17 +61,10 @@ export type DataColumnSidecarErrorType =
       columnIndex: number;
       fork: ForkName;
     }
-  | {
-      code: DataColumnSidecarErrorCode.INVALID_SUBNET;
-      slot: Slot;
-      root: RootHex;
-      columnIndex: number;
-      gossipSubnet: SubnetID;
-    }
+  | {code: DataColumnSidecarErrorCode.INVALID_SUBNET; columnIndex: number; gossipSubnet: SubnetID}
   | {
       code: DataColumnSidecarErrorCode.TOO_MANY_KZG_COMMITMENTS;
       slot: number;
-      root: RootHex;
       columnIndex: number;
       count: number;
       limit: number;
@@ -94,12 +85,12 @@ export type DataColumnSidecarErrorType =
   | {
       code: DataColumnSidecarErrorCode.PROPOSAL_SIGNATURE_INVALID;
       slot: Slot;
-      root: RootHex;
+      blockRoot: RootHex;
       index: number;
     }
-  | {code: DataColumnSidecarErrorCode.NOT_LATER_THAN_PARENT; slot: Slot; root: RootHex; parentSlot: Slot}
-  | {code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID; slot: Slot; root: RootHex; columnIndex: number}
-  | {code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF; slot: Slot; root: RootHex; columnIndex: number}
+  | {code: DataColumnSidecarErrorCode.NOT_LATER_THAN_PARENT; parentSlot: Slot; slot: Slot}
+  | {code: DataColumnSidecarErrorCode.INCLUSION_PROOF_INVALID; slot: Slot; columnIndex: number}
+  | {code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF; slot: Slot; columnIndex: number}
   | {code: DataColumnSidecarErrorCode.INCORRECT_SIDECAR_COUNT; slot: number; expected: number; actual: number}
   | {
       code: DataColumnSidecarErrorCode.INCORRECT_BLOCK;
@@ -115,7 +106,6 @@ export type DataColumnSidecarErrorType =
     }
   | {
       code: DataColumnSidecarErrorCode.INCORRECT_SIDECAR_SLOT;
-      root: RootHex;
       columnIndex: number;
       expected: Slot;
       actual: Slot;
@@ -137,13 +127,7 @@ export type DataColumnSidecarErrorType =
       actual: number;
     }
   | {code: DataColumnSidecarErrorCode.INVALID_KZG_PROOF_BATCH; slot: number; reason: string}
-  | {
-      code: DataColumnSidecarErrorCode.INCORRECT_PROPOSER;
-      slot: Slot;
-      root: RootHex;
-      actualProposerIndex: number;
-      expectedProposerIndex: number;
-    }
+  | {code: DataColumnSidecarErrorCode.INCORRECT_PROPOSER; actualProposerIndex: number; expectedProposerIndex: number}
   | {code: DataColumnSidecarErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING; slot: Slot; blockRoot: RootHex};
 
 export class DataColumnSidecarGossipError extends GossipActionError<DataColumnSidecarErrorType> {}

package/src/chain/errors/executionPayloadEnvelope.ts

@@ -26,35 +26,23 @@ export type ExecutionPayloadEnvelopeErrorType =
       slot: Slot;
     }
   | {code: ExecutionPayloadEnvelopeErrorCode.INVALID_BLOCK; blockRoot: RootHex}
-  | {
-      code: ExecutionPayloadEnvelopeErrorCode.SLOT_MISMATCH;
-      slot: Slot;
-      root: RootHex;
-      envelopeSlot: Slot;
-      blockSlot: Slot;
-    }
+  | {code: ExecutionPayloadEnvelopeErrorCode.SLOT_MISMATCH; envelopeSlot: Slot; blockSlot: Slot}
   | {
       code: ExecutionPayloadEnvelopeErrorCode.BUILDER_INDEX_MISMATCH;
-      slot: Slot;
-      root: RootHex;
       envelopeBuilderIndex: BuilderIndex;
       bidBuilderIndex: BuilderIndex | null;
     }
   | {
       code: ExecutionPayloadEnvelopeErrorCode.BLOCK_HASH_MISMATCH;
-      slot: Slot;
-      root: RootHex;
       envelopeBlockHash: RootHex;
       bidBlockHash: RootHex | null;
     }
   | {
       code: ExecutionPayloadEnvelopeErrorCode.EXECUTION_REQUESTS_ROOT_MISMATCH;
-      slot: Slot;
-      root: RootHex;
       envelopeRequestsRoot: RootHex;
       bidRequestsRoot: RootHex;
     }
-  | {code: ExecutionPayloadEnvelopeErrorCode.INVALID_SIGNATURE; slot: Slot; root: RootHex}
+  | {code: ExecutionPayloadEnvelopeErrorCode.INVALID_SIGNATURE}
   | {code: ExecutionPayloadEnvelopeErrorCode.PAYLOAD_ENVELOPE_INPUT_MISSING; blockRoot: RootHex};
 
 export class ExecutionPayloadEnvelopeError extends GossipActionError<ExecutionPayloadEnvelopeErrorType> {}

package/src/chain/interface.ts

@@ -290,8 +290,8 @@ export interface IBeaconChain {
     postState: IBeaconStateView,
     block: SignedBeaconBlock
   ): Promise<void>;
-  persistInvalidSszValue<T>(type: Type<T>, sszObject: T, suffix?: string, rootHex?: RootHex): void;
-  persistInvalidSszBytes(type: string, sszBytes: Uint8Array, rootHex: RootHex, suffix?: string): void;
+  persistInvalidSszValue<T>(type: Type<T>, sszObject: T | Uint8Array, suffix?: string): void;
+  persistInvalidSszBytes(type: string, sszBytes: Uint8Array, suffix?: string): void;
   regenStateForAttestationVerification(
     attEpoch: Epoch,
     shufflingDependentRoot: RootHex,

package/src/chain/prepareNextSlot.ts

@@ -243,22 +243,6 @@ export class PrepareNextSlotScheduler {
           parentBlockHash = preparedState.latestExecutionPayloadHeader.blockHash;
         }
 
-        // If emitPayloadAttributes is true emit a SSE payloadAttributes event for
-        // every slot. Without the flag, only emit the event if we are proposing in the next slot.
-        if (
-          (feeRecipient || this.chain.opts.emitPayloadAttributes === true) &&
-          this.chain.emitter.listenerCount(routes.events.EventType.payloadAttributes)
-        ) {
-          const data = getPayloadAttributesForSSE(fork as ForkPostBellatrix, this.chain, {
-            prepareState: stateAfterParentPayload,
-            prepareSlot,
-            parentBlockRoot: fromHex(updatedHead.blockRoot),
-            parentBlockHash,
-            feeRecipient: feeRecipient ?? "0x0000000000000000000000000000000000000000",
-          });
-          this.chain.emitter.emit(routes.events.EventType.payloadAttributes, {data, version: fork});
-        }
-
         if (feeRecipient) {
           const preparationTime =
             computeTimeAtSlot(this.config, prepareSlot, this.chain.genesisTime) - Date.now() / 1000;
@@ -289,6 +273,22 @@ export class PrepareNextSlotScheduler {
         }
 
         this.computeStateHashTreeRoot(preparedState, isEpochTransition);
+
+        // If emitPayloadAttributes is true emit a SSE payloadAttributes event for
+        // every slot. Without the flag, only emit the event if we are proposing in the next slot.
+        if (
+          (feeRecipient || this.chain.opts.emitPayloadAttributes === true) &&
+          this.chain.emitter.listenerCount(routes.events.EventType.payloadAttributes)
+        ) {
+          const data = getPayloadAttributesForSSE(fork as ForkPostBellatrix, this.chain, {
+            prepareState: stateAfterParentPayload,
+            prepareSlot,
+            parentBlockRoot: fromHex(updatedHead.blockRoot),
+            parentBlockHash,
+            feeRecipient: feeRecipient ?? "0x0000000000000000000000000000000000000000",
+          });
+          this.chain.emitter.emit(routes.events.EventType.payloadAttributes, {data, version: fork});
+        }
       } else {
         // Pre-bellatrix only reaches here at an epoch transition to precompute the next epoch state
         const preparedState = await this.chain.regen.getBlockSlotState(

package/src/chain/validation/block.ts

@@ -134,9 +134,8 @@ export async function validateGossipBlock(
   if (parentBlock.slot >= blockSlot) {
     throw new BlockGossipError(GossipAction.REJECT, {
       code: BlockErrorCode.NOT_LATER_THAN_PARENT,
-      slot: blockSlot,
-      root: blockRoot,
       parentSlot: parentBlock.slot,
+      slot: blockSlot,
     });
   }
 
@@ -151,8 +150,6 @@ export async function validateGossipBlock(
     if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
       throw new BlockGossipError(GossipAction.REJECT, {
         code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS,
-        slot: blockSlot,
-        root: blockRoot,
         blobKzgCommitmentsLen,
         commitmentLimit: maxBlobsPerBlock,
       });
@@ -170,8 +167,6 @@ export async function validateGossipBlock(
     if (blobKzgCommitmentsLen > maxBlobsPerBlock) {
       throw new BlockGossipError(GossipAction.REJECT, {
         code: BlockErrorCode.TOO_MANY_KZG_COMMITMENTS,
-        slot: blockSlot,
-        root: blockRoot,
         blobKzgCommitmentsLen,
         commitmentLimit: maxBlobsPerBlock,
       });
@@ -181,8 +176,6 @@ export async function validateGossipBlock(
     if (!byteArrayEquals(bid.parentBlockRoot, block.parentRoot)) {
       throw new BlockGossipError(GossipAction.REJECT, {
         code: BlockErrorCode.BID_PARENT_ROOT_MISMATCH,
-        slot: blockSlot,
-        root: blockRoot,
         bidParentRoot: toRootHex(bid.parentBlockRoot),
         blockParentRoot: parentRoot,
       });
@@ -192,8 +185,6 @@ export async function validateGossipBlock(
     if (body.deposits.length !== 0) {
       throw new BlockGossipError(GossipAction.REJECT, {
         code: BlockErrorCode.NON_ZERO_DEPOSITS,
-        slot: blockSlot,
-        root: blockRoot,
         count: body.deposits.length,
       });
     }
@@ -258,8 +249,6 @@ export async function validateGossipBlock(
       if (executionPayload.timestamp !== computeTimeAtSlot(config, blockSlot, chain.genesisTime)) {
         throw new BlockGossipError(GossipAction.REJECT, {
           code: BlockErrorCode.INCORRECT_TIMESTAMP,
-          slot: blockSlot,
-          root: blockRoot,
           timestamp: executionPayload.timestamp,
           expectedTimestamp,
         });
@@ -269,12 +258,7 @@ export async function validateGossipBlock(
 
   // [REJECT] The proposer index is a valid validator index
   if (proposerIndex >= state.validatorCount) {
-    throw new BlockGossipError(GossipAction.REJECT, {
-      code: BlockErrorCode.UNKNOWN_PROPOSER,
-      slot: blockSlot,
-      root: blockRoot,
-      proposerIndex,
-    });
+    throw new BlockGossipError(GossipAction.REJECT, {code: BlockErrorCode.UNKNOWN_PROPOSER, proposerIndex});
   }
 
   // [REJECT] The proposer signature, signed_beacon_block.signature, is valid with respect to the proposer_index pubkey.
@@ -286,12 +270,7 @@ export async function validateGossipBlock(
   // shuffling, the block MAY be queued for later processing while proposers for the block's branch are calculated --
   // in such a case do not REJECT, instead IGNORE this message.
   if (state.getBeaconProposer(blockSlot) !== proposerIndex) {
-    throw new BlockGossipError(GossipAction.REJECT, {
-      code: BlockErrorCode.INCORRECT_PROPOSER,
-      slot: blockSlot,
-      root: blockRoot,
-      proposerIndex,
-    });
+    throw new BlockGossipError(GossipAction.REJECT, {code: BlockErrorCode.INCORRECT_PROPOSER, proposerIndex});
   }
 
   // Simple implementation of a pending block queue. Keeping the block here recycles the queue logic, and keeps the
@@ -336,8 +315,7 @@ export async function verifyBlockProposerSignature(
   if (!(await chain.bls.verifySignatureSets([signatureSet], {verifyOnMainThread: opts.verifyOnMainThread ?? true}))) {
     throw new BlockGossipError(GossipAction.REJECT, {
       code: BlockErrorCode.PROPOSAL_SIGNATURE_INVALID,
-      slot: blockSlot,
-      root: blockRoot,
+      blockSlot,
     });
   }