@lodestar/builder 1.48.0-dev.e9c9b8835d → 1.48.0-dev.fd70e5fc15

package/src/services/bidLedger.ts

@@ -1,245 +0,0 @@
-import {SLOTS_PER_EPOCH} from "@lodestar/params";
-import type {Epoch, RootHex, Slot} from "@lodestar/types";
-import {LodestarError} from "@lodestar/utils";
-
-export type SubmittedBid = {
-  slot: Slot;
-  parentBlockHash: RootHex;
-  parentBlockRoot: RootHex;
-  blockHash: RootHex;
-  valueGwei: number;
-  signedBidRoot: RootHex;
-};
-
-export type BidIdentity = Pick<SubmittedBid, "slot" | "parentBlockHash" | "parentBlockRoot" | "blockHash">;
-
-export type BidLedgerRecord = SubmittedBid & {
-  wonBlockRoots: RootHex[];
-};
-
-type RevealedPayload = {
-  slot: Slot;
-  blockHash: RootHex;
-  envelopeRoot: RootHex;
-  published: boolean;
-};
-
-type MutableBidLedgerRecord = SubmittedBid & {
-  wonBlockRoots: Set<RootHex>;
-  paymentSettled: boolean;
-};
-
-export enum BidLedgerErrorCode {
-  INVALID_BID_VALUE = "BID_LEDGER_ERROR_INVALID_BID_VALUE",
-  DUPLICATE_BID = "BID_LEDGER_ERROR_DUPLICATE_BID",
-  REVEAL_CONFLICT = "BID_LEDGER_ERROR_REVEAL_CONFLICT",
-  UNSETTLED_VALUE_OVERFLOW = "BID_LEDGER_ERROR_UNSETTLED_VALUE_OVERFLOW",
-}
-
-export type BidLedgerErrorType =
-  | {
-      code: BidLedgerErrorCode.INVALID_BID_VALUE;
-      valueGwei: number;
-    }
-  | {
-      code: BidLedgerErrorCode.DUPLICATE_BID;
-      slot: Slot;
-      parentBlockHash: RootHex;
-      parentBlockRoot: RootHex;
-    }
-  | {
-      code: BidLedgerErrorCode.REVEAL_CONFLICT;
-      blockRoot: RootHex;
-      blockHash: RootHex;
-      revealedBlockHash: RootHex;
-      envelopeRoot: RootHex;
-      revealedEnvelopeRoot: RootHex;
-    }
-  | {
-      code: BidLedgerErrorCode.UNSETTLED_VALUE_OVERFLOW;
-      currentEpoch: Epoch;
-    };
-
-export class BidLedgerError extends LodestarError<BidLedgerErrorType> {}
-
-const RECORD_RETENTION_EPOCHS = 3;
-const KEEP_SLOTS = RECORD_RETENTION_EPOCHS * SLOTS_PER_EPOCH;
-
-/** Tracks at most one bid per (slot, parentBlockHash, parentBlockRoot) and its reveal obligations. */
-export class BidLedger {
-  private readonly bidsBySlot = new Map<Slot, Map<string, MutableBidLedgerRecord>>();
-  private readonly revealedPayloadByBlockRoot = new Map<RootHex, RevealedPayload>();
-
-  hasSubmitted(slot: Slot, parentBlockHash: RootHex, parentBlockRoot: RootHex): boolean {
-    return this.bidsBySlot.get(slot)?.has(tupleKey(parentBlockHash, parentBlockRoot)) ?? false;
-  }
-
-  recordBid(bid: SubmittedBid): BidLedgerRecord {
-    if (!Number.isSafeInteger(bid.valueGwei) || bid.valueGwei < 0) {
-      throw new BidLedgerError(
-        {code: BidLedgerErrorCode.INVALID_BID_VALUE, valueGwei: bid.valueGwei},
-        `Invalid bid value valueGwei=${bid.valueGwei}`
-      );
-    }
-
-    let bidsForSlot = this.bidsBySlot.get(bid.slot);
-    if (bidsForSlot === undefined) {
-      bidsForSlot = new Map();
-      this.bidsBySlot.set(bid.slot, bidsForSlot);
-    }
-
-    const key = tupleKey(bid.parentBlockHash, bid.parentBlockRoot);
-    if (bidsForSlot.has(key)) {
-      throw new BidLedgerError(
-        {
-          code: BidLedgerErrorCode.DUPLICATE_BID,
-          slot: bid.slot,
-          parentBlockHash: bid.parentBlockHash,
-          parentBlockRoot: bid.parentBlockRoot,
-        },
-        `Bid already recorded slot=${bid.slot} parentBlockHash=${bid.parentBlockHash} parentBlockRoot=${bid.parentBlockRoot}`
-      );
-    }
-
-    const record = {...bid, wonBlockRoots: new Set<RootHex>(), paymentSettled: false};
-    bidsForSlot.set(key, record);
-    return toRecord(record);
-  }
-
-  recordWin(identity: BidIdentity & Pick<SubmittedBid, "signedBidRoot">, blockRoot: RootHex): BidLedgerRecord | null {
-    const record = this.getBid(identity.slot, identity.parentBlockHash, identity.parentBlockRoot);
-    if (record === null || record.blockHash !== identity.blockHash || record.signedBidRoot !== identity.signedBidRoot) {
-      return null;
-    }
-
-    record.wonBlockRoots.add(blockRoot);
-    return toRecord(record);
-  }
-
-  /** Release a winning bid liability only after its payment is known to be reflected in Builder balance. */
-  recordPaymentSettled(identity: BidIdentity): BidLedgerRecord | null {
-    const record = this.getBid(identity.slot, identity.parentBlockHash, identity.parentBlockRoot);
-    if (record === null || record.blockHash !== identity.blockHash || record.wonBlockRoots.size === 0) {
-      return null;
-    }
-
-    record.paymentSettled = true;
-    return toRecord(record);
-  }
-
-  canReveal(blockRoot: RootHex, blockHash: RootHex, envelopeRoot: RootHex): boolean {
-    const revealedPayload = this.revealedPayloadByBlockRoot.get(blockRoot);
-    return (
-      revealedPayload === undefined ||
-      (revealedPayload.blockHash === blockHash && revealedPayload.envelopeRoot === envelopeRoot)
-    );
-  }
-
-  hasRevealed(blockRoot: RootHex): boolean {
-    return this.revealedPayloadByBlockRoot.has(blockRoot);
-  }
-
-  hasPublishedReveal(blockRoot: RootHex): boolean {
-    return this.revealedPayloadByBlockRoot.get(blockRoot)?.published ?? false;
-  }
-
-  recordReveal(slot: Slot, blockRoot: RootHex, blockHash: RootHex, envelopeRoot: RootHex): void {
-    const revealedPayload = this.revealedPayloadByBlockRoot.get(blockRoot);
-    if (revealedPayload !== undefined) {
-      if (revealedPayload.blockHash !== blockHash || revealedPayload.envelopeRoot !== envelopeRoot) {
-        throw new BidLedgerError(
-          {
-            code: BidLedgerErrorCode.REVEAL_CONFLICT,
-            blockRoot,
-            blockHash,
-            revealedBlockHash: revealedPayload.blockHash,
-            envelopeRoot,
-            revealedEnvelopeRoot: revealedPayload.envelopeRoot,
-          },
-          `Different envelope already recorded blockRoot=${blockRoot} envelopeRoot=${revealedPayload.envelopeRoot}`
-        );
-      }
-      return;
-    }
-
-    this.revealedPayloadByBlockRoot.set(blockRoot, {slot, blockHash, envelopeRoot, published: false});
-  }
-
-  recordRevealPublished(slot: Slot, blockRoot: RootHex, blockHash: RootHex, envelopeRoot: RootHex): void {
-    this.recordReveal(slot, blockRoot, blockHash, envelopeRoot);
-    const revealedPayload = this.revealedPayloadByBlockRoot.get(blockRoot);
-    if (revealedPayload !== undefined) {
-      revealedPayload.published = true;
-    }
-  }
-
-  getUnsettledValueGwei(currentEpoch: Epoch): number {
-    let total = 0;
-    for (const bidsForSlot of this.bidsBySlot.values()) {
-      for (const record of bidsForSlot.values()) {
-        if (record.wonBlockRoots.size === 0 || record.paymentSettled) {
-          continue;
-        }
-
-        total += record.valueGwei;
-        if (!Number.isSafeInteger(total)) {
-          throw new BidLedgerError(
-            {code: BidLedgerErrorCode.UNSETTLED_VALUE_OVERFLOW, currentEpoch},
-            `Unsettled bid value exceeds the safe integer range currentEpoch=${currentEpoch}`
-          );
-        }
-      }
-    }
-    return total;
-  }
-
-  getBidsForSlot(slot: Slot): BidLedgerRecord[] {
-    return Array.from(this.bidsBySlot.get(slot)?.values() ?? [], toRecord);
-  }
-
-  prune(currentSlot: Slot): number {
-    let removed = 0;
-    for (const [slot, bidsForSlot] of this.bidsBySlot) {
-      if (slot >= currentSlot - KEEP_SLOTS) {
-        continue;
-      }
-
-      for (const [key, record] of bidsForSlot) {
-        if (record.wonBlockRoots.size === 0 || record.paymentSettled) {
-          bidsForSlot.delete(key);
-          removed++;
-        }
-      }
-      if (bidsForSlot.size === 0) {
-        this.bidsBySlot.delete(slot);
-      }
-    }
-
-    for (const [blockRoot, revealedPayload] of this.revealedPayloadByBlockRoot) {
-      if (revealedPayload.slot < currentSlot - KEEP_SLOTS) {
-        this.revealedPayloadByBlockRoot.delete(blockRoot);
-      }
-    }
-    return removed;
-  }
-
-  private getBid(slot: Slot, parentBlockHash: RootHex, parentBlockRoot: RootHex): MutableBidLedgerRecord | null {
-    return this.bidsBySlot.get(slot)?.get(tupleKey(parentBlockHash, parentBlockRoot)) ?? null;
-  }
-}
-
-function tupleKey(parentBlockHash: RootHex, parentBlockRoot: RootHex): string {
-  return `${parentBlockHash}:${parentBlockRoot}`;
-}
-
-function toRecord(record: MutableBidLedgerRecord): BidLedgerRecord {
-  return {
-    slot: record.slot,
-    parentBlockHash: record.parentBlockHash,
-    parentBlockRoot: record.parentBlockRoot,
-    blockHash: record.blockHash,
-    valueGwei: record.valueGwei,
-    signedBidRoot: record.signedBidRoot,
-    wonBlockRoots: Array.from(record.wonBlockRoots),
-  };
-}

