@lodestar/beacon-node 1.35.0-dev.91dadf81de → 1.35.0-dev.955e9f89ed

package/src/util/sszBytes.ts

@@ -1,481 +0,0 @@
-import {BitArray, deserializeUint8ArrayBitListFromBytes} from "@chainsafe/ssz";
-import {ChainForkConfig} from "@lodestar/config";
-import {
-  BYTES_PER_FIELD_ELEMENT,
-  FIELD_ELEMENTS_PER_BLOB,
-  ForkName,
-  ForkPostDeneb,
-  ForkSeq,
-  MAX_COMMITTEES_PER_SLOT,
-  isForkPostElectra,
-} from "@lodestar/params";
-import {BLSSignature, CommitteeIndex, RootHex, Slot, ValidatorIndex, ssz} from "@lodestar/types";
-
-export type BlockRootHex = RootHex;
-// pre-electra, AttestationData is used to cache attestations
-export type AttDataBase64 = string;
-// electra, CommitteeBits
-export type CommitteeBitsBase64 = string;
-
-// pre-electra
-// class Attestation(Container):
-//   aggregation_bits: Bitlist[MAX_VALIDATORS_PER_COMMITTEE] - offset 4
-//   data: AttestationData - target data - 128
-//   signature: BLSSignature - 96
-
-// electra
-// class Attestation(Container):
-//   aggregation_bits: BitList[MAX_VALIDATORS_PER_COMMITTEE * MAX_COMMITTEES_PER_SLOT] - offset 4
-//   data: AttestationData - target data - 128
-//   signature: BLSSignature - 96
-//   committee_bits: BitVector[MAX_COMMITTEES_PER_SLOT]
-// electra
-// class SingleAttestation(Container):
-//   committeeIndex: CommitteeIndex - data 8
-//   attesterIndex: ValidatorIndex - data 8
-//   data: AttestationData - data 128
-//   signature: BLSSignature - data 96
-//
-// for all forks
-// class AttestationData(Container): 128 bytes fixed size
-//   slot: Slot                - data 8
-//   index: CommitteeIndex     - data 8
-//   beacon_block_root: Root   - data 32
-//   source: Checkpoint        - data 40
-//   target: Checkpoint        - data 40
-
-const VARIABLE_FIELD_OFFSET = 4;
-const ATTESTATION_BEACON_BLOCK_ROOT_OFFSET = VARIABLE_FIELD_OFFSET + 8 + 8;
-export const ROOT_SIZE = 32;
-const SLOT_SIZE = 8;
-const COMMITTEE_INDEX_SIZE = 8;
-const ATTESTATION_DATA_SIZE = 128;
-// MAX_COMMITTEES_PER_SLOT is in bit, need to convert to byte
-const COMMITTEE_BITS_SIZE = Math.max(Math.ceil(MAX_COMMITTEES_PER_SLOT / 8), 1);
-const SIGNATURE_SIZE = 96;
-const SINGLE_ATTESTATION_ATTDATA_OFFSET = 8 + 8;
-const SINGLE_ATTESTATION_SLOT_OFFSET = SINGLE_ATTESTATION_ATTDATA_OFFSET;
-const SINGLE_ATTESTATION_COMMITTEE_INDEX_OFFSET = 0;
-const SINGLE_ATTESTATION_ATTESTER_INDEX_OFFSET = 8;
-const SINGLE_ATTESTATION_BEACON_BLOCK_ROOT_OFFSET = SINGLE_ATTESTATION_ATTDATA_OFFSET + 8 + 8;
-const SINGLE_ATTESTATION_SIGNATURE_OFFSET = SINGLE_ATTESTATION_ATTDATA_OFFSET + ATTESTATION_DATA_SIZE;
-const SINGLE_ATTESTATION_SIZE = SINGLE_ATTESTATION_SIGNATURE_OFFSET + SIGNATURE_SIZE;
-
-// shared Buffers to convert bytes to hex/base64
-const blockRootBuf = Buffer.alloc(ROOT_SIZE);
-const attDataBuf = Buffer.alloc(ATTESTATION_DATA_SIZE);
-const committeeBitsDataBuf = Buffer.alloc(COMMITTEE_BITS_SIZE);
-
-/**
- * Extract slot from attestation serialized bytes.
- * Return null if data is not long enough to extract slot.
- */
-export function getSlotFromAttestationSerialized(data: Uint8Array): Slot | null {
-  if (data.length < VARIABLE_FIELD_OFFSET + SLOT_SIZE) {
-    return null;
-  }
-
-  return getSlotFromOffset(data, VARIABLE_FIELD_OFFSET);
-}
-
-/**
- * Extract block root from attestation serialized bytes.
- * Return null if data is not long enough to extract block root.
- */
-export function getBlockRootFromAttestationSerialized(data: Uint8Array): BlockRootHex | null {
-  if (data.length < ATTESTATION_BEACON_BLOCK_ROOT_OFFSET + ROOT_SIZE) {
-    return null;
-  }
-
-  blockRootBuf.set(
-    data.subarray(ATTESTATION_BEACON_BLOCK_ROOT_OFFSET, ATTESTATION_BEACON_BLOCK_ROOT_OFFSET + ROOT_SIZE)
-  );
-  return "0x" + blockRootBuf.toString("hex");
-}
-
-/**
- * Extract attestation data base64 from all forks' attestation serialized bytes.
- * Return null if data is not long enough to extract attestation data.
- */
-export function getAttDataFromAttestationSerialized(data: Uint8Array): AttDataBase64 | null {
-  if (data.length < VARIABLE_FIELD_OFFSET + ATTESTATION_DATA_SIZE) {
-    return null;
-  }
-
-  // base64 is a bit efficient than hex
-  attDataBuf.set(data.subarray(VARIABLE_FIELD_OFFSET, VARIABLE_FIELD_OFFSET + ATTESTATION_DATA_SIZE));
-  return attDataBuf.toString("base64");
-}
-
-/**
- * Extract AttDataBase64 from `beacon_attestation` gossip message serialized bytes.
- * This is used for GossipQueue.
- */
-export function getBeaconAttestationGossipIndex(fork: ForkName, data: Uint8Array): AttDataBase64 | null {
-  return ForkSeq[fork] >= ForkSeq.electra
-    ? getAttDataFromSingleAttestationSerialized(data)
-    : getAttDataFromAttestationSerialized(data);
-}
-
-/**
- * Extract slot from `beacon_attestation` gossip message serialized bytes.
- */
-export function getSlotFromBeaconAttestationSerialized(fork: ForkName, data: Uint8Array): Slot | null {
-  return ForkSeq[fork] >= ForkSeq.electra
-    ? getSlotFromSingleAttestationSerialized(data)
-    : getSlotFromAttestationSerialized(data);
-}
-
-/**
- * Extract block root from `beacon_attestation` gossip message serialized bytes.
- */
-export function getBlockRootFromBeaconAttestationSerialized(fork: ForkName, data: Uint8Array): BlockRootHex | null {
-  return ForkSeq[fork] >= ForkSeq.electra
-    ? getBlockRootFromSingleAttestationSerialized(data)
-    : getBlockRootFromAttestationSerialized(data);
-}
-
-/**
- * Extract aggregation bits from attestation serialized bytes.
- * Return null if data is not long enough to extract aggregation bits.
- * Pre-electra attestation only
- */
-export function getAggregationBitsFromAttestationSerialized(data: Uint8Array): BitArray | null {
-  const aggregationBitsStartIndex = VARIABLE_FIELD_OFFSET + ATTESTATION_DATA_SIZE + SIGNATURE_SIZE;
-
-  if (data.length < aggregationBitsStartIndex) {
-    return null;
-  }
-
-  const {uint8Array, bitLen} = deserializeUint8ArrayBitListFromBytes(data, aggregationBitsStartIndex, data.length);
-  return new BitArray(uint8Array, bitLen);
-}
-
-/**
- * Extract signature from attestation serialized bytes.
- * Return null if data is not long enough to extract signature.
- */
-export function getSignatureFromAttestationSerialized(data: Uint8Array): BLSSignature | null {
-  const signatureStartIndex = VARIABLE_FIELD_OFFSET + ATTESTATION_DATA_SIZE;
-
-  if (data.length < signatureStartIndex + SIGNATURE_SIZE) {
-    return null;
-  }
-
-  return data.subarray(signatureStartIndex, signatureStartIndex + SIGNATURE_SIZE);
-}
-
-/**
- * Extract slot from SingleAttestation serialized bytes.
- * Return null if data is not long enough to extract slot.
- */
-export function getSlotFromSingleAttestationSerialized(data: Uint8Array): Slot | null {
-  if (data.length !== SINGLE_ATTESTATION_SIZE) {
-    return null;
-  }
-
-  return getSlotFromOffset(data, SINGLE_ATTESTATION_SLOT_OFFSET);
-}
-
-/**
- * Extract committee index from SingleAttestation serialized bytes.
- * Return null if data is not long enough to extract slot.
- */
-export function getCommitteeIndexFromSingleAttestationSerialized(
-  fork: ForkName,
-  data: Uint8Array
-): CommitteeIndex | null {
-  if (isForkPostElectra(fork)) {
-    if (data.length !== SINGLE_ATTESTATION_SIZE) {
-      return null;
-    }
-
-    return getIndexFromOffset(data, SINGLE_ATTESTATION_COMMITTEE_INDEX_OFFSET);
-  }
-
-  if (data.length < VARIABLE_FIELD_OFFSET + SLOT_SIZE + COMMITTEE_INDEX_SIZE) {
-    return null;
-  }
-
-  return getIndexFromOffset(data, VARIABLE_FIELD_OFFSET + SLOT_SIZE);
-}
-
-/**
- * Extract attester index from SingleAttestation serialized bytes.
- * Return null if data is not long enough to extract index.
- */
-export function getAttesterIndexFromSingleAttestationSerialized(data: Uint8Array): ValidatorIndex | null {
-  if (data.length !== SINGLE_ATTESTATION_SIZE) {
-    return null;
-  }
-
-  return getIndexFromOffset(data, SINGLE_ATTESTATION_ATTESTER_INDEX_OFFSET);
-}
-
-/**
- * Extract block root from SingleAttestation serialized bytes.
- * Return null if data is not long enough to extract block root.
- */
-export function getBlockRootFromSingleAttestationSerialized(data: Uint8Array): BlockRootHex | null {
-  if (data.length !== SINGLE_ATTESTATION_SIZE) {
-    return null;
-  }
-
-  blockRootBuf.set(
-    data.subarray(SINGLE_ATTESTATION_BEACON_BLOCK_ROOT_OFFSET, SINGLE_ATTESTATION_BEACON_BLOCK_ROOT_OFFSET + ROOT_SIZE)
-  );
-  return `0x${blockRootBuf.toString("hex")}`;
-}
-
-/**
- * Extract attestation data base64 from SingleAttestation serialized bytes.
- * Return null if data is not long enough to extract attestation data.
- */
-export function getAttDataFromSingleAttestationSerialized(data: Uint8Array): AttDataBase64 | null {
-  if (data.length !== SINGLE_ATTESTATION_SIZE) {
-    return null;
-  }
-
-  // base64 is a bit efficient than hex
-  attDataBuf.set(
-    data.subarray(SINGLE_ATTESTATION_ATTDATA_OFFSET, SINGLE_ATTESTATION_ATTDATA_OFFSET + ATTESTATION_DATA_SIZE)
-  );
-  return attDataBuf.toString("base64");
-}
-
-/**
- * Extract signature from SingleAttestation serialized bytes.
- * Return null if data is not long enough to extract signature.
- */
-export function getSignatureFromSingleAttestationSerialized(data: Uint8Array): BLSSignature | null {
-  if (data.length !== SINGLE_ATTESTATION_SIZE) {
-    return null;
-  }
-
-  return data.subarray(SINGLE_ATTESTATION_SIGNATURE_OFFSET, SINGLE_ATTESTATION_SIGNATURE_OFFSET + SIGNATURE_SIZE);
-}
-
-//
-// class SignedAggregateAndProof(Container):
-//    message: AggregateAndProof - offset 4
-//    signature: BLSSignature    - data 96
-
-// class AggregateAndProof(Container)
-//    aggregatorIndex: ValidatorIndex - data 8
-//    aggregate: Attestation          - offset 4
-//    selectionProof: BLSSignature    - data 96
-
-const AGGREGATE_AND_PROOF_OFFSET = 4 + 96;
-const AGGREGATE_OFFSET = AGGREGATE_AND_PROOF_OFFSET + 8 + 4 + 96;
-const SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET = AGGREGATE_OFFSET + VARIABLE_FIELD_OFFSET;
-const SIGNED_AGGREGATE_AND_PROOF_BLOCK_ROOT_OFFSET = SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET + 8 + 8;
-
-/**
- * Extract slot from signed aggregate and proof serialized bytes
- * Return null if data is not long enough to extract slot
- * This works for both phase + electra
- */
-export function getSlotFromSignedAggregateAndProofSerialized(data: Uint8Array): Slot | null {
-  if (data.length < SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET + SLOT_SIZE) {
-    return null;
-  }
-
-  return getSlotFromOffset(data, SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET);
-}
-
-/**
- * Extract block root from signed aggregate and proof serialized bytes
- * Return null if data is not long enough to extract block root
- * This works for both phase + electra
- */
-export function getBlockRootFromSignedAggregateAndProofSerialized(data: Uint8Array): BlockRootHex | null {
-  if (data.length < SIGNED_AGGREGATE_AND_PROOF_BLOCK_ROOT_OFFSET + ROOT_SIZE) {
-    return null;
-  }
-
-  blockRootBuf.set(
-    data.subarray(
-      SIGNED_AGGREGATE_AND_PROOF_BLOCK_ROOT_OFFSET,
-      SIGNED_AGGREGATE_AND_PROOF_BLOCK_ROOT_OFFSET + ROOT_SIZE
-    )
-  );
-  return "0x" + blockRootBuf.toString("hex");
-}
-
-/**
- * Extract AttestationData base64 from SignedAggregateAndProof for electra
- * Return null if data is not long enough
- */
-export function getAttDataFromSignedAggregateAndProofElectra(data: Uint8Array): AttDataBase64 | null {
-  const startIndex = SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET;
-  const endIndex = startIndex + ATTESTATION_DATA_SIZE;
-
-  if (data.length < endIndex + SIGNATURE_SIZE + COMMITTEE_BITS_SIZE) {
-    return null;
-  }
-  attDataBuf.set(data.subarray(startIndex, endIndex));
-  return attDataBuf.toString("base64");
-}
-
-/**
- * Extract CommitteeBits base64 from SignedAggregateAndProof for electra
- * Return null if data is not long enough
- */
-export function getCommitteeBitsFromSignedAggregateAndProofElectra(data: Uint8Array): CommitteeBitsBase64 | null {
-  const startIndex = SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET + ATTESTATION_DATA_SIZE + SIGNATURE_SIZE;
-  const endIndex = startIndex + COMMITTEE_BITS_SIZE;
-
-  if (data.length < endIndex) {
-    return null;
-  }
-
-  committeeBitsDataBuf.set(data.subarray(startIndex, endIndex));
-  return committeeBitsDataBuf.toString("base64");
-}
-
-/**
- * Extract attestation data base64 from signed aggregate and proof serialized bytes.
- * Return null if data is not long enough to extract attestation data.
- */
-export function getAttDataFromSignedAggregateAndProofPhase0(data: Uint8Array): AttDataBase64 | null {
-  if (data.length < SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET + ATTESTATION_DATA_SIZE) {
-    return null;
-  }
-
-  // base64 is a bit efficient than hex
-  attDataBuf.set(
-    data.subarray(
-      SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET,
-      SIGNED_AGGREGATE_AND_PROOF_SLOT_OFFSET + ATTESTATION_DATA_SIZE
-    )
-  );
-  return attDataBuf.toString("base64");
-}
-
-/**
- * 4 + 96 = 100
- * ```
- * class SignedBeaconBlock(Container):
- *   message: BeaconBlock [offset - 4 bytes]
- *   signature: BLSSignature [fixed - 96 bytes]
- *
- * class BeaconBlock(Container):
- *   slot: Slot [fixed - 8 bytes]
- *   proposer_index: ValidatorIndex
- *   parent_root: Root
- *   state_root: Root
- *   body: BeaconBlockBody
- * ```
- */
-const SLOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK = VARIABLE_FIELD_OFFSET + SIGNATURE_SIZE;
-
-export function getSlotFromSignedBeaconBlockSerialized(data: Uint8Array): Slot | null {
-  if (data.length < SLOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK + SLOT_SIZE) {
-    return null;
-  }
-
-  return getSlotFromOffset(data, SLOT_BYTES_POSITION_IN_SIGNED_BEACON_BLOCK);
-}
-
-/**
- * class BlobSidecar(Container):
- *  index: BlobIndex [fixed - 8 bytes ],
- *  blob: Blob, BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB
- *  kzgCommitment: Bytes48,
- *  kzgProof: Bytes48,
- *  signedBlockHeader:
- *    slot: 8 bytes
- */
-
-const SLOT_BYTES_POSITION_IN_SIGNED_BLOB_SIDECAR = 8 + BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB + 48 + 48;
-
-export function getSlotFromBlobSidecarSerialized(data: Uint8Array): Slot | null {
-  if (data.length < SLOT_BYTES_POSITION_IN_SIGNED_BLOB_SIDECAR + SLOT_SIZE) {
-    return null;
-  }
-
-  return getSlotFromOffset(data, SLOT_BYTES_POSITION_IN_SIGNED_BLOB_SIDECAR);
-}
-
-/**
- * {
-    index: ColumnIndex [ fixed - 8 bytes],
-    column: DataColumn BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_CELL * <some non fixed length>,
-    kzgCommitments: denebSsz.BlobKzgCommitments,
-    kzgProofs: denebSsz.KZGProofs,
-    signedBlockHeader: phase0Ssz.SignedBeaconBlockHeader,
-    kzgCommitmentsInclusionProof: KzgCommitmentsInclusionProof,
-  }
- */
-
-const SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR = 20;
-export function getSlotFromDataColumnSidecarSerialized(data: Uint8Array): Slot | null {
-  if (data.length < SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR + SLOT_SIZE) {
-    return null;
-  }
-
-  return getSlotFromOffset(data, SLOT_BYTES_POSITION_IN_SIGNED_DATA_COLUMN_SIDECAR);
-}
-
-/**
- * Read only the first 4 bytes of Slot, max value is 4,294,967,295 will be reached 1634 years after genesis
- *
- * If the high bytes are not zero, return null
- */
-function getSlotFromOffset(data: Uint8Array, offset: number): Slot | null {
-  return checkSlotHighBytes(data, offset) ? getSlotFromOffsetTrusted(data, offset) : null;
-}
-
-/**
- * Alias of `getSlotFromOffset` for readability
- */
-function getIndexFromOffset(data: Uint8Array, offset: number): (ValidatorIndex | CommitteeIndex) | null {
-  return getSlotFromOffset(data, offset);
-}
-
-/**
- * Read only the first 4 bytes of Slot, max value is 4,294,967,295 will be reached 1634 years after genesis
- */
-function getSlotFromOffsetTrusted(data: Uint8Array, offset: number): Slot {
-  return (data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24)) >>> 0;
-}
-
-function checkSlotHighBytes(data: Uint8Array, offset: number): boolean {
-  return (data[offset + 4] | data[offset + 5] | data[offset + 6] | data[offset + 7]) === 0;
-}
-
-export function getBlobKzgCommitmentsCountFromSignedBeaconBlockSerialized(
-  config: ChainForkConfig,
-  blockBytes: Uint8Array
-): number {
-  const slot = getSlotFromSignedBeaconBlockSerialized(blockBytes);
-  if (!slot) throw new Error("Can not parse the slot from block bytes");
-
-  if (config.getForkSeq(slot) < ForkSeq.deneb) return 0;
-
-  const {SignedBeaconBlock, BeaconBlock, BeaconBlockBody, KZGCommitment} =
-    ssz[config.getForkName(slot) as ForkPostDeneb];
-
-  const view = new DataView(blockBytes.buffer, blockBytes.byteOffset, blockBytes.byteLength);
-  const singedBlockFieldRanges = SignedBeaconBlock.getFieldRanges(view, 0, blockBytes.length);
-  const messageIndex = Object.keys(SignedBeaconBlock.fields).indexOf("message");
-  const messageRange = singedBlockFieldRanges[messageIndex];
-
-  const blockFieldRanges = BeaconBlock.getFieldRanges(view, messageRange.start, messageRange.end);
-  const bodyIndex = Object.keys(BeaconBlock.fields).indexOf("body");
-  const bodyRange = blockFieldRanges[bodyIndex];
-
-  const bodyFieldRanges = BeaconBlockBody.getFieldRanges(
-    view,
-    messageRange.start + bodyRange.start,
-    messageRange.end + bodyRange.end
-  );
-  const kzgCommitmentsIndex = Object.keys(BeaconBlockBody.fields).indexOf("blobKzgCommitments");
-  const kzgCommitmentsRange = bodyFieldRanges[kzgCommitmentsIndex];
-  const commitmentSize = KZGCommitment.fixedSize;
-
-  const end = messageRange.end + bodyRange.end + kzgCommitmentsRange.end;
-  const start = messageRange.start + bodyRange.start + kzgCommitmentsRange.start;
-
-  return Math.round(((end > blockBytes.byteLength ? blockBytes.byteLength : end) - start) / commitmentSize);
-}

