@lodestar/beacon-node 1.43.0-dev.7622a1076c → 1.43.0-dev.7733cd3832

package/src/sync/range/chain.ts

@@ -4,6 +4,7 @@ import {ErrorAborted, LodestarError, Logger, toRootHex} from "@lodestar/utils";
 import {isBlockInputBlobs, isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {BlockInputErrorCode} from "../../chain/blocks/blockInput/errors.js";
 import {IBlockInput} from "../../chain/blocks/blockInput/types.js";
+import {PayloadEnvelopeInput} from "../../chain/blocks/payloadEnvelopeInput/payloadEnvelopeInput.js";
 import {BlobSidecarErrorCode} from "../../chain/errors/blobSidecarError.js";
 import {DataColumnSidecarErrorCode} from "../../chain/errors/dataColumnSidecarError.js";
 import {Metrics} from "../../metrics/metrics.js";
@@ -44,13 +45,19 @@ export type SyncChainFns = {
    * Must return if ALL blocks are processed successfully
    * If SOME blocks are processed must throw BlockProcessorError()
    */
-  processChainSegment: (blocks: IBlockInput[], syncType: RangeSyncType) => Promise<void>;
+  processChainSegment: (
+    blocks: IBlockInput[],
+    payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null,
+    syncType: RangeSyncType
+  ) => Promise<void>;
   /** Must download blocks, and validate their range */
   downloadByRange: (
     peer: PeerSyncMeta,
     batch: Batch,
     syncType: RangeSyncType
-  ) => Promise<WarnResult<IBlockInput[], DownloadByRangeError>>;
+  ) => Promise<
+    WarnResult<{blocks: IBlockInput[]; payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null}, DownloadByRangeError>
+  >;
   /** Report peer for negative actions. Decouples from the full network instance */
   reportPeer: (peer: PeerIdStr, action: PeerAction, actionName: string) => void;
   /** Gets current peer custodyColumns and earliestAvailableSlot */
@@ -516,7 +523,8 @@ export class SyncChain {
         });
         this.metrics?.syncRange.downloadByRange.success.inc();
         const {warnings, result} = res.result;
-        const downloadSuccessOutput = batch.downloadingSuccess(peer.peerId, result);
+        const {blocks: downloadedBlocks, payloadEnvelopes} = result;
+        const downloadSuccessOutput = batch.downloadingSuccess(peer.peerId, downloadedBlocks, payloadEnvelopes);
         const logMeta: Record<string, number> = {
           blockCount: downloadSuccessOutput.blocks.length,
         };
