@lodestar/builder 1.48.0-dev.b62c97bb9f → 1.48.0-dev.b6386729a9

package/src/services/blockObserver.ts

@@ -1,231 +0,0 @@
-import {ApiClient, ApiError, routes} from "@lodestar/api";
-import {ChainForkConfig} from "@lodestar/config";
-import {ForkPostGloas, isForkPostGloas} from "@lodestar/params";
-import {RootHex, SignedBeaconBlock, Slot, isGloasBeaconBlock} from "@lodestar/types";
-import {Logger, TimeoutError, isErrorAborted, isFetchError, pruneSetToMax, retry, toRootHex} from "@lodestar/utils";
-
-const {EventType} = routes.events;
-
-type BlockEvent = routes.events.EventData[typeof EventType.block];
-
-type BlockObserverOptions = {
-  retries?: number;
-  retryDelay?: number;
-  maxSeenBlockRoots?: number;
-};
-
-export type ObservedBlock = {
-  blockRoot: RootHex;
-  slot: Slot;
-  executionOptimistic: boolean;
-  version: ForkPostGloas;
-  block: SignedBeaconBlock<ForkPostGloas>;
-  signedBid: SignedBeaconBlock<ForkPostGloas>["message"]["body"]["signedExecutionPayloadBid"];
-};
-
-type RunOnBlockFn = (block: ObservedBlock) => Promise<void>;
-
-/**
- * Observes imported beacon blocks through the source beacon node API.
- *
- * Each block root is evaluated at most once while retained in the bounded seen set. Terminal failures remain consumed
- * until normal FIFO eviction; reconnect, replay, and recovery policies are handled separately.
- */
-export class BlockObserver {
-  private readonly fns: RunOnBlockFn[] = [];
-  private readonly seenBlockRoots = new Set<RootHex>();
-  private readonly retries: number;
-  private readonly retryDelay: number;
-  private readonly maxSeenBlockRoots: number;
-
-  constructor(
-    private readonly config: ChainForkConfig,
-    private readonly logger: Logger,
-    private readonly api: ApiClient,
-    {retries = 5, retryDelay = 200, maxSeenBlockRoots = 256}: BlockObserverOptions = {}
-  ) {
-    this.retries = retries;
-    this.retryDelay = retryDelay;
-    this.maxSeenBlockRoots = maxSeenBlockRoots;
-  }
-
-  /**
-   * Register a block consumer. Consumers that require complete observation must register before {@link start}, because
-   * roots observed before registration remain consumed until normal FIFO eviction.
-   */
-  runOnBlock(fn: RunOnBlockFn): void {
-    this.fns.push(fn);
-  }
-
-  start(signal: AbortSignal): void {
-    this.logger.info("Subscribing to block events", {
-      retries: this.retries,
-      retryDelay: this.retryDelay,
-      maxSeenBlockRoots: this.maxSeenBlockRoots,
-    });
-
-    this.api.events
-      .eventstream({
-        topics: [EventType.block],
-        signal,
-        onEvent: (event) => {
-          if (event.type !== EventType.block) {
-            this.logger.debug("Ignoring unexpected beacon event", {eventType: event.type});
-            return;
-          }
-
-          void this.processBlockEvent(event.message, signal);
-        },
-        onError: (error) => {
-          this.logger.error("Failed to receive block event", {}, error);
-        },
-        onClose: () => {
-          if (signal.aborted) {
-            this.logger.debug("Closed stream for block events");
-          } else {
-            this.logger.error("Block event stream closed unexpectedly", {});
-          }
-        },
-      })
-      .catch((error: unknown) => {
-        this.logger.error(
-          "Failed to subscribe to block events",
-          {},
-          error instanceof Error ? error : Error(String(error))
-        );
-      });
-  }
-
-  async processBlockEvent(event: BlockEvent, signal: AbortSignal): Promise<void> {
-    try {
-      const {slot, block: blockRoot, executionOptimistic} = event;
-
-      if (this.seenBlockRoots.has(blockRoot)) {
-        this.logger.debug("Ignoring duplicate block event", {slot, blockRoot});
-        return;
-      }
-
-      this.seenBlockRoots.add(blockRoot);
-      pruneSetToMax(this.seenBlockRoots, this.maxSeenBlockRoots);
-
-      if (!isForkPostGloas(this.config.getForkName(slot))) {
-        this.logger.debug("Ignoring pre-Gloas block event", {slot, blockRoot});
-        return;
-      }
-
-      const response = await retry(
-        async () => {
-          // TODO GLOAS: Remove this lookup once bid-selection notifications provide the required data.
-          const result = await this.api.beacon.getBlockV2({blockId: blockRoot}, {signal});
-          result.assertOk();
-          return result;
-        },
-        {
-          retries: this.retries,
-          retryDelay: this.retryDelay,
-          signal,
-          shouldRetry: isRetryableBlockRetrievalError,
-          onRetry: (error, attempt) => {
-            this.logger.debug("Retrying block retrieval", {
-              slot,
-              blockRoot,
-              attempt,
-              error: error.message,
-            });
-          },
-        }
-      ).catch((error: unknown) => {
-        if (!isErrorAborted(error)) {
-          this.logger.error(
-            "Failed to retrieve block referenced by block event",
-            {slot, blockRoot},
-            error instanceof Error ? error : Error(String(error))
-          );
-        }
-        return null;
-      });
-
-      if (response === null) {
-        return;
-      }
-
-      const {version} = response.meta();
-      if (!isForkPostGloas(version)) {
-        this.logger.warn("Ignoring block with unsupported fork version", {slot, blockRoot, fork: version});
-        return;
-      }
-
-      const block = response.value();
-      if (!isGloasBeaconBlock(block.message)) {
-        this.logger.warn("Block response version and body do not agree", {slot, blockRoot, fork: version});
-        return;
-      }
-
-      if (block.message.slot !== slot) {
-        this.logger.warn("Block response slot does not match block event", {
-          slot,
-          blockRoot,
-          blockSlot: block.message.slot,
-        });
-        return;
-      }
-
-      const postGloasBlock = block as SignedBeaconBlock<ForkPostGloas>;
-      const signedBid = postGloasBlock.message.body.signedExecutionPayloadBid;
-      const observedBlock: ObservedBlock = {
-        blockRoot,
-        slot,
-        executionOptimistic,
-        version,
-        block: postGloasBlock,
-        signedBid,
-      };
-
-      this.logger.debug("Observed post-Gloas block", {
-        slot,
-        blockRoot,
-        fork: version,
-        builderIndex: signedBid.message.builderIndex,
-        value: signedBid.message.value,
-        blockHash: toRootHex(signedBid.message.blockHash),
-        parentBlockHash: toRootHex(signedBid.message.parentBlockHash),
-      });
-
-      await Promise.all(
-        this.fns.map(async (fn) => {
-          try {
-            await fn(observedBlock);
-          } catch (error) {
-            if (isErrorAborted(error)) {
-              return;
-            }
-
-            this.logger.error(
-              "Failed to process observed block",
-              {slot, blockRoot},
-              error instanceof Error ? error : Error(String(error))
-            );
-          }
-        })
-      );
-    } catch (error) {
-      if (isErrorAborted(error)) {
-        return;
-      }
-
-      this.logger.error(
-        "Failed to process block event",
-        {slot: event.slot, blockRoot: event.block},
-        error instanceof Error ? error : Error(String(error))
-      );
-    }
-  }
-}
-
-export function isRetryableBlockRetrievalError(error: Error): boolean {
-  if (error instanceof ApiError) {
-    return error.status === 404 || error.status >= 500;
-  }
-
-  return error instanceof TimeoutError || (isFetchError(error) && error.type !== "input");
-}