package/src/services/bidPolicy.ts

@@ -1,65 +0,0 @@
-export type BidContext = {
-  /** Value of the payload to the builder's fee recipient, as reported by the execution client */
-  payloadValueGwei: number;
-  /** Builder balance that can back a bid, excess over the minimum and unsettled payments */
-  coverableGwei: number;
-};
-
-/** Decides how much to pay the proposer for a payload, null means do not bid */
-export interface BidPolicy {
-  computeValue(ctx: BidContext): number | null;
-}
-
-export type ProportionalBidPolicyOpts = {
-  /** Share of the payload value offered to the proposer, in basis points */
-  shareBps: number;
-  /** Fixed amount deducted from the share, e.g. to cover operating cost */
-  fixedCostGwei: number;
-  /** Never bid below this value */
-  minValueGwei: number;
-  /** Never bid above this value */
-  maxValueGwei?: number;
-};
-
-/**
- * Offers a fixed share of the payload value, bounded by the configured limits and the
- * builder's coverable balance. Independent of competing bids.
- */
-export class ProportionalBidPolicy implements BidPolicy {
-  constructor(private readonly opts: ProportionalBidPolicyOpts) {
-    if (!Number.isSafeInteger(opts.shareBps) || opts.shareBps < 0 || opts.shareBps > 10_000) {
-      throw Error(`Invalid shareBps=${opts.shareBps}, must be an integer within [0, 10000]`);
-    }
-
-    if (!Number.isSafeInteger(opts.fixedCostGwei) || opts.fixedCostGwei < 0) {
-      throw Error(`Invalid fixedCostGwei=${opts.fixedCostGwei}, must be a non-negative safe integer`);
-    }
-
-    if (!Number.isSafeInteger(opts.minValueGwei) || opts.minValueGwei < 0) {
-      throw Error(`Invalid minValueGwei=${opts.minValueGwei}, must be a non-negative safe integer`);
-    }
-
-    if (
-      opts.maxValueGwei !== undefined &&
-      (!Number.isSafeInteger(opts.maxValueGwei) || opts.maxValueGwei < opts.minValueGwei)
-    ) {
-      throw Error(
-        `Invalid maxValueGwei=${opts.maxValueGwei}, must be a safe integer greater than or equal to minValueGwei=${opts.minValueGwei}`
-      );
-    }
-  }
-
-  computeValue({payloadValueGwei, coverableGwei}: BidContext): number | null {
-    const proportionalValue = Number((BigInt(payloadValueGwei) * BigInt(this.opts.shareBps)) / 10_000n);
-    const share = proportionalValue - this.opts.fixedCostGwei;
-    // This will override `fixedCostGwei` for the sake of fulfilling `minValueGwei`
-    let value = Math.max(this.opts.minValueGwei, share);
-    if (this.opts.maxValueGwei !== undefined) {
-      value = Math.min(value, this.opts.maxValueGwei);
-    }
-    if (value > coverableGwei) {
-      return null;
-    }
-    return value;
-  }
-}

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;
-  }
-}