package/src/util/strictEvents.ts

@@ -1,8 +0,0 @@
-/**
- * Simplified version of `strict-event-emitter-types` where each event only emits one argument
- */
-export type StrictEventEmitterSingleArg<EventData> = {
-  on<K extends keyof EventData>(event: K, listener: (data: EventData[K]) => void): void;
-  off<K extends keyof EventData>(event: K, listener: (data: EventData[K]) => void): void;
-  emit<K extends keyof EventData>(event: K, data: EventData[K]): void;
-};

package/src/util/time.ts

@@ -1,13 +0,0 @@
-/**
- * Render a time difference in human readable form
- */
-export function prettyTimeDiffSec(secDiff: number): string {
-  const minDiff = secDiff / 60;
-  const hourDiff = minDiff / 60;
-  const daysDiff = hourDiff / 24;
-
-  if (daysDiff > 1) return `${+daysDiff.toPrecision(2)} days`;
-  if (hourDiff > 1) return `${+hourDiff.toPrecision(2)} hours`;
-  if (minDiff > 1) return `${+minDiff.toPrecision(2)} minutes`;
-  return `${+secDiff.toPrecision(2)} seconds`;
-}

package/src/util/timeSeries.ts

@@ -1,118 +0,0 @@
-type Point = [number, number]; // [x, y] or here [time, value]
-
-export class TimeSeries {
-  private points: Point[] = [];
-  private startTimeSec: number;
-  private maxPoints: number;
-
-  constructor(opts?: {maxPoints?: number}) {
-    this.maxPoints = opts?.maxPoints ?? 1000;
-    this.startTimeSec = Date.now() / 1000;
-  }
-
-  /** Add TimeSeries entry for value at current time */
-  addPoint(value: number, timeSec = Math.floor(Date.now() / 1000)): void {
-    // Substract initial time so x values are not big and cause rounding errors
-    const time = timeSec - this.startTimeSec;
-    this.points.push([time, value]);
-
-    // Limit length by removing old entries
-    while (this.points.length > this.maxPoints) {
-      this.points.shift();
-    }
-  }
-
-  /** Compute the slope of all registered points assuming linear regression */
-  computeLinearSpeed(): number {
-    return linearRegression(this.points).m;
-  }
-
-  /**
-   * Compute x point at which y = 0.
-   * From eq `y = b + m*x` then solve for `0 = b + m*x`
-   */
-  computeY0Point(): number {
-    const {m, b} = linearRegression(this.points);
-    // The X cordinate system has been shifted left by startTimeSec, so return the
-    // projection in original coordinated system
-    return -b / m + this.startTimeSec;
-  }
-
-  /** Remove all entries */
-  clear(): void {
-    this.points = [];
-  }
-
-  numPoints(): number {
-    return this.points.length;
-  }
-}
-
-/**
- * From https://github.com/simple-statistics/simple-statistics/blob/d0d177baf74976a2421638bce98ab028c5afb537/src/linear_regression.js
- *
- * [Simple linear regression](http://en.wikipedia.org/wiki/Simple_linear_regression)
- * is a simple way to find a fitted line between a set of coordinates.
- * This algorithm finds the slope and y-intercept of a regression line
- * using the least sum of squares.
- *
- * @param data an array of two-element of arrays,
- * like `[[0, 1], [2, 3]]`
- * @returns object containing slope and intersect of regression line
- * @example
- * linearRegression([[0, 0], [1, 1]]); // => { m: 1, b: 0 }
- */
-function linearRegression(data: Point[]): {m: number; b: number} {
-  let m: number, b: number;
-
-  // Store data length in a local variable to reduce
-  // repeated object property lookups
-  const dataLength = data.length;
-
-  //if there's only one point, arbitrarily choose a slope of 0
-  //and a y-intercept of whatever the y of the initial point is
-  if (dataLength === 1) {
-    m = 0;
-    b = data[0][1];
-  } else {
-    // Initialize our sums and scope the `m` and `b`
-    // variables that define the line.
-    let sumX = 0,
-      sumY = 0,
-      sumXX = 0,
-      sumXY = 0;
-
-    // Use local variables to grab point values
-    // with minimal object property lookups
-    let point: Point, x: number, y: number;
-
-    // Gather the sum of all x values, the sum of all
-    // y values, and the sum of x^2 and (x*y) for each
-    // value.
-    //
-    // In math notation, these would be SS_x, SS_y, SS_xx, and SS_xy
-    for (let i = 0; i < dataLength; i++) {
-      point = data[i];
-      x = point[0];
-      y = point[1];
-
-      sumX += x;
-      sumY += y;
-
-      sumXX += x * x;
-      sumXY += x * y;
-    }
-
-    // `m` is the slope of the regression line
-    m = (dataLength * sumXY - sumX * sumY) / (dataLength * sumXX - sumX * sumX);
-
-    // `b` is the y-intercept of the line.
-    b = sumY / dataLength - (m * sumX) / dataLength;
-  }
-
-  // Return both values as an object.
-  return {
-    m: m,
-    b: b,
-  };
-}

