@lodestar/beacon-node 1.39.1 → 1.40.0-dev.193b2e2047

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

@@ -1,48 +1,21 @@
 import {ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
-import {Slot} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {getSlotFromSignedBeaconBlockSerialized} from "../../../util/sszBytes.js";
 import {BeaconBlocksByRootRequest} from "../../../util/types.js";
 
 export async function* onBeaconBlocksByRoot(
   requestBody: BeaconBlocksByRootRequest,
-  chain: IBeaconChain,
-  db: IBeaconDb
+  chain: IBeaconChain
 ): AsyncIterable<ResponseOutgoing> {
   for (const blockRoot of requestBody) {
     const root = blockRoot;
-    const summary = chain.forkChoice.getBlock(root);
-    let blockBytes: Uint8Array | null = null;
-
-    // finalized block has summary in forkchoice but it stays in blockArchive db
-    if (summary) {
-      blockBytes = await db.block.getBinary(root);
-    }
-
-    let slot: Slot | undefined = undefined;
-    if (!blockBytes) {
-      const blockEntry = await db.blockArchive.getBinaryEntryByRoot(root);
-      if (blockEntry) {
-        slot = blockEntry.key;
-        blockBytes = blockEntry.value;
-      }
-    }
-
-    if (blockBytes) {
-      if (slot === undefined) {
-        const slotFromBytes = getSlotFromSignedBeaconBlockSerialized(blockBytes);
-        if (slotFromBytes === null) {
-          throw Error(`Invalid block bytes for block root ${toRootHex(root)}`);
-        }
-        slot = slotFromBytes;
-      }
+    const block = await chain.getSerializedBlockByRoot(toRootHex(root));
 
+    if (block) {
       yield {
-        data: blockBytes,
-        boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(slot)),
+        data: block.block,
+        boundary: chain.config.getForkBoundaryAtEpoch(computeEpochAtSlot(block.slot)),
       };
     }
   }

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

@@ -2,16 +2,13 @@ import {BLOB_SIDECAR_FIXED_SIZE} from "@lodestar/params";
 import {RespStatus, ResponseError, ResponseOutgoing} from "@lodestar/reqresp";
 import {computeEpochAtSlot} from "@lodestar/state-transition";
 import {RootHex} from "@lodestar/types";
-import {fromHex, toRootHex} from "@lodestar/utils";
+import {toRootHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../chain/index.js";
-import {IBeaconDb} from "../../../db/index.js";
-import {BLOB_SIDECARS_IN_WRAPPER_INDEX} from "../../../db/repositories/blobSidecars.js";
 import {BlobSidecarsByRootRequest} from "../../../util/types.js";
 
 export async function* onBlobSidecarsByRoot(
   requestBody: BlobSidecarsByRootRequest,
-  chain: IBeaconChain,
-  db: IBeaconDb
+  chain: IBeaconChain
 ): AsyncIterable<ResponseOutgoing> {
   const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
 
@@ -34,14 +31,13 @@ export async function* onBlobSidecarsByRoot(
 
     // Check if we need to load sidecars for a new block root
     if (lastFetchedSideCars === null || lastFetchedSideCars.blockRoot !== blockRootHex) {
-      const blobSideCarsBytesWrapped = await db.blobSidecars.getBinary(fromHex(block.blockRoot));
-      if (!blobSideCarsBytesWrapped) {
+      const blobSidecarsBytes = await chain.getSerializedBlobSidecars(block.slot, blockRootHex);
+      if (!blobSidecarsBytes) {
         // Handle the same to onBeaconBlocksByRange
         throw new ResponseError(RespStatus.SERVER_ERROR, `No item for root ${block.blockRoot} slot ${block.slot}`);
       }
-      const blobSideCarsBytes = blobSideCarsBytesWrapped.slice(BLOB_SIDECARS_IN_WRAPPER_INDEX);
 
-      lastFetchedSideCars = {blockRoot: blockRootHex, bytes: blobSideCarsBytes};
+      lastFetchedSideCars = {blockRoot: blockRootHex, bytes: blobSidecarsBytes};
     }
 
     const blobSidecarBytes = lastFetchedSideCars.bytes.slice(

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

@@ -38,7 +38,6 @@ export async function* onDataColumnSidecarsByRange(
   }
 
   const finalized = db.dataColumnSidecarArchive;
-  const unfinalized = db.dataColumnSidecar;
   const finalizedSlot = chain.forkChoice.getFinalizedBlock().slot;
 
   // Finalized range of columns
@@ -92,7 +91,11 @@ export async function* onDataColumnSidecarsByRange(
         // at the time of the start of the request. Spec is clear the chain of columns must be consistent, but on
         // re-org there's no need to abort the request
         // Spec: https://github.com/ethereum/consensus-specs/blob/ad36024441cf910d428d03f87f331fbbd2b3e5f1/specs/fulu/p2p-interface.md#L425-L429
-        const dataColumnSidecars = await unfinalized.getManyBinary(fromHex(block.blockRoot), availableColumns);
+        const dataColumnSidecars = await chain.getSerializedDataColumnSidecars(
+          block.slot,
+          block.blockRoot,
+          availableColumns
+        );
 
         const unavailableColumnIndices: ColumnIndex[] = [];
         for (let i = 0; i < dataColumnSidecars.length; i++) {

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

@@ -61,11 +61,7 @@ export async function* onDataColumnSidecarsByRoot(
       continue;
     }
 
-    const dataColumns = block
-      ? // Non-finalized sidecars are stored by block root
-        await db.dataColumnSidecar.getManyBinary(blockRoot, availableColumns)
-      : // Finalized sidecars are archived and stored by slot
-        await db.dataColumnSidecarArchive.getManyBinary(slot, availableColumns);
+    const dataColumns = await chain.getSerializedDataColumnSidecars(slot, blockRootHex, availableColumns);
 
     const unavailableColumnIndices: ColumnIndex[] = [];
     for (let i = 0; i < dataColumns.length; i++) {

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

@@ -42,12 +42,12 @@ export function getReqRespHandlers({db, chain}: {db: IBeaconDb; chain: IBeaconCh
     [ReqRespMethod.BeaconBlocksByRoot]: (req) => {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       const body = BeaconBlocksByRootRequestType(fork, chain.config).deserialize(req.data);
-      return onBeaconBlocksByRoot(body, chain, db);
+      return onBeaconBlocksByRoot(body, chain);
     },
     [ReqRespMethod.BlobSidecarsByRoot]: (req) => {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       const body = BlobSidecarsByRootRequestType(fork, chain.config).deserialize(req.data);
-      return onBlobSidecarsByRoot(body, chain, db);
+      return onBlobSidecarsByRoot(body, chain);
     },
     [ReqRespMethod.BlobSidecarsByRange]: (req) => {
       const body = ssz.deneb.BlobSidecarsByRangeRequest.deserialize(req.data);

package/src/network/reqresp/utils/dataColumnResponseValidation.ts

@@ -55,7 +55,7 @@ export async function handleColumnSidecarUnavailability({
   const blobsCount = getBlobKzgCommitmentsCountFromSignedBeaconBlockSerialized(chain.config, blockBytes);
 
   // There are zero blobs for that column index, so we can safely return without any error
-  if (blobsCount > 0) return;
+  if (blobsCount === 0) return;
 
   // There are blobs for that column index so we should have synced for it
   // We need to inform to peers that we don't have that expected data

package/src/node/nodejs.ts

@@ -6,9 +6,10 @@ import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconApiMethods} from "@lodestar/api/beacon/server";
 import {BeaconConfig} from "@lodestar/config";
 import type {LoggerNode} from "@lodestar/logger/node";
-import {CachedBeaconStateAllForks, Index2PubkeyCache} from "@lodestar/state-transition";
+import {ZERO_HASH_HEX} from "@lodestar/params";
+import {CachedBeaconStateAllForks, Index2PubkeyCache, isExecutionCachedStateType} from "@lodestar/state-transition";
 import {phase0} from "@lodestar/types";
-import {sleep} from "@lodestar/utils";
+import {sleep, toRootHex} from "@lodestar/utils";
 import {ProcessShutdownCallback} from "@lodestar/validator";
 import {BeaconRestApiServer, getApi} from "../api/index.js";
 import {BeaconChain, IBeaconChain, initBeaconMetrics} from "../chain/index.js";
@@ -221,6 +222,20 @@ export class BeaconNode {
         )
       : null;
 
+    let executionEngineOpts = opts.executionEngine;
+    if (opts.executionEngine.mode === "mock") {
+      const eth1BlockHash = isExecutionCachedStateType(anchorState)
+        ? toRootHex(anchorState.latestExecutionPayloadHeader.blockHash)
+        : undefined;
+      executionEngineOpts = {
+        ...opts.executionEngine,
+        genesisBlockHash: ZERO_HASH_HEX,
+        eth1BlockHash,
+        genesisTime: anchorState.genesisTime,
+        config,
+      };
+    }
+
     const chain = new BeaconChain(opts.chain, {
       privateKey,
       config,
@@ -236,7 +251,7 @@ export class BeaconNode {
       validatorMonitor,
       anchorState,
       isAnchorStateFinalized,
-      executionEngine: initializeExecutionEngine(opts.executionEngine, {
+      executionEngine: initializeExecutionEngine(executionEngineOpts, {
         metrics,
         signal,
         logger: logger.child({module: LoggerModule.execution}),

package/src/sync/backfill/backfill.ts

@@ -750,7 +750,7 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
 
     // GENESIS_SLOT doesn't has valid signature
     if (anchorBlock.message.slot === GENESIS_SLOT) return;
-    await verifyBlockProposerSignature(this.chain.config, this.chain.index2pubkey, this.chain.bls, [anchorBlock]);
+    await verifyBlockProposerSignature(this.chain.config, this.chain.bls, [anchorBlock]);
 
     // We can write to the disk if this is ahead of prevFinalizedCheckpointBlock otherwise
     // we will need to go make checks on the top of sync loop before writing as it might
@@ -815,7 +815,7 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
 
     // If any of the block's proposer signature fail, we can't trust this peer at all
     if (verifiedBlocks.length > 0) {
-      await verifyBlockProposerSignature(this.chain.config, this.chain.index2pubkey, this.chain.bls, verifiedBlocks);
+      await verifyBlockProposerSignature(this.chain.config, this.chain.bls, verifiedBlocks);
 
       // This is bad, like super bad. Abort the backfill
       if (!nextAnchor)

package/src/sync/backfill/verify.ts

@@ -1,6 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {ISignatureSet, Index2PubkeyCache, getBlockProposerSignatureSet} from "@lodestar/state-transition";
+import {ISignatureSet, getBlockProposerSignatureSet} from "@lodestar/state-transition";
 import {Root, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
 import {IBlsVerifier} from "../../chain/bls/index.js";
 import {BackfillSyncError, BackfillSyncErrorCode} from "./errors.js";
@@ -42,14 +42,13 @@ export function verifyBlockSequence(
 
 export async function verifyBlockProposerSignature(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   bls: IBlsVerifier,
   blocks: SignedBeaconBlock[]
 ): Promise<void> {
   if (blocks.length === 1 && blocks[0].message.slot === GENESIS_SLOT) return;
   const signatures = blocks.reduce((sigs: ISignatureSet[], block) => {
     // genesis block doesn't have valid signature
-    if (block.message.slot !== GENESIS_SLOT) sigs.push(getBlockProposerSignatureSet(config, index2pubkey, block));
+    if (block.message.slot !== GENESIS_SLOT) sigs.push(getBlockProposerSignatureSet(config, block));
     return sigs;
   }, []);
 

package/src/sync/range/chain.ts

@@ -585,7 +585,6 @@ export class SyncChain {
 
     if (!res.err) {
       batch.processingSuccess();
-      this.pruneBlockInputs(batch.getBlocks());
 
       // If the processed batch is not empty, validate previous AwaitingValidation blocks.
       if (blocks.length > 0) {

package/src/sync/range/range.ts

@@ -188,9 +188,6 @@ export class RangeSync extends (EventEmitter as {new (): RangeSyncEmitter}) {
       // when this runs, syncing is the most important thing and gossip is not likely to run
       // so we can utilize worker threads to verify signatures
       blsVerifyOnMainThread: false,
-      // we want to be safe to only persist blocks after verifying it to avoid any attacks that may cause our DB
-      // to grow too much
-      eagerPersistBlock: false,
     };
 
     if (this.opts?.disableProcessAsChainSegment) {

package/src/sync/unknownBlock.ts

@@ -423,8 +423,6 @@ export class BlockInputSync {
         // see https://github.com/ChainSafe/lodestar/issues/5650
         ignoreIfFinalized: true,
         blsVerifyOnMainThread: true,
-        // block is validated with correct root, we want to process it as soon as possible
-        eagerPersistBlock: true,
       })
     );
 
@@ -434,7 +432,6 @@ export class BlockInputSync {
     if (!res.err) {
       // no need to update status to "processed", delete anyway
       this.pendingBlocks.delete(pendingBlock.blockInput.blockRootHex);
-      this.chain.seenBlockInputCache.prune(pendingBlock.blockInput.blockRootHex);
 
       // Send child blocks to the processor
       for (const descendantBlock of getDescendantBlocks(pendingBlock.blockInput.blockRootHex, this.pendingBlocks)) {

package/src/util/sszBytes.ts

@@ -479,7 +479,7 @@ export function getBlobKzgCommitmentsCountFromSignedBeaconBlockSerialized(
   blockBytes: Uint8Array
 ): number {
   const slot = getSlotFromSignedBeaconBlockSerialized(blockBytes);
-  if (!slot) throw new Error("Can not parse the slot from block bytes");
+  if (slot === null) throw new Error("Can not parse the slot from block bytes");
 
   if (config.getForkSeq(slot) < ForkSeq.deneb) return 0;