BeaconStateFork/BeaconBlockFork -> ConsensusFork (status-im#4560)

* `BeaconStateFork/BeaconBlockFork` -> `ConsensusFork`

* revert unrelated change

* revert unrelated changes

* update test summaries

AllTests-mainnet.md

@@ -508,6 +508,11 @@ OK: 4/4 Fail: 0/4 Skip: 0/4
 + [SyncQueue] hasEndGap() test                                                               OK
 ```
 OK: 23/23 Fail: 0/23 Skip: 0/23
+## Type helpers
+```diff
++ BeaconBlockType                                                                            OK
+```
+OK: 1/1 Fail: 0/1 Skip: 0/1
 ## Validator change pool testing suite
 ```diff
 + addValidatorChangeMessage/getAttesterSlashingMessage                                       OK
@@ -623,4 +628,4 @@ OK: 2/2 Fail: 0/2 Skip: 0/2
 OK: 9/9 Fail: 0/9 Skip: 0/9
 
 ---TOTAL---
-OK: 348/353 Fail: 0/353 Skip: 5/353
+OK: 349/354 Fail: 0/354 Skip: 5/354

beacon_chain/beacon_chain_db.nim

@@ -111,13 +111,13 @@ type
     checkpoint*: proc() {.gcsafe, raises: [Defect].}
 
     keyValues: KvStoreRef # Random stuff using DbKeyKind - suitable for small values mainly!
-    blocks: array[BeaconBlockFork, KvStoreRef] # BlockRoot -> TrustedSignedBeaconBlock
+    blocks: array[ConsensusFork, KvStoreRef] # BlockRoot -> TrustedSignedBeaconBlock
 
     blobs: KvStoreRef # (BlockRoot -> BlobsSidecar)
 
     stateRoots: KvStoreRef # (Slot, BlockRoot) -> StateRoot
 
-    statesNoVal: array[BeaconStateFork, KvStoreRef] # StateRoot -> ForkBeaconStateNoImmutableValidators
+    statesNoVal: array[ConsensusFork, KvStoreRef] # StateRoot -> ForkBeaconStateNoImmutableValidators
 
     stateDiffs: KvStoreRef ##\
       ## StateRoot -> BeaconStateDiff
@@ -851,7 +851,7 @@ proc putState*(db: BeaconChainDB, state: ForkyHashedBeaconState) =
 
 # For testing rollback
 proc putCorruptState*(
-    db: BeaconChainDB, fork: static BeaconStateFork, key: Eth2Digest) =
+    db: BeaconChainDB, fork: static ConsensusFork, key: Eth2Digest) =
   db.statesNoVal[fork].putSnappySSZ(key.data, Validator())
 
 func stateRootKey(root: Eth2Digest, slot: Slot): array[40, byte] =
