@lodestar/state-transition 1.46.0-dev.ba5ee9aff0 → 1.46.0-dev.ba701016f3

package/src/util/clock.ts

@@ -0,0 +1,183 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {GENESIS_SLOT, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {Epoch, Slot, TimeSeconds} from "@lodestar/types";
+import {ErrorAborted, Logger, isErrorAborted, sleep} from "@lodestar/utils";
+import {computeEpochAtSlot} from "./epoch.js";
+import {computeTimeAtSlot, getCurrentSlot} from "./slot.js";
+
+type RunEveryFn = (slot: Slot, signal: AbortSignal) => Promise<void>;
+
+export type ClockOptions = {
+  skipSlots?: boolean;
+};
+
+export interface IClock {
+  readonly genesisTime: number;
+  readonly secondsPerSlot: number;
+
+  readonly currentEpoch: number;
+
+  start(signal: AbortSignal): void;
+  runEverySlot(fn: (slot: Slot, signal: AbortSignal) => Promise<void>): void;
+  runEveryEpoch(fn: (epoch: Epoch, signal: AbortSignal) => Promise<void>): void;
+  msToSlot(slot: Slot): number;
+  msFromSlot(slot: Slot): number;
+  secFromSlot(slot: Slot): number;
+  getCurrentSlot(): Slot;
+  getCurrentEpoch(): Epoch;
+}
+
+export enum TimeItem {
+  Slot,
+  Epoch,
+}
+
+export class Clock implements IClock {
+  readonly genesisTime: number;
+  readonly secondsPerSlot: number;
+  private readonly config: ChainForkConfig;
+  private readonly logger: Logger;
+  private readonly fns: {timeItem: TimeItem; fn: RunEveryFn}[] = [];
+
+  constructor(
+    config: ChainForkConfig,
+    logger: Logger,
+    private readonly opts: {genesisTime: number} & ClockOptions
+  ) {
+    this.genesisTime = opts.genesisTime;
+    this.secondsPerSlot = config.SLOT_DURATION_MS / 1000;
+    this.config = config;
+    this.logger = logger;
+  }
+
+  get currentEpoch(): Epoch {
+    return computeEpochAtSlot(getCurrentSlot(this.config, this.genesisTime));
+  }
+
+  start(signal: AbortSignal): void {
+    for (const {timeItem, fn} of this.fns) {
+      this.runAtMostEvery(timeItem, signal, fn).catch((e: Error) => {
+        if (!isErrorAborted(e)) {
+          this.logger.error("runAtMostEvery", {}, e);
+        }
+      });
+    }
+  }
+
+  getCurrentSlot(): Slot {
+    return getCurrentSlot(this.config, this.genesisTime);
+  }
+
+  getCurrentEpoch(): Epoch {
+    return computeEpochAtSlot(getCurrentSlot(this.config, this.genesisTime));
+  }
+
+  runEverySlot(fn: RunEveryFn): void {
+    this.fns.push({timeItem: TimeItem.Slot, fn});
+  }
+
+  runEveryEpoch(fn: RunEveryFn): void {
+    this.fns.push({timeItem: TimeItem.Epoch, fn});
+  }
+
+  /** Milliseconds from now to a specific slot */
+  msToSlot(slot: Slot): number {
+    return computeTimeAtSlot(this.config, slot, this.genesisTime) * 1000 - Date.now();
+  }
+
+  /** Milliseconds elapsed from a specific slot to now */
+  msFromSlot(slot: Slot): number {
+    return Date.now() - computeTimeAtSlot(this.config, slot, this.genesisTime) * 1000;
+  }
+
+  /** Seconds elapsed from a specific slot to now */
+  secFromSlot(slot: Slot): number {
+    return Date.now() / 1000 - computeTimeAtSlot(this.config, slot, this.genesisTime);
+  }
+
+  /**
+   * If a task happens to take more than one slot to run, we might skip a slot. This is unfortunate,
+   * however the alternative is to *always* process every slot, which has the chance of creating a
+   * theoretically unlimited backlog of tasks. It was a conscious decision to choose to drop tasks
+   * on an overloaded/latent system rather than overload it even more.
+   */
+  private async runAtMostEvery(timeItem: TimeItem, signal: AbortSignal, fn: RunEveryFn): Promise<void> {
+    // Run immediately first
+    let slot = getCurrentSlot(this.config, this.genesisTime);
+    let slotOrEpoch = timeItem === TimeItem.Slot ? slot : computeEpochAtSlot(slot);
+    while (!signal.aborted) {
+      // Must catch fn() to ensure `sleep()` is awaited both for resolve and reject
+      const task = fn(slotOrEpoch, signal).catch((e: Error) => {
+        if (!isErrorAborted(e)) this.logger.error("Error on runEvery fn", {}, e);
+      });
+
+      if (timeItem !== TimeItem.Slot || this.opts.skipSlots !== false) {
+        // await response to only continue with next task if current task finished within slot
+        await task;
+      }
+
+      try {
+        await sleep(this.timeUntilNext(timeItem), signal);
+        // calling getCurrentSlot here may not be correct when we're close to the next slot
+        // it's safe to call getCurrentSlotAround after we sleep
+        const nextSlot = getCurrentSlotAround(this.config, this.genesisTime);
+
+        if (timeItem === TimeItem.Slot) {
+          if (nextSlot > slot + 1) {
+            // It's not very likely that we skip more than one slot as HTTP timeout is set
+            // to SLOT_DURATION_MS so we will fail task before skipping another slot.
+            this.logger.warn("Skipped slot due to task taking more than one slot to run", {
+              skippedSlot: slot + 1,
+            });
+          }
+          slotOrEpoch = nextSlot;
+        } else {
+          slotOrEpoch = computeEpochAtSlot(nextSlot);
+        }
+        slot = nextSlot;
+      } catch (e) {
+        if (e instanceof ErrorAborted) {
+          return;
+        }
+        throw e;
+      }
+    }
+  }
+
+  private timeUntilNext(timeItem: TimeItem): number {
+    const milliSecondsPerSlot = this.config.SLOT_DURATION_MS;
+    const msFromGenesis = Date.now() - this.genesisTime * 1000;
+
+    if (timeItem === TimeItem.Slot) {
+      if (msFromGenesis >= 0) {
+        return milliSecondsPerSlot - (msFromGenesis % milliSecondsPerSlot);
+      }
+      return Math.abs(msFromGenesis) % milliSecondsPerSlot;
+    }
+    const milliSecondsPerEpoch = SLOTS_PER_EPOCH * milliSecondsPerSlot;
+    if (msFromGenesis >= 0) {
+      return milliSecondsPerEpoch - (msFromGenesis % milliSecondsPerEpoch);
+    }
+    return Math.abs(msFromGenesis) % milliSecondsPerEpoch;
+  }
+}
+
+/**
+ * Same to the spec but we use Math.round instead of Math.floor.
+ */
+export function getCurrentSlotAround(config: ChainForkConfig, genesisTime: TimeSeconds): Slot {
+  const diffInSeconds = Date.now() / 1000 - genesisTime;
+  const slotsSinceGenesis = Math.round((diffInSeconds * 1000) / config.SLOT_DURATION_MS);
+  return GENESIS_SLOT + slotsSinceGenesis;
+}
+
+// function useEventStream() {
+//   this.stream = this.events.getEventStream([BeaconEventType.BLOCK, BeaconEventType.HEAD, BeaconEventType.CHAIN_REORG]);
+//   pipeToEmitter(this.stream, this).catch((e: Error) => {
+//     this.logger.error("Error on stream pipe", {}, e);
+//   });
+
+//   // On stop
+//   this.stream.stop();
+//   this.stream = null;
+// }

package/src/util/gloas.ts

@@ -87,15 +87,19 @@ export function isActiveBuilder(builder: gloas.Builder, finalizedEpoch: Epoch):
  * From https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md
  */
 export function getExpectedGasLimit(parentGasLimit: number, targetGasLimit: number): number {
-  const maxGasLimitDifference = Math.max(Math.floor(parentGasLimit / 1024), 1) - 1;
+  return Number(getExpectedGasLimitBigint(BigInt(parentGasLimit), BigInt(targetGasLimit)));
+}
+
+export function getExpectedGasLimitBigint(parentGasLimit: bigint, targetGasLimit: bigint): bigint {
+  const maxGasLimitDifference = (parentGasLimit / 1024n > 1n ? parentGasLimit / 1024n : 1n) - 1n;
 
   if (targetGasLimit > parentGasLimit) {
     const gasDiff = targetGasLimit - parentGasLimit;
-    return parentGasLimit + Math.min(gasDiff, maxGasLimitDifference);
+    return parentGasLimit + (gasDiff < maxGasLimitDifference ? gasDiff : maxGasLimitDifference);
   }
 
   const gasDiff = parentGasLimit - targetGasLimit;
-  return parentGasLimit - Math.min(gasDiff, maxGasLimitDifference);
+  return parentGasLimit - (gasDiff < maxGasLimitDifference ? gasDiff : maxGasLimitDifference);
 }
 
 /**
@@ -104,8 +108,8 @@ export function getExpectedGasLimit(parentGasLimit: number, targetGasLimit: numb
  * adjustment step of the parent, otherwise it must hit the clamped boundary.
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.8/specs/gloas/builder.md#new-is_gas_limit_target_compatible
  */
-export function isGasLimitTargetCompatible(parentGasLimit: number, gasLimit: number, targetGasLimit: number): boolean {
-  return gasLimit === getExpectedGasLimit(parentGasLimit, targetGasLimit);
+export function isGasLimitTargetCompatible(parentGasLimit: bigint, gasLimit: bigint, targetGasLimit: bigint): boolean {
+  return gasLimit === getExpectedGasLimitBigint(parentGasLimit, targetGasLimit);
 }
 
 /**

package/src/util/index.ts

@@ -6,6 +6,7 @@ export * from "./balance.js";
 export * from "./blindedBlock.js";
 export * from "./blockRoot.js";
 export * from "./capella.js";
+export * from "./clock.js";
 export * from "./computeAnchorCheckpoint.js";
 export * from "./deposit.js";
 export * from "./domain.js";