package/src/services/payloadStore.ts

@@ -1,51 +0,0 @@
-import {ForkPostGloas} from "@lodestar/params";
-import {BlobsBundle, ExecutionPayload, Root, RootHex, Slot, gloas} from "@lodestar/types";
-
-// NOTE: BuiltPayload will migrate to payloadSource.ts when the payload source lands; the store
-// holds it here for now.
-export type BuiltPayload = {
-  sourceId: string;
-  executionPayload: ExecutionPayload<ForkPostGloas>;
-  executionRequests: gloas.ExecutionRequests;
-  blobsBundle: BlobsBundle<ForkPostGloas>;
-  /** Value of the payload to the fee recipient in wei, as reported by the execution client */
-  executionPayloadValue: bigint;
-};
-
-export type StoredPayload = {
-  slot: Slot;
-  parentBlockRoot: Root;
-  blockHash: RootHex;
-  payload: BuiltPayload;
-};
-
-/** Keep payloads for this many slots after their target slot, late blocks may still commit to them */
-const KEEP_SLOTS = 2;
-
-export class PayloadStore {
-  private readonly byBlockHash = new Map<RootHex, StoredPayload>();
-
-  add(payload: StoredPayload): void {
-    this.byBlockHash.set(payload.blockHash, payload);
-  }
-
-  get(blockHash: RootHex): StoredPayload | null {
-    return this.byBlockHash.get(blockHash) ?? null;
-  }
-
-  has(blockHash: RootHex): boolean {
-    return this.byBlockHash.has(blockHash);
-  }
-
-  prune(currentSlot: Slot): void {
-    for (const [blockHash, {slot}] of this.byBlockHash) {
-      if (slot + KEEP_SLOTS < currentSlot) {
-        this.byBlockHash.delete(blockHash);
-      }
-    }
-  }
-
-  get size(): number {
-    return this.byBlockHash.size;
-  }
-}

package/src/services/proposerPreferencesTracker.ts

@@ -1,74 +0,0 @@
-import {ApiClient, routes} from "@lodestar/api";
-import type {RootHex, Slot, gloas} from "@lodestar/types";
-import {Logger, MapDef, toRootHex} from "@lodestar/utils";
-
-/** Retains validated proposer preferences by the branch-specific identity used for bid validation. */
-export class ProposerPreferencesTracker {
-  private readonly byDependentRootBySlot = new MapDef<Slot, Map<RootHex, gloas.SignedProposerPreferences>>(
-    () => 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);
-    const byDependentRoot = this.byDependentRootBySlot.getOrDefault(proposalSlot);
-
-    if (byDependentRoot.has(dependentRootHex)) {
-      return false;
-    }
-
-    byDependentRoot.set(dependentRootHex, signedProposerPreferences);
-    return true;
-  }
-
-  get(slot: Slot, dependentRoot: RootHex): gloas.SignedProposerPreferences | null {
-    return this.byDependentRootBySlot.get(slot)?.get(dependentRoot) ?? null;
-  }
-
-  prune(currentSlot: Slot): number {
-    let removed = 0;
-    for (const [slot, byDependentRoot] of this.byDependentRootBySlot) {
-      if (slot >= currentSlot) {
-        continue;
-      }
-
-      removed += byDependentRoot.size;
-      this.byDependentRootBySlot.delete(slot);
-    }
-    return removed;
-  }
-}