@@ -869,20 +869,20 @@ proc putStateRoot*(db: BeaconChainDB, root: Eth2Digest, slot: Slot,
 proc putStateDiff*(db: BeaconChainDB, root: Eth2Digest, value: BeaconStateDiff) =
   db.stateDiffs.putSnappySSZ(root.data, value)
 
-proc delBlock*(db: BeaconChainDB, fork: BeaconBlockFork, key: Eth2Digest): bool =
+proc delBlock*(db: BeaconChainDB, fork: ConsensusFork, key: Eth2Digest): bool =
   var deleted = false
   db.withManyWrites:
     discard db.summaries.del(key.data).expectDb()
     deleted = db.blocks[fork].del(key.data).expectDb()
   deleted
 
-proc delState*(db: BeaconChainDB, fork: BeaconStateFork, key: Eth2Digest) =
+proc delState*(db: BeaconChainDB, fork: ConsensusFork, key: Eth2Digest) =
   discard db.statesNoVal[fork].del(key.data).expectDb()
 
-proc clearBlocks*(db: BeaconChainDB, fork: BeaconBlockFork) =
+proc clearBlocks*(db: BeaconChainDB, fork: ConsensusFork) =
   discard db.blocks[fork].clear().expectDb()
 
-proc clearStates*(db: BeaconChainDB, fork: BeaconStateFork) =
+proc clearStates*(db: BeaconChainDB, fork: ConsensusFork) =
   discard db.statesNoVal[fork].clear().expectDb()
 
 proc delKeyValue*(db: BeaconChainDB, key: array[1, byte]) =
@@ -1021,7 +1021,7 @@ proc getBlockSSZ*(
   func decode(data: openArray[byte]) =
     try: dataPtr[] = snappy.decode(data, maxDecompressedDbRecordSize)
     except CatchableError: success = false
-  db.blocks[BeaconBlockFork.Phase0].get(key.data, decode).expectDb() and success or
+  db.blocks[ConsensusFork.Phase0].get(key.data, decode).expectDb() and success or
     db.v0.getPhase0BlockSSZ(key, data)
 
 proc getBlockSSZ*(
@@ -1047,17 +1047,17 @@ proc getBlockSSZ*[
 
 proc getBlockSSZ*(
     db: BeaconChainDB, key: Eth2Digest, data: var seq[byte],
-    fork: BeaconBlockFork): bool =
+    fork: ConsensusFork): bool =
   case fork
-  of BeaconBlockFork.Phase0:
+  of ConsensusFork.Phase0:
     getBlockSSZ(db, key, data, phase0.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.Altair:
+  of ConsensusFork.Altair:
     getBlockSSZ(db, key, data, altair.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.Bellatrix:
+  of ConsensusFork.Bellatrix:
     getBlockSSZ(db, key, data, bellatrix.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.Capella:
+  of ConsensusFork.Capella:
     getBlockSSZ(db, key, data, capella.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.EIP4844:
+  of ConsensusFork.EIP4844:
     getBlockSSZ(db, key, data, eip4844.TrustedSignedBeaconBlock)
 
 
@@ -1077,7 +1077,7 @@ proc getBlockSZ*(
     try: dataPtr[] = snappy.encodeFramed(
       snappy.decode(data, maxDecompressedDbRecordSize))
     except CatchableError: success = false
-  db.blocks[BeaconBlockFork.Phase0].get(key.data, decode).expectDb() and success or
+  db.blocks[ConsensusFork.Phase0].get(key.data, decode).expectDb() and success or
     db.v0.getPhase0BlockSZ(key, data)
 
 proc getBlockSZ*(
@@ -1102,17 +1102,17 @@ proc getBlockSZ*[
 
 proc getBlockSZ*(
     db: BeaconChainDB, key: Eth2Digest, data: var seq[byte],
-    fork: BeaconBlockFork): bool =
+    fork: ConsensusFork): bool =
   case fork
-  of BeaconBlockFork.Phase0:
+  of ConsensusFork.Phase0:
     getBlockSZ(db, key, data, phase0.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.Altair:
+  of ConsensusFork.Altair:
     getBlockSZ(db, key, data, altair.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.Bellatrix:
+  of ConsensusFork.Bellatrix:
     getBlockSZ(db, key, data, bellatrix.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.Capella:
+  of ConsensusFork.Capella:
     getBlockSZ(db, key, data, capella.TrustedSignedBeaconBlock)
-  of BeaconBlockFork.EIP4844:
+  of ConsensusFork.EIP4844:
     getBlockSZ(db, key, data, eip4844.TrustedSignedBeaconBlock)
 
 proc getStateOnlyMutableValidators(
@@ -1301,7 +1301,7 @@ proc getState*(
     rollback)
 
 proc getState*(
-    db: BeaconChainDB, fork: BeaconStateFork, state_root: Eth2Digest,
+    db: BeaconChainDB, fork: ConsensusFork, state_root: Eth2Digest,
     state: var ForkedHashedBeaconState, rollback: RollbackProc): bool =
   if state.kind != fork:
     # Avoid temporary (!)
@@ -1368,13 +1368,13 @@ proc containsBlock*[
     db: BeaconChainDB, key: Eth2Digest, T: type X): bool =
   db.blocks[X.toFork].contains(key.data).expectDb()
 
-proc containsBlock*(db: BeaconChainDB, key: Eth2Digest, fork: BeaconBlockFork): bool =
+proc containsBlock*(db: BeaconChainDB, key: Eth2Digest, fork: ConsensusFork): bool =
   case fork
-  of BeaconBlockFork.Phase0: containsBlock(db, key, phase0.TrustedSignedBeaconBlock)
+  of ConsensusFork.Phase0: containsBlock(db, key, phase0.TrustedSignedBeaconBlock)
   else: db.blocks[fork].contains(key.data).expectDb()
 
 proc containsBlock*(db: BeaconChainDB, key: Eth2Digest): bool =
-  for fork in countdown(BeaconBlockFork.high, BeaconBlockFork.low):
+  for fork in countdown(ConsensusFork.high, ConsensusFork.low):
     if db.containsBlock(key, fork): return true
 
   false
@@ -1385,14 +1385,14 @@ proc containsState*(db: BeaconChainDBV0, key: Eth2Digest): bool =
     db.backend.contains(sk).expectDb() or
     db.backend.contains(subkey(phase0.BeaconState, key)).expectDb()
 
-proc containsState*(db: BeaconChainDB, fork: BeaconStateFork, key: Eth2Digest,
+proc containsState*(db: BeaconChainDB, fork: ConsensusFork, key: Eth2Digest,
     legacy: bool = true): bool =
   if db.statesNoVal[fork].contains(key.data).expectDb(): return true
 
-  (legacy and fork == BeaconStateFork.Phase0 and db.v0.containsState(key))
+  (legacy and fork == ConsensusFork.Phase0 and db.v0.containsState(key))
 
 proc containsState*(db: BeaconChainDB, key: Eth2Digest, legacy: bool = true): bool =
-  for fork in countdown(BeaconStateFork.high, BeaconStateFork.low):
+  for fork in countdown(ConsensusFork.high, ConsensusFork.low):
     if db.statesNoVal[fork].contains(key.data).expectDb(): return true
 
   (legacy and db.v0.containsState(key))
@@ -1505,7 +1505,7 @@ iterator getAncestorSummaries*(db: BeaconChainDB, root: Eth2Digest):
 
   # Backwards compat for reading old databases, or those that for whatever
   # reason lost a summary along the way..
-  static: doAssert BeaconBlockFork.high == BeaconBlockFork.EIP4844
+  static: doAssert ConsensusFork.high == ConsensusFork.EIP4844
   while true:
     if db.v0.backend.getSnappySSZ(
         subkey(BeaconBlockSummary, res.root), res.summary) == GetResult.found:

beacon_chain/beacon_node_light_client.nim

@@ -47,9 +47,9 @@ proc initLightClient*(
         dag = node.dag.head.bid,
         wallSlot = node.currentSlot
       withBlck(signedBlock):
-        when stateFork == BeaconStateFork.EIP4844:
+        when stateFork == ConsensusFork.EIP4844:
           debugRaiseAssert $eip4844ImplementationMissing & ": beacon_node_light_client.nim:initLightClient"
-        elif stateFork >= BeaconStateFork.Bellatrix:
+        elif stateFork >= ConsensusFork.Bellatrix:
           if blck.message.is_execution_block:
             template payload(): auto = blck.message.body.execution_payload
 

beacon_chain/consensus_object_pools/attestation_pool.nim

@@ -143,7 +143,7 @@ proc init*(T: type AttestationPool, dag: ChainDAGRef,
           var unrealized: FinalityCheckpoints
           if enableTestFeatures in dag.updateFlags and blckRef == dag.head:
             unrealized = withState(dag.headState):
-              when stateFork >= BeaconStateFork.Altair:
+              when stateFork >= ConsensusFork.Altair:
                 forkyState.data.compute_unrealized_finality()
               else:
                 var cache: StateCache

beacon_chain/consensus_object_pools/block_clearance.nim

@@ -104,8 +104,8 @@ proc addResolvedHeadBlock(
     var unrealized: FinalityCheckpoints
     if enableTestFeatures in dag.updateFlags:
       unrealized = withState(state):
-        static: doAssert high(BeaconStateFork) == BeaconStateFork.EIP4844
-        when stateFork >= BeaconStateFork.Altair:
+        static: doAssert high(ConsensusFork) == ConsensusFork.EIP4844
+        when stateFork >= ConsensusFork.Altair:
           forkyState.data.compute_unrealized_finality()
         else:
           forkyState.data.compute_unrealized_finality(cache)

beacon_chain/consensus_object_pools/blockchain_dag.nim

@@ -142,7 +142,7 @@ func validatorKey*(
 template is_merge_transition_complete*(
     stateParam: ForkedHashedBeaconState): bool =
   withState(stateParam):
-    when stateFork >= BeaconStateFork.Bellatrix:
+    when stateFork >= ConsensusFork.Bellatrix:
       is_merge_transition_complete(forkyState.data)
     else:
       false
@@ -209,7 +209,7 @@ proc getForkedBlock*(db: BeaconChainDB, root: Eth2Digest):
     Opt[ForkedTrustedSignedBeaconBlock] =
   # When we only have a digest, we don't know which fork it's from so we try
   # them one by one - this should be used sparingly
-  static: doAssert high(BeaconBlockFork) == BeaconBlockFork.EIP4844
+  static: doAssert high(ConsensusFork) == ConsensusFork.EIP4844
   if (let blck = db.getBlock(root, eip4844.TrustedSignedBeaconBlock);
       blck.isSome()):
     ok(ForkedTrustedSignedBeaconBlock.init(blck.get()))
@@ -731,7 +731,7 @@ proc currentSyncCommitteeForPeriod*(
     bsi = ? dag.getBlockIdAtSlot(syncCommitteeSlot)
   dag.withUpdatedState(tmpState, bsi) do:
     withState(updatedState):
-      when stateFork >= BeaconStateFork.Altair:
+      when stateFork >= ConsensusFork.Altair:
         ok forkyState.data.current_sync_committee
       else: err()
   do: err()
@@ -857,31 +857,31 @@ proc applyBlock(
   loadStateCache(dag, cache, bid, getStateField(state, slot).epoch)
 
   case dag.cfg.blockForkAtEpoch(bid.slot.epoch)
-  of BeaconBlockFork.Phase0:
+  of ConsensusFork.Phase0:
     let data = getBlock(dag, bid, phase0.TrustedSignedBeaconBlock).valueOr:
       return err("Block load failed")
     state_transition(
       dag.cfg, state, data, cache, info,
       dag.updateFlags + {slotProcessed}, noRollback)
-  of BeaconBlockFork.Altair:
+  of ConsensusFork.Altair:
     let data = getBlock(dag, bid, altair.TrustedSignedBeaconBlock).valueOr:
       return err("Block load failed")
     state_transition(
       dag.cfg, state, data, cache, info,
       dag.updateFlags + {slotProcessed}, noRollback)
-  of BeaconBlockFork.Bellatrix:
+  of ConsensusFork.Bellatrix:
     let data = getBlock(dag, bid, bellatrix.TrustedSignedBeaconBlock).valueOr:
       return err("Block load failed")
     state_transition(
       dag.cfg, state, data, cache, info,
       dag.updateFlags + {slotProcessed}, noRollback)
-  of BeaconBlockFork.Capella:
+  of ConsensusFork.Capella:
     let data = getBlock(dag, bid, capella.TrustedSignedBeaconBlock).valueOr:
       return err("Block load failed")
     state_transition(
       dag.cfg, state, data, cache, info,
       dag.updateFlags + {slotProcessed}, noRollback)
-  of BeaconBlockFork.EIP4844:
+  of ConsensusFork.EIP4844:
     let data = getBlock(dag, bid, eip4844.TrustedSignedBeaconBlock).valueOr:
       return err("Block load failed")
     state_transition(
@@ -1034,11 +1034,11 @@ proc init*(T: type ChainDAGRef, cfg: RuntimeConfig, db: BeaconChainDB,
 
   let
     configFork = case dag.headState.kind
-      of BeaconStateFork.Phase0: genesisFork(cfg)
-      of BeaconStateFork.Altair: altairFork(cfg)
-      of BeaconStateFork.Bellatrix: bellatrixFork(cfg)
-      of BeaconStateFork.Capella: capellaFork(cfg)
-      of BeaconStateFork.EIP4844: eip4844Fork(cfg)
+      of ConsensusFork.Phase0: genesisFork(cfg)
+      of ConsensusFork.Altair: altairFork(cfg)
+      of ConsensusFork.Bellatrix: bellatrixFork(cfg)
+      of ConsensusFork.Capella: capellaFork(cfg)
+      of ConsensusFork.EIP4844: eip4844Fork(cfg)
     stateFork = getStateField(dag.headState, fork)
 
   if stateFork != configFork:
@@ -1165,7 +1165,7 @@ proc init*(T: type ChainDAGRef, cfg: RuntimeConfig, db: BeaconChainDB,
   dag.updateValidatorKeys(getStateField(dag.headState, validators).asSeq())
 
   withState(dag.headState):
-    when stateFork >= BeaconStateFork.Altair:
+    when stateFork >= ConsensusFork.Altair:
       dag.headSyncCommittees = forkyState.data.get_sync_committee_cache(cache)
 
   info "Block DAG initialized",
@@ -1184,7 +1184,7 @@ proc init*(T: type ChainDAGRef, cfg: RuntimeConfig, db: BeaconChainDB,
 
   # If these aren't actually optimistic, the first fcU will resolve that
   withState(dag.headState):
-    when stateFork >= BeaconStateFork.Bellatrix:
+    when stateFork >= ConsensusFork.Bellatrix:
       template executionPayloadHeader(): auto =
         forkyState().data.latest_execution_payload_header
       const emptyExecutionPayloadHeader =
@@ -1700,7 +1700,7 @@ iterator syncSubcommitteePairs*(
 func syncCommitteeParticipants*(dag: ChainDAGRef,
                                 slot: Slot): seq[ValidatorIndex] =
   withState(dag.headState):
-    when stateFork >= BeaconStateFork.Altair:
+    when stateFork >= ConsensusFork.Altair:
       let
         period = sync_committee_period(slot)
         curPeriod = sync_committee_period(forkyState.data.slot)
@@ -1730,7 +1730,7 @@ func getSubcommitteePositions*(
     subcommitteeIdx: SyncSubcommitteeIndex,
     validatorIdx: uint64): seq[uint64] =
   withState(dag.headState):
-    when stateFork >= BeaconStateFork.Altair:
+    when stateFork >= ConsensusFork.Altair:
       let
         period = sync_committee_period(slot)
         curPeriod = sync_committee_period(forkyState.data.slot)
@@ -1920,25 +1920,25 @@ proc pruneHistory*(dag: ChainDAGRef, startup = false) =
       # pruned easily by fork)
 
       let stateFork = dag.cfg.stateForkAtEpoch(tailSlot.epoch)
-      if stateFork > BeaconStateFork.Phase0:
-        for fork in BeaconStateFork.Phase0..<stateFork:
+      if stateFork > ConsensusFork.Phase0:
+        for fork in ConsensusFork.Phase0..<stateFork:
           dag.db.clearStates(fork)
 
       let blockFork = dag.cfg.blockForkAtEpoch(blockHorizon.epoch)
 
-      if blockFork > BeaconBlockFork.Phase0:
-        for fork in BeaconBlockFork.Phase0..<blockFork:
+      if blockFork > ConsensusFork.Phase0:
+        for fork in ConsensusFork.Phase0..<blockFork:
           dag.db.clearBlocks(fork)
 
 proc loadExecutionBlockRoot*(dag: ChainDAGRef, bid: BlockId): Eth2Digest =
-  if dag.cfg.blockForkAtEpoch(bid.slot.epoch) < BeaconBlockFork.Bellatrix:
+  if dag.cfg.blockForkAtEpoch(bid.slot.epoch) < ConsensusFork.Bellatrix:
     return ZERO_HASH
 
   let blockData = dag.getForkedBlock(bid).valueOr:
     return ZERO_HASH
 
   withBlck(blockData):
-    when stateFork >= BeaconStateFork.Bellatrix:
+    when stateFork >= ConsensusFork.Bellatrix:
       blck.message.body.execution_payload.block_hash
     else:
       ZERO_HASH
@@ -2012,20 +2012,20 @@ proc updateHead*(
 
   if dag.headState.kind > lastHeadKind:
     case dag.headState.kind
-    of BeaconStateFork.Phase0 .. BeaconStateFork.Bellatrix:
+    of ConsensusFork.Phase0 .. ConsensusFork.Bellatrix:
       discard
-    of BeaconStateFork.Capella:
+    of ConsensusFork.Capella:
       if dag.vanityLogs.onUpgradeToCapella != nil:
         dag.vanityLogs.onUpgradeToCapella()
-    of BeaconStateFork.EIP4844:
+    of ConsensusFork.EIP4844:
       discard
 
   dag.db.putHeadBlock(newHead.root)
 
   updateBeaconMetrics(dag.headState, dag.head.bid, cache)
 
   withState(dag.headState):
-    when stateFork >= BeaconStateFork.Altair:
+    when stateFork >= ConsensusFork.Altair:
       dag.headSyncCommittees = forkyState.data.get_sync_committee_cache(cache)
 
   let