Trace invalid blocks in unviable quarantine

A block may become unviable for two main reasons:

* the fork it was on is orphaned by chain finality - ie the block was
valid in some history, but not any more in the canonical one
* the block is invalid, either because it is itself invalid or it builds
on an invalid block

Until now we've treated both kinds the same when it comes to the
`unviable` quarantine - because of this, when checking gossip rules the
client has in some cases opted for the more lenient "IGNORE" respons
instead of using "REJECT".

This PR brings the client more closely in line with ignore/reject rules
by tracking the original error that led to the unviablility.

* use `minilru` instead of `OrderedTable` for simplified capacity
management and performance
* simplify quarantine operations that deal with unviables
* remove unused quarantine events
* keep track of the block being processed to avoid it being readded to
the quarantine during processing

Author: arnetheduck

beacon_chain.nimble

@@ -14,7 +14,6 @@ license       = "MIT or Apache License 2.0"
 
 requires(
   "nim == 2.2.4",
-  "https://github.com/status-im/NimYAML",
   "bearssl",
   "blscurve",
   "chronicles",
@@ -28,6 +27,7 @@ requires(
   "libbacktrace",
   "libp2p",
   "metrics",
+  "minilru",
   "nat_traversal",
   "nimcrypto",
   "normalize",
@@ -41,11 +41,12 @@ requires(
   "stint",
   "taskpools",
   "testutils",
+  "toml_serialization",
   "unicodedb >= 0.10",
   "unittest2",
+  "yaml",
   "web3",
   "zlib",
-  "toml_serialization",
   "https://github.com/status-im/nim-kzg4844.git",
   "zxcvbn"
 )

beacon_chain/consensus_object_pools/attestation_pool.nim

@@ -953,19 +953,23 @@ proc getBeaconHead*(
 proc selectOptimisticHead*(
     pool: var AttestationPool, wallTime: BeaconTime): Opt[BeaconHead] =
   ## Trigger fork choice and returns the new head block.
-  let newHeadRoot = pool.forkChoice.get_head(pool.dag, wallTime)
-  if newHeadRoot.isErr:
-    error "Couldn't select head", err = newHeadRoot.error
-    return err()
+  let newHeadRoot = pool.forkChoice.get_head(pool.dag, wallTime).valueOr:
+    error "Couldn't select head", err = error
+    return Opt.none(BeaconHead)
 
-  let headBlock = pool.dag.getBlockRef(newHeadRoot.get()).valueOr:
+  let headBlock = pool.dag.getBlockRef(newHeadRoot).valueOr:
     # This should normally not happen, but if the chain dag and fork choice
     # get out of sync, we'll need to try to download the selected head - in
     # the meantime, return nil to indicate that no new head was chosen
-    warn "Fork choice selected unknown head, trying to sync",
-      root = newHeadRoot.get()
-    pool.quarantine[].addMissing(newHeadRoot.get())
-    return err()
+
+    pool.quarantine[].addMissing(newHeadRoot).isOkOr:
+      # The newly selected head is unviable for some reason - the only way out
+      # here is that fork choice gets information about some other head
+      warn "Fork choice selected unviable head - cannot sync", newHeadRoot, err = error
+      return Opt.none(BeaconHead)
+
+    warn "Fork choice selected unknown head, trying to sync", newHeadRoot
+    return Opt.none(BeaconHead)
 
   ok pool.getBeaconHead(headBlock)