package/src/util/types.ts

@@ -1,31 +0,0 @@
-import {ContainerType, ListCompositeType, ValueOf} from "@chainsafe/ssz";
-import {BeaconConfig} from "@lodestar/config";
-import {ForkName, isForkPostDeneb, isForkPostElectra} from "@lodestar/params";
-import {ssz} from "@lodestar/types";
-
-// Misc SSZ types used only in the beacon-node package, no need to upstream to types
-
-export const signedBLSToExecutionChangeVersionedType = new ContainerType(
-  {
-    // Assumes less than 256 forks, sounds reasonable in our lifetime
-    preCapella: ssz.Boolean,
-    data: ssz.capella.SignedBLSToExecutionChange,
-  },
-  {jsonCase: "eth2", typeName: "SignedBLSToExecutionChangeVersionedType"}
-);
-export type SignedBLSToExecutionChangeVersioned = ValueOf<typeof signedBLSToExecutionChangeVersionedType>;
-
-export const BeaconBlocksByRootRequestType = (fork: ForkName, config: BeaconConfig) =>
-  new ListCompositeType(ssz.Root, isForkPostDeneb(fork) ? config.MAX_REQUEST_BLOCKS_DENEB : config.MAX_REQUEST_BLOCKS);
-export type BeaconBlocksByRootRequest = ValueOf<ReturnType<typeof BeaconBlocksByRootRequestType>>;
-
-export const BlobSidecarsByRootRequestType = (fork: ForkName, config: BeaconConfig) =>
-  new ListCompositeType(
-    ssz.deneb.BlobIdentifier,
-    isForkPostElectra(fork) ? config.MAX_REQUEST_BLOB_SIDECARS_ELECTRA : config.MAX_REQUEST_BLOB_SIDECARS
-  );
-export type BlobSidecarsByRootRequest = ValueOf<ReturnType<typeof BlobSidecarsByRootRequestType>>;
-
-export const DataColumnSidecarsByRootRequestType = (config: BeaconConfig) =>
-  new ListCompositeType(ssz.fulu.DataColumnsByRootIdentifier, config.MAX_REQUEST_BLOCKS_DENEB);
-export type DataColumnSidecarsByRootRequest = ValueOf<ReturnType<typeof DataColumnSidecarsByRootRequestType>>;