@@ -578,10 +586,10 @@ export class SyncChain {
    * Sends `batch` to the processor. Note: batch may be empty
    */
   private async processBatch(batch: Batch): Promise<void> {
-    const blocks = batch.startProcessing();
+    const {blocks, payloadEnvelopes} = batch.startProcessing();
 
     // wrapError ensures to never call both batch success() and batch error()
-    const res = await wrapError(this.processChainSegment(blocks, this.syncType));
+    const res = await wrapError(this.processChainSegment(blocks, payloadEnvelopes, this.syncType));
 
     if (!res.err) {
       batch.processingSuccess();

package/src/sync/range/range.ts

@@ -172,7 +172,7 @@ export class RangeSync extends (EventEmitter as {new (): RangeSyncEmitter}) {
   }
 
   /** Convenience method for `SyncChain` */
-  private processChainSegment: SyncChainFns["processChainSegment"] = async (blocks, syncType) => {
+  private processChainSegment: SyncChainFns["processChainSegment"] = async (blocks, payloadEnvelopes, syncType) => {
     // Not trusted, verify signatures
     const flags: ImportBlockOpts = {
       // Only skip importing attestations for finalized sync. For head sync attestation are valuable.
@@ -192,9 +192,15 @@ export class RangeSync extends (EventEmitter as {new (): RangeSyncEmitter}) {
 
     if (this.opts?.disableProcessAsChainSegment) {
       // Should only be used for debugging or testing
-      for (const block of blocks) await this.chain.processBlock(block, flags);
+      for (const block of blocks) {
+        await this.chain.processBlock(block, flags);
+        const payloadEnvelope = payloadEnvelopes?.get(block.slot);
+        if (payloadEnvelope) {
+          await this.chain.processExecutionPayload(payloadEnvelope);
+        }
+      }
     } else {
-      await this.chain.processChainSegment(blocks, flags);
+      await this.chain.processChainSegment(blocks, payloadEnvelopes, flags);
     }
   };
 
@@ -209,13 +215,19 @@ export class RangeSync extends (EventEmitter as {new (): RangeSyncEmitter}) {
       peerDasMetrics: this.chain.metrics?.peerDas,
       ...batch.getRequestsForPeer(peer),
     });
-    const cached = cacheByRangeResponses({
+    const {responses, payloadEnvelopes: downloadedPayloadEnvelopes} = result;
+    const {blocks, payloadEnvelopes} = cacheByRangeResponses({
       cache: this.chain.seenBlockInputCache,
+      seenPayloadEnvelopeInputCache: this.chain.seenPayloadEnvelopeInputCache,
       peerIdStr: peer.peerId,
-      responses: result,
+      responses,
       batchBlocks,
+      downloadedPayloadEnvelopes,
+      existingPayloadEnvelopes: batch.getPayloadEnvelopes(),
+      custodyConfig: this.chain.custodyConfig,
+      seenTimestampSec: Date.now() / 1000,
     });
-    return {result: cached, warnings};
+    return {result: {blocks, payloadEnvelopes}, warnings};
   };
 
   private pruneBlockInputs: SyncChainFns["pruneBlockInputs"] = (blocks: IBlockInput[]) => {

package/src/sync/types.ts

@@ -1,5 +1,8 @@
 import {RootHex, Slot} from "@lodestar/types";
+import {SignedExecutionPayloadEnvelope} from "@lodestar/types/gloas";
+import {toRootHex} from "@lodestar/utils";
 import {IBlockInput} from "../chain/blocks/blockInput/index.js";
+import {PayloadEnvelopeInput} from "../chain/blocks/payloadEnvelopeInput/payloadEnvelopeInput.js";
 
 export enum PendingBlockType {
   /**
@@ -26,6 +29,14 @@ export enum PendingBlockInputStatus {
   processing = "processing",
 }
 
+export enum PendingPayloadInputStatus {
+  pending = "pending",
+  fetching = "fetching",
+  waitingForBlock = "waiting_for_block",
+  downloaded = "downloaded",
+  processing = "processing",
+}
+
 export type PendingBlockInput = {
   status: PendingBlockInputStatus;
   blockInput: IBlockInput;
@@ -44,10 +55,47 @@ export type PendingRootHex = {
 
 export type BlockInputSyncCacheItem = PendingBlockInput | PendingRootHex;
 
+export type PendingPayloadInput = {
+  status:
+    | PendingPayloadInputStatus.pending
+    | PendingPayloadInputStatus.fetching
+    | PendingPayloadInputStatus.downloaded
+    | PendingPayloadInputStatus.processing;
+  payloadInput: PayloadEnvelopeInput;
+  timeAddedSec: number;
+  timeSyncedSec?: number;
+  peerIdStrings: Set<string>;
+};
+
+export type PendingPayloadRootHex = {
+  status: PendingPayloadInputStatus.pending | PendingPayloadInputStatus.fetching;
+  rootHex: RootHex;
+  timeAddedSec: number;
+  timeSyncedSec?: number;
+  peerIdStrings: Set<string>;
+};
+
+export type PendingPayloadEnvelope = {
+  status: PendingPayloadInputStatus.waitingForBlock;
+  envelope: SignedExecutionPayloadEnvelope;
+  timeAddedSec: number;
+  peerIdStrings: Set<string>;
+};
+
+export type PayloadSyncCacheItem = PendingPayloadInput | PendingPayloadRootHex | PendingPayloadEnvelope;
+
 export function isPendingBlockInput(pending: BlockInputSyncCacheItem): pending is PendingBlockInput {
   return "blockInput" in pending;
 }
 
+export function isPendingPayloadInput(pending: PayloadSyncCacheItem): pending is PendingPayloadInput {
+  return "payloadInput" in pending;
+}
+
+export function isPendingPayloadEnvelope(pending: PayloadSyncCacheItem): pending is PendingPayloadEnvelope {
+  return "envelope" in pending;
+}
+
 export function getBlockInputSyncCacheItemRootHex(block: BlockInputSyncCacheItem): RootHex {
   return isPendingBlockInput(block) ? block.blockInput.blockRootHex : block.rootHex;
 }
@@ -55,3 +103,27 @@ export function getBlockInputSyncCacheItemRootHex(block: BlockInputSyncCacheItem
 export function getBlockInputSyncCacheItemSlot(block: BlockInputSyncCacheItem): Slot | string {
   return isPendingBlockInput(block) ? block.blockInput.slot : "unknown";
 }
+
+export function getPayloadSyncCacheItemRootHex(payload: PayloadSyncCacheItem): RootHex {
+  if (isPendingPayloadInput(payload)) {
+    return payload.payloadInput.blockRootHex;
+  }
+
+  if (isPendingPayloadEnvelope(payload)) {
+    return toRootHex(payload.envelope.message.beaconBlockRoot);
+  }
+
+  return payload.rootHex;
+}
+
+export function getPayloadSyncCacheItemSlot(payload: PayloadSyncCacheItem): Slot | string {
+  if (isPendingPayloadInput(payload)) {
+    return payload.payloadInput.slot;
+  }
+
+  if (isPendingPayloadEnvelope(payload)) {
+    return payload.envelope.message.payload.slotNumber;
+  }
+
+  return "unknown";
+}