@lodestar/beacon-node 1.35.0-dev.47470aab65 → 1.35.0-dev.47c570ab76

package/src/sync/utils/remoteSyncType.ts

@@ -1,144 +0,0 @@
-import {IForkChoice} from "@lodestar/fork-choice";
-import {computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {Slot, Status} from "@lodestar/types";
-import {ChainTarget} from "../range/utils/index.js";
-
-/** The type of peer relative to our current state */
-export enum PeerSyncType {
-  /** The peer is on our chain and is fully synced with respect to our chain */
-  FullySynced = "FullySynced",
-  /** The peer has a greater knowledge of the chain than us that warrants a full sync */
-  Advanced = "Advanced",
-  /** A peer is behind in the sync and not useful to us for downloading blocks */
-  Behind = "Behind",
-}
-
-// Cache Object.keys iteration for faster loops in metrics
-export const peerSyncTypes = Object.keys(PeerSyncType) as PeerSyncType[];
-
-function withinRangeOf(value: number, target: number, range: number): boolean {
-  return value >= target - range && value <= target + range;
-}
-
-export function getPeerSyncType(
-  local: Status,
-  remote: Status,
-  forkChoice: IForkChoice,
-  slotImportTolerance: number
-): PeerSyncType {
-  // Aux vars: Inclusive boundaries of the range to consider a peer's head synced to ours.
-  const nearRangeStart = local.headSlot - slotImportTolerance;
-  const nearRangeEnd = local.headSlot + slotImportTolerance;
-
-  if (remote.finalizedEpoch < local.finalizedEpoch) {
-    // The node has a lower finalized epoch, their chain is not useful to us. There are two
-    // cases where a node can have a lower finalized epoch:
-    //
-    // ## The node is on the same chain
-    //
-    // If a node is on the same chain but has a lower finalized epoch, their head must be
-    // lower than ours. Therefore, we have nothing to request from them.
-    //
-    // ## The node is on a fork
-    //
-    // If a node is on a fork that has a lower finalized epoch, switching to that fork would
-    // cause us to revert a finalized block. This is not permitted, therefore we have no
-    // interest in their blocks.
-    //
-    // We keep these peers to allow them to sync from us.
-    return PeerSyncType.Behind;
-  }
-
-  if (remote.finalizedEpoch > local.finalizedEpoch) {
-    if (
-      // Peer is in next epoch, and head is within range => SYNCED
-      (local.finalizedEpoch + 1 === remote.finalizedEpoch &&
-        withinRangeOf(remote.headSlot, local.headSlot, slotImportTolerance)) ||
-      // Peer's head is known => SYNCED
-      forkChoice.hasBlock(remote.headRoot)
-    ) {
-      return PeerSyncType.FullySynced;
-    }
-    return PeerSyncType.Advanced;
-  }
-
-  // remote.finalizedEpoch == local.finalizedEpoch
-  // NOTE: if a peer has our same `finalizedEpoch` with a different `finalized_root`
-  // they are not considered relevant and won't be propagated to sync.
-  // Check if the peer is the peer is inside the tolerance range to be considered synced.
-  if (remote.headSlot < nearRangeStart) {
-    return PeerSyncType.Behind;
-  }
-
-  if (remote.headSlot > nearRangeEnd && !forkChoice.hasBlock(remote.headRoot)) {
-    // This peer has a head ahead enough of ours and we have no knowledge of their best block.
-    return PeerSyncType.Advanced;
-  }
-  // This peer is either in the tolerance range, or ahead us with an already rejected block.
-  return PeerSyncType.FullySynced;
-}
-
-export enum RangeSyncType {
-  /** A finalized chain sync should be started with this peer */
-  Finalized = "Finalized",
-  /** A head chain sync should be started with this peer */
-  Head = "Head",
-}
-
-// Cache Object.keys iteration for faster loops in metrics
-export const rangeSyncTypes = Object.keys(RangeSyncType) as RangeSyncType[];
-
-/**
- * Check if a peer requires a finalized chain sync. Only if:
- * - The remotes finalized epoch is greater than our current finalized epoch and we have
- *   not seen the finalized hash before
- */
-export function getRangeSyncType(local: Status, remote: Status, forkChoice: IForkChoice): RangeSyncType {
-  if (remote.finalizedEpoch > local.finalizedEpoch && !forkChoice.hasBlock(remote.finalizedRoot)) {
-    return RangeSyncType.Finalized;
-  }
-  return RangeSyncType.Head;
-}
-
-export function getRangeSyncTarget(
-  local: Status,
-  remote: Status,
-  forkChoice: IForkChoice
-): {syncType: RangeSyncType; startEpoch: Slot; target: ChainTarget} {
-  if (remote.finalizedEpoch > local.finalizedEpoch && !forkChoice.hasBlock(remote.finalizedRoot)) {
-    return {
-      // If  RangeSyncType.Finalized, the range of blocks fetchable from startEpoch and target must allow to switch
-      // to RangeSyncType.Head
-      //
-      // finalizedRoot is a block with slot <= computeStartSlotAtEpoch(finalizedEpoch).
-      // If finalizedEpoch does not start with a skipped slot, the SyncChain with this target MUST process the
-      // first block of the next epoch in order to trigger the condition above `forkChoice.hasBlock(remote.finalizedRoot)`
-      // and do a Head sync.
-      //
-      // When doing a finalized sync, we'll process blocks up to the finalized checkpoint, which does not allow to
-      // finalize that checkpoint. Instead, our head will be the finalized checkpoint and our finalized checkpoint will
-      // be some older checkpoint. After completing a finalized SyncChain:
-      //
-      // (== finalized, -- non-finalized)
-      // Remote  ====================================================|----------------|
-      // Local   =====================================|--------------|
-
-      syncType: RangeSyncType.Finalized,
-      startEpoch: local.finalizedEpoch,
-      target: {
-        slot: computeStartSlotAtEpoch(remote.finalizedEpoch),
-        root: remote.finalizedRoot,
-      },
-    };
-  }
-  return {
-    syncType: RangeSyncType.Head,
-    // The new peer has the same finalized (earlier filters should prevent a peer with an
-    // earlier finalized chain from reaching here).
-    startEpoch: Math.min(computeEpochAtSlot(local.headSlot), remote.finalizedEpoch),
-    target: {
-      slot: remote.headSlot,
-      root: remote.headRoot,
-    },
-  };
-}

package/src/util/address.ts

@@ -1,3 +0,0 @@
-export function isValidAddress(address: string): boolean {
-  return /^0x[0-9a-fA-F]{40}$/.test(address);
-}

package/src/util/array.ts

@@ -1,311 +0,0 @@
-/**
- * Return the last index in the array that matches the predicate
- */
-export function findLastIndex<T>(array: T[], predicate: (value: T) => boolean): number {
-  let i = array.length;
-  while (i--) {
-    if (predicate(array[i])) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-/**
- * The node for LinkedList below
- */
-class Node<T> {
-  data: T;
-  next: Node<T> | null = null;
-  prev: Node<T> | null = null;
-
-  constructor(data: T) {
-    this.data = data;
-  }
-}
-
-/**
- * We want to use this if we only need push/pop/shift method
- * without random access.
- * The shift() method should be cheaper than regular array.
- */
-export class LinkedList<T> {
-  private _length: number;
-  private head: Node<T> | null;
-  private tail: Node<T> | null;
-  private pointer: Node<T> | null = null;
-
-  constructor() {
-    this._length = 0;
-    this.head = null;
-    this.tail = null;
-  }
-
-  get length(): number {
-    return this._length;
-  }
-
-  /**
-   * Add to the end of the list
-   */
-  push(data: T): void {
-    if (this._length === 0) {
-      this.tail = this.head = new Node(data);
-      this._length++;
-      return;
-    }
-
-    if (!this.head || !this.tail) {
-      // should not happen
-      throw Error("No head or tail");
-    }
-
-    const newTail = new Node(data);
-    this.tail.next = newTail;
-    newTail.prev = this.tail;
-    this.tail = newTail;
-    this._length++;
-  }
-
-  /**
-   * Add to the beginning of the list
-   */
-  unshift(data: T): void {
-    if (this._length === 0) {
-      this.tail = this.head = new Node(data);
-      this._length++;
-      return;
-    }
-
-    if (!this.head || !this.tail) {
-      // should not happen
-      throw Error("No head or tail");
-    }
-
-    const newHead = new Node(data);
-    newHead.next = this.head;
-    this.head.prev = newHead;
-    this.head = newHead;
-    this._length++;
-  }
-
-  insertAfter(after: T, data: T): void {
-    const node = this.findNode(after);
-    if (!node) {
-      return;
-    }
-
-    if (node === this.tail) {
-      this.push(data);
-      return;
-    }
-
-    const newNode = new Node(data);
-    newNode.next = node.next;
-    newNode.prev = node;
-    node.next = newNode;
-    if (newNode.next) newNode.next.prev = newNode;
-    this._length++;
-  }
-
-  pop(): T | null {
-    const oldTail = this.tail;
-    if (!oldTail) return null;
-    this._length = Math.max(0, this._length - 1);
-
-    if (this._length === 0) {
-      this.head = this.tail = null;
-    } else {
-      this.tail = oldTail.prev;
-      if (this.tail) this.tail.next = null;
-      oldTail.prev = oldTail.next = null;
-    }
-
-    return oldTail.data;
-  }
-
-  shift(): T | null {
-    const oldHead = this.head;
-    if (!oldHead) return null;
-    this._length = Math.max(0, this._length - 1);
-
-    if (this._length === 0) {
-      this.head = this.tail = null;
-    } else {
-      this.head = oldHead.next;
-      if (this.head) this.head.prev = null;
-      oldHead.prev = oldHead.next = null;
-    }
-
-    return oldHead.data;
-  }
-
-  first(): T | null {
-    return this.head?.data ?? null;
-  }
-
-  last(): T | null {
-    return this.tail?.data ?? null;
-  }
-
-  /**
-   * Delete the first item thats search from head
-   */
-  deleteFirst(item: T): boolean {
-    if (item === this.head?.data) {
-      this.shift();
-      return true;
-    }
-
-    let node = this.head;
-    while (node) {
-      if (node.data === item) {
-        if (node === this.tail) this.tail = node.prev;
-        if (node.prev) node.prev.next = node.next;
-        if (node.next) node.next.prev = node.prev;
-        node.prev = node.next = null;
-        this._length--;
-        return true;
-      }
-      node = node.next;
-    }
-
-    return false;
-  }
-
-  /**
-   * Delete the first item search from tail.
-   */
-  deleteLast(item: T): boolean {
-    if (item === this.tail?.data) {
-      this.pop();
-      return true;
-    }
-
-    let node = this.tail;
-    while (node) {
-      if (node.data === item) {
-        if (node === this.head) this.head = node.next;
-        if (node.prev) node.prev.next = node.next;
-        if (node.next) node.next.prev = node.prev;
-        node.prev = node.next = null;
-        this._length--;
-        return true;
-      }
-      node = node.prev;
-    }
-
-    return false;
-  }
-
-  /**
-   * Move an existing item to the head of the list.
-   * If the item is not found, do nothing.
-   */
-  moveToHead(item: T): void {
-    // if this is head, do nothing
-    if (this.head?.data === item) {
-      return;
-    }
-
-    const found = this.deleteFirst(item);
-    if (found) {
-      this.unshift(item);
-    }
-  }
-
-  /**
-   * Move an existing item to the second position of the list.
-   * If the item is not found, do nothing.
-   */
-  moveToSecond(item: T): void {
-    // if this is head or second, do nothing
-    if (this.head?.data === item || this.head?.next?.data === item) {
-      return;
-    }
-
-    const found = this.deleteFirst(item);
-    if (found) {
-      if (this.head?.next) {
-        const oldSecond = this.head.next;
-        const newSecond = new Node(item);
-        this.head.next = newSecond;
-        newSecond.next = oldSecond;
-        newSecond.prev = this.head;
-        oldSecond.prev = newSecond;
-      } else {
-        // only 1 item in the list
-        this.push(item);
-      }
-    }
-  }
-
-  next(): IteratorResult<T> {
-    if (!this.pointer) {
-      return {done: true, value: undefined};
-    }
-    const value = this.pointer.data;
-    this.pointer = this.pointer.next;
-    return {done: false, value};
-  }
-
-  [Symbol.iterator](): IterableIterator<T> {
-    this.pointer = this.head;
-    return this;
-  }
-
-  values(): IterableIterator<T> {
-    this.pointer = this.head;
-    return this;
-  }
-
-  clear(): void {
-    this.head = this.tail = null;
-    this._length = 0;
-  }
-
-  toArray(): T[] {
-    let node = this.head;
-    if (!node) return [];
-
-    const arr: T[] = [];
-    while (node) {
-      arr.push(node.data);
-      node = node.next;
-    }
-
-    return arr;
-  }
-
-  map<U>(fn: (t: T) => U): U[] {
-    let node = this.head;
-    if (!node) return [];
-
-    const arr: U[] = [];
-    while (node) {
-      arr.push(fn(node.data));
-      node = node.next;
-    }
-
-    return arr;
-  }
-
-  /**
-   * Check if the item is in the list.
-   * @returns
-   */
-  has(item: T): boolean {
-    return this.findNode(item) !== null;
-  }
-
-  private findNode(item: T): Node<T> | null {
-    let node = this.head;
-    while (node) {
-      if (node.data === item) {
-        return node;
-      }
-      node = node.next;
-    }
-    return null;
-  }
-}

package/src/util/asyncIterableToEvents.ts

@@ -1,164 +0,0 @@
-import {LinkedList} from "./array.js";
-import {ThreadBoundaryError, fromThreadBoundaryError, toThreadBoundaryError} from "./error.js";
-
-export type RequestEvent<T> = {
-  callArgs: T;
-  id: number;
-};
-
-export enum IteratorEventType {
-  next = "iterator.next",
-  done = "iterator.done",
-  error = "iterator.error",
-}
-
-export type IteratorEvent<V> =
-  | {type: IteratorEventType.next; id: number; item: V}
-  | {type: IteratorEventType.done; id: number}
-  | {type: IteratorEventType.error; id: number; error: ThreadBoundaryError};
-
-export type AsyncIterableEventBus<Args, Item> = {
-  emitRequest(data: RequestEvent<Args>): void;
-  emitResponse(data: IteratorEvent<Item>): void;
-  onRequest(handler: (data: RequestEvent<Args>) => void): void;
-  onResponse(handler: (data: IteratorEvent<Item>) => void): void;
-};
-
-type PendingItem<T> = {
-  items: LinkedList<T>;
-  done: boolean;
-  error: null | Error;
-  onNext: null | (() => void);
-};
-
-export class AsyncIterableBridgeCaller<Args, Item> {
-  private nextRequestId = 0;
-
-  // 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">) {
-    events.onResponse(this.onResponse.bind(this));
-  }
-
-  get pendingCount(): number {
-    return this.pending.size;
-  }
-
-  getAsyncIterable(callArgs: Args): AsyncIterable<Item> {
-    const self = this;
-
-    return {
-      [Symbol.asyncIterator]() {
-        const id = self.nextRequestId++;
-        const req: PendingItem<Item> = {
-          items: new LinkedList(),
-          done: false,
-          error: null,
-          onNext: null,
-        };
-        self.pending.set(id, req);
-
-        self.events.emitRequest({
-          callArgs,
-          id,
-        });
-
-        return {
-          async next() {
-            while (true) {
-              const item = req.items.shift();
-              if (item !== null) {
-                return {value: item, done: false};
-              }
-
-              if (req.error) {
-                throw req.error;
-              }
-
-              if (req.done) {
-                // Is it correct to return undefined on done: true?
-                return {value: undefined as unknown as Item, done: true};
-              }
-
-              await new Promise<void>((resolve) => {
-                req.onNext = resolve;
-              });
-            }
-          },
-
-          async return() {
-            // This will be reached if the consumer called 'break' or 'return' early in the loop.
-            self.pending.delete(id);
-            return {value: undefined, done: true};
-          },
-        };
-      },
-    };
-  }
-
-  private onResponse(data: IteratorEvent<Item>): void {
-    const req = this.pending.get(data.id);
-    if (!req) {
-      // TODO: Log or track, can happen if consumer returns source early
-      return;
-    }
-
-    switch (data.type) {
-      case IteratorEventType.done:
-        // What if it's already done?
-        req.done = true;
-
-        // Do not expect more responses
-        this.pending.delete(data.id);
-        break;
-
-      case IteratorEventType.error:
-        // What if there's already an error?
-        req.error = fromThreadBoundaryError(data.error);
-
-        // Do not expect more responses
-        this.pending.delete(data.id);
-        break;
-
-      case IteratorEventType.next:
-        // Should check that's it's already done or error?
-        req.items.push(data.item);
-        break;
-    }
-
-    req.onNext?.();
-  }
-}
-
-export class AsyncIterableBridgeHandler<Args, Item> {
-  constructor(
-    private readonly events: Pick<AsyncIterableEventBus<Args, Item>, "onRequest" | "emitResponse">,
-    private readonly handler: (args: Args) => AsyncIterable<Item>
-  ) {
-    events.onRequest(this.onRequest.bind(this));
-  }
-
-  private async onRequest(data: RequestEvent<Args>): Promise<void> {
-    try {
-      for await (const item of this.handler(data.callArgs)) {
-        this.events.emitResponse({
-          type: IteratorEventType.next,
-          id: data.id,
-          item,
-        });
-      }
-
-      this.events.emitResponse({
-        type: IteratorEventType.done,
-        id: data.id,
-      });
-    } catch (e) {
-      this.events.emitResponse({
-        type: IteratorEventType.error,
-        id: data.id,
-        error: toThreadBoundaryError(e as Error),
-      });
-    }
-  }
-}

package/src/util/binarySearch.ts

@@ -1,48 +0,0 @@
-export function binarySearchLte<T>(items: T[], value: number, getter: (item: T) => number): T {
-  const lastItem = items.at(-1);
-
-  if (!lastItem) {
-    throw new ErrorNoValues();
-  }
-
-  const maxValue = getter(lastItem);
-  const minValue = getter(items[0]);
-  // Shortcut for the actual value
-  if (value >= maxValue) {
-    return lastItem;
-  }
-  if (value < minValue) {
-    throw new ErrorNoValueMinValue(value, minValue);
-  }
-
-  // Binary search of the value in the array
-  let min = 0;
-  let max = items.length - 1;
-  while (max > min) {
-    const mid = Math.floor((max + min + 1) / 2);
-    if (getter(items[mid]) <= value) {
-      min = mid;
-    } else {
-      max = mid - 1;
-    }
-  }
-  return items[min];
-}
-
-export class ErrorBinarySearch extends Error {}
-
-export class ErrorNoValues extends ErrorBinarySearch {
-  constructor() {
-    super("Empty array to perform binary search");
-  }
-}
-
-export class ErrorNoValueMinValue extends ErrorBinarySearch {
-  value: number;
-  minValue: number;
-  constructor(value: number, minValue: number) {
-    super(`Target value ${value} is less than min value ${minValue}`);
-    this.value = value;
-    this.minValue = minValue;
-  }
-}