@lodestar/beacon-node 1.50.0-dev.c02b971f5b → 1.50.0-dev.c24762bc60

package/src/network/core/events.ts

@@ -1,21 +1,30 @@
 import EventEmitter from "node:events";
 import {ResponseIncoming, ResponseOutgoing} from "@lodestar/reqresp";
-import {AsyncIterableEventBus, IteratorEvent, RequestEvent} from "../../util/asyncIterableToEvents.js";
+import {
+  AsyncIterableEventBus,
+  IteratorEvent,
+  RequestCancelEvent,
+  RequestEvent,
+} from "../../util/asyncIterableToEvents.js";
 import {StrictEventEmitterSingleArg} from "../../util/strictEvents.js";
 import {EventDirection} from "../events.js";
 import {IncomingRequestArgs, OutgoingRequestArgs} from "../reqresp/types.js";
 
 export enum ReqRespBridgeEvent {
   outgoingRequest = "reqresp.outgoingRequest",
+  outgoingRequestCancel = "reqresp.outgoingRequestCancel",
   outgoingResponse = "reqresp.outgoingResponse",
   incomingRequest = "reqresp.incomingRequest",
+  incomingRequestCancel = "reqresp.incomingRequestCancel",
   incomingResponse = "reqresp.incomingResponse",
 }
 
 export type ReqRespBridgeEventData = {
   [ReqRespBridgeEvent.outgoingRequest]: RequestEvent<OutgoingRequestArgs>;
+  [ReqRespBridgeEvent.outgoingRequestCancel]: RequestCancelEvent;
   [ReqRespBridgeEvent.outgoingResponse]: IteratorEvent<ResponseOutgoing>;
   [ReqRespBridgeEvent.incomingRequest]: RequestEvent<IncomingRequestArgs>;
+  [ReqRespBridgeEvent.incomingRequestCancel]: RequestCancelEvent;
   [ReqRespBridgeEvent.incomingResponse]: IteratorEvent<ResponseIncoming>;
 };
 
