@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/util/sszBytes.ts

@@ -0,0 +1,481 @@
+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

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+/**
+ * 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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,31 @@
+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>>;