common: improve ugly method (#4080)

* common: clean up nextHardforkBlockOrTimestamp method

* remove TODO comment

---------

Co-authored-by: acolytec3 <[email protected]>

Author: ScottyPoi

packages/client/src/sync/fullsync.ts

@@ -250,7 +250,6 @@ export class FullSynchronizer extends Synchronizer {
     if (nextHFBlockNum !== null) {
       const remaining = nextHFBlockNum - last
       if (remaining <= BigInt(10000)) {
-        // TODO: Do something about super-ugly nextHardforkBlockOrTimestamp() method
         const nextHF = this.config.chainCommon.getHardforkBy({ blockNumber: nextHFBlockNum })
         attentionHF = `${nextHF} HF in ${remaining} blocks`
       }

packages/common/src/common.ts

@@ -567,52 +567,60 @@ export class Common {
   }
 
   /**
-   * Returns the change block for the next hardfork after the hardfork provided or set
+   * Returns the block number or timestamp at which the next hardfork will occur.
+   * For pre-merge hardforks, returns the block number.
+   * For post-merge hardforks, returns the timestamp.
+   * Returns null if there is no next hardfork.
    * @param hardfork Hardfork name, optional if HF set
-   * @returns Block timestamp, number or null if not available
+   * @returns Block number or timestamp, or null if not available
    */
   nextHardforkBlockOrTimestamp(hardfork?: string | Hardfork): bigint | null {
-    hardfork = hardfork ?? this._hardfork
+    const targetHardfork = hardfork ?? this._hardfork
     const hfs = this.hardforks()
-    let hfIndex = hfs.findIndex((hf) => hf.name === hardfork)
-    // If the current hardfork is merge, go one behind as merge hf is not part of these
-    // calcs even if the merge hf block is set
-    if (hardfork === Hardfork.Paris) {
-      hfIndex -= 1
-    }
-    // Hardfork not found
-    if (hfIndex < 0) {
+
+    // Find the index of the target hardfork
+    let targetHfIndex = hfs.findIndex((hf) => hf.name === targetHardfork)
+
+    // Special handling for The Merge (Paris) hardfork
+    if (targetHardfork === Hardfork.Paris) {
+      // The Merge is determined by total difficulty, not block number
+      // So we look at the previous hardfork's parameters instead
+      targetHfIndex -= 1
+    }
+
+    // If we couldn't find a valid hardfork index, return null
+    if (targetHfIndex < 0) {
       return null
     }
 
-    let currHfTimeOrBlock = hfs[hfIndex].timestamp ?? hfs[hfIndex].block
-    currHfTimeOrBlock =
-      currHfTimeOrBlock !== null && currHfTimeOrBlock !== undefined
-        ? Number(currHfTimeOrBlock)
-        : null
+    // Get the current hardfork's block/timestamp
+    const currentHf = hfs[targetHfIndex]
+    const currentBlockOrTimestamp = currentHf.timestamp ?? currentHf.block
+    if (currentBlockOrTimestamp === null || currentBlockOrTimestamp === undefined) {
+      return null
+    }
 
-    const nextHf = hfs.slice(hfIndex + 1).find((hf) => {
-      let hfTimeOrBlock = hf.timestamp ?? hf.block
-      hfTimeOrBlock =
-        hfTimeOrBlock !== null && hfTimeOrBlock !== undefined ? Number(hfTimeOrBlock) : null
+    // Find the next hardfork that has a different block/timestamp
+    const nextHf = hfs.slice(targetHfIndex + 1).find((hf) => {
+      const nextBlockOrTimestamp = hf.timestamp ?? hf.block
       return (
-        hf.name !== Hardfork.Paris &&
-        hfTimeOrBlock !== null &&
-        hfTimeOrBlock !== undefined &&
-        hfTimeOrBlock !== currHfTimeOrBlock
+        nextBlockOrTimestamp !== null &&
+        nextBlockOrTimestamp !== undefined &&
+        nextBlockOrTimestamp !== currentBlockOrTimestamp
       )
     })
     // If no next hf found with valid block or timestamp return null
     if (nextHf === undefined) {
       return null
     }
 
-    const nextHfBlock = nextHf.timestamp ?? nextHf.block
-    if (nextHfBlock === null || nextHfBlock === undefined) {
+    // Get the block/timestamp for the next hardfork
+    const nextBlockOrTimestamp = nextHf.timestamp ?? nextHf.block
+    if (nextBlockOrTimestamp === null || nextBlockOrTimestamp === undefined) {
       return null
     }
 
-    return BigInt(nextHfBlock)
+    return BigInt(nextBlockOrTimestamp)
   }
 
   /**