@@ -26,8 +35,10 @@ export class ReqRespBridgeEventBus extends (EventEmitter as {new (): IReqRespBri
 // NOTE: If the same event is on this two arrays it can create an infinite cycle
 export const reqRespBridgeEventDirection: Record<ReqRespBridgeEvent, EventDirection> = {
   [ReqRespBridgeEvent.outgoingRequest]: EventDirection.mainToWorker,
+  [ReqRespBridgeEvent.outgoingRequestCancel]: EventDirection.mainToWorker,
   [ReqRespBridgeEvent.outgoingResponse]: EventDirection.mainToWorker,
   [ReqRespBridgeEvent.incomingRequest]: EventDirection.workerToMain,
+  [ReqRespBridgeEvent.incomingRequestCancel]: EventDirection.workerToMain,
   [ReqRespBridgeEvent.incomingResponse]: EventDirection.workerToMain,
 };
 
@@ -36,8 +47,10 @@ export function getReqRespBridgeReqEvents(
 ): AsyncIterableEventBus<OutgoingRequestArgs, ResponseIncoming> {
   return {
     emitRequest: (data) => events.emit(ReqRespBridgeEvent.outgoingRequest, data),
+    emitRequestCancel: (data) => events.emit(ReqRespBridgeEvent.outgoingRequestCancel, data),
     emitResponse: (data) => events.emit(ReqRespBridgeEvent.incomingResponse, data),
     onRequest: (cb) => events.on(ReqRespBridgeEvent.outgoingRequest, cb),
+    onRequestCancel: (cb) => events.on(ReqRespBridgeEvent.outgoingRequestCancel, cb),
     onResponse: (cb) => events.on(ReqRespBridgeEvent.incomingResponse, cb),
   };
 }
@@ -47,8 +60,10 @@ export function getReqRespBridgeRespEvents(
 ): AsyncIterableEventBus<IncomingRequestArgs, ResponseOutgoing> {
   return {
     emitRequest: (data) => events.emit(ReqRespBridgeEvent.incomingRequest, data),
+    emitRequestCancel: (data) => events.emit(ReqRespBridgeEvent.incomingRequestCancel, data),
     emitResponse: (data) => events.emit(ReqRespBridgeEvent.outgoingResponse, data),
     onRequest: (cb) => events.on(ReqRespBridgeEvent.incomingRequest, cb),
+    onRequestCancel: (cb) => events.on(ReqRespBridgeEvent.incomingRequestCancel, cb),
     onResponse: (cb) => events.on(ReqRespBridgeEvent.outgoingResponse, cb),
   };
 }

package/src/network/processor/gossipHandlers.ts

@@ -1395,7 +1395,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           const delaySec = chain.clock.secFromSlot(payloadAttestationMessage.data.slot, seenTimestampSec);
           metrics?.gossipPayloadAttestationMessage.elapsedTimeTillReceived.observe({source: OpSource.gossip}, delaySec);
           const nextSlotProposer = chain.getHeadState().getBeaconProposer(payloadAttestationMessage.data.slot + 1);
-          const isNextSlotProposer = chain.beaconProposerCache.get(nextSlotProposer) !== undefined;
+          const isNextSlotProposer = chain.beaconProposerCache.has(nextSlotProposer);
 
           if (isNextSlotProposer) {
             try {

package/src/node/options.ts

@@ -3,12 +3,14 @@ import {ArchiveMode, DEFAULT_ARCHIVE_MODE, IChainOptions, defaultChainOptions} f
 import {ValidatorMonitorOpts, defaultValidatorMonitorOpts} from "../chain/validatorMonitor.js";
 import {DatabaseOptions, defaultDbOptions} from "../db/options.js";
 import {
+  EngineApiMode,
   ExecutionBuilderOpts,
   ExecutionEngineOpts,
   defaultExecutionBuilderHttpOpts,
   defaultExecutionBuilderOpts,
   defaultExecutionEngineHttpOpts,
   defaultExecutionEngineOpts,
+  engineApiModes,
 } from "../execution/index.js";
 import {MetricsOptions, defaultMetricsOptions} from "../metrics/options.js";
 import {MonitoringOptions, defaultMonitoringOptions} from "../monitoring/options.js";
@@ -19,7 +21,14 @@ import {SyncOptions, defaultSyncOptions} from "../sync/options.js";
 export {allNamespaces} from "../api/rest/index.js";
 
 // Re-export to use as default values in CLI args
-export {defaultExecutionEngineHttpOpts, defaultExecutionBuilderHttpOpts, ArchiveMode, DEFAULT_ARCHIVE_MODE};
+export {
+  defaultExecutionEngineHttpOpts,
+  defaultExecutionBuilderHttpOpts,
+  engineApiModes,
+  ArchiveMode,
+  DEFAULT_ARCHIVE_MODE,
+};
+export type {EngineApiMode};
 
 export interface IBeaconNodeOptions {
   api: ApiOptions;

package/src/util/asyncIterableToEvents.ts

@@ -6,6 +6,10 @@ export type RequestEvent<T> = {
   id: number;
 };
 
+export type RequestCancelEvent = {
+  id: number;
+};
+
 export enum IteratorEventType {
   next = "iterator.next",
   done = "iterator.done",
@@ -19,8 +23,10 @@ export type IteratorEvent<V> =
 
 export type AsyncIterableEventBus<Args, Item> = {
   emitRequest(data: RequestEvent<Args>): void;
+  emitRequestCancel(data: RequestCancelEvent): void;
   emitResponse(data: IteratorEvent<Item>): void;
   onRequest(handler: (data: RequestEvent<Args>) => void): void;
+  onRequestCancel(handler: (data: RequestCancelEvent) => void): void;
   onResponse(handler: (data: IteratorEvent<Item>) => void): void;
 };
 
@@ -37,7 +43,9 @@ export class AsyncIterableBridgeCaller<Args, Item> {
   // TODO: Consider expiring the requests after no reply for long enough, t
   private readonly pending = new Map<number, PendingItem<Item>>();
 
-  constructor(private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onResponse" | "emitRequest">) {
+  constructor(
+    private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onResponse" | "emitRequest" | "emitRequestCancel">
+  ) {
     events.onResponse(this.onResponse.bind(this));
   }
 
@@ -89,7 +97,10 @@ export class AsyncIterableBridgeCaller<Args, Item> {
 
           async return() {
             // This will be reached if the consumer called 'break' or 'return' early in the loop.
-            self.pending.delete(id);
+            // Without the cancel the handler keeps producing items that cross the thread boundary just to be dropped
+            if (self.pending.delete(id)) {
+              self.events.emitRequestCancel({id});
+            }
             return {value: undefined, done: true};
           },
         };
@@ -132,20 +143,35 @@ export class AsyncIterableBridgeCaller<Args, Item> {
 }
 
 export class AsyncIterableBridgeHandler<Args, Item> {
+  private readonly iterators = new Map<number, AsyncIterator<Item>>();
+
   constructor(
-    private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onRequest" | "emitResponse">,
+    private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onRequest" | "onRequestCancel" | "emitResponse">,
     private readonly handler: (args: Args) => AsyncIterable<Item>
   ) {
     events.onRequest(this.onRequest.bind(this));
+    events.onRequestCancel(this.onRequestCancel.bind(this));
+  }
+
+  get iteratingCount(): number {
+    return this.iterators.size;
   }
 
   private async onRequest(data: RequestEvent<Args>): Promise<void> {
     try {
-      for await (const item of this.handler(data.callArgs)) {
+      const iterator = this.handler(data.callArgs)[Symbol.asyncIterator]();
+      this.iterators.set(data.id, iterator);
+
+      while (true) {
+        const result = await iterator.next();
+        if (result.done) {
+          break;
+        }
+
         this.events.emitResponse({
           type: IteratorEventType.next,
           id: data.id,
-          item,
+          item: result.value,
         });
       }
 
@@ -159,6 +185,19 @@ export class AsyncIterableBridgeHandler<Args, Item> {
         id: data.id,
         error: toThreadBoundaryError(e as Error),
       });
+    } finally {
+      this.iterators.delete(data.id);
+    }
+  }
+
+  private onRequestCancel(data: RequestCancelEvent): void {
+    const iterator = this.iterators.get(data.id);
+    if (!iterator?.return) {
+      return;
     }
+
+    // An async generator queues return() behind the next() that is in flight, so at most one more
+    // item is produced before its finally blocks run. Any error surfaces through that next() call.
+    void iterator.return().catch(() => {});
   }
 }

package/src/util/metadata.ts

@@ -6,7 +6,8 @@ export function getLodestarClientVersion(info?: {version?: string; commit?: stri
     code: ClientCode.LS,
     name: "Lodestar",
     version: info?.version ?? "",
-    commit: info?.commit?.slice(0, 8) ?? "",
+    // engine_getClientVersionV1 defines commit as 4 bytes, so builds without git data must not send an empty one
+    commit: info?.commit ? info.commit.slice(0, 8) : "00000000",
   };
 }