Re-type FilterRef.src as HashKey

why:
  So it is directly comparable to `kMap[$1]`

nimbus/db/aristo/aristo_debug.nim

@@ -403,7 +403,7 @@ proc ppFilter(
  if fl.isNil:
  result &= " n/a"
  return
- result &= pfx & "src=" & fl.src.to(HashKey).ppKey(db)
+ result &= pfx & "src=" & fl.src.ppKey(db)
  result &= pfx & "vGen" & pfx1 & "[" &
  fl.vGen.mapIt(it.ppVid).join(",") & "]"
  result &= pfx & "sTab" & pfx1 & "{"

nimbus/db/aristo/aristo_delta.nim

@@ -13,7 +13,7 @@
 ##
 
 import
- std/[options, sequtils, sets, tables],
+ std/[sequtils, sets, tables],
  eth/common,
  results,
  "."/[aristo_desc, aristo_get, aristo_vid],
@@ -73,14 +73,14 @@ proc deltaMerge*(
  let ubeRoot = block:
  let rc = db.getKeyUbe VertexID(1)
  if rc.isOk:
- rc.value.to(Hash256)
+ rc.value
  elif rc.error == GetKeyNotFound:
- EMPTY_ROOT_HASH
+ VOID_HASH_KEY
  else:
  return err((VertexID(1),rc.error))
 
  db.roFilter = ? db.merge(filter, db.roFilter, ubeRoot)
- if db.roFilter.src == db.roFilter.kMap.getOrVoid(VertexID 1).to(Hash256):
+ if db.roFilter.src == db.roFilter.kMap.getOrVoid(VertexID 1):
  # Under normal conditions, the root keys cannot be the same unless the
  # database is empty. This changes if there is a fixed root vertex as
  # used with the `snap` sync protocol boundaty proof. In that case, there
@@ -142,7 +142,7 @@ proc deltaPersistent*(
 
  let lSst = SavedState(
  src: db.roFilter.src,
- trg: db.roFilter.kMap.getOrVoid(VertexID 1).to(Hash256),
+ trg: db.roFilter.kMap.getOrVoid(VertexID 1),
  serial: nxtFid)
 
  # Store structural single trie entries

nimbus/db/aristo/aristo_delta/delta_merge.nim

@@ -22,7 +22,7 @@ proc merge*(
  db: AristoDbRef;
  upper: FilterRef; # Src filter, `nil` is ok
  lower: FilterRef; # Trg filter, `nil` is ok
- beStateRoot: Hash256; # Merkle hash key
+ beStateRoot: HashKey; # Merkle hash key
  ): Result[FilterRef,(VertexID,AristoError)] =
  ## Merge argument `upper` into the `lower` filter instance.
  ##
@@ -58,7 +58,7 @@ proc merge*(
  return ok(lower)
 
  # Verify stackability
- let lowerTrg = lower.kMap.getOrVoid(VertexID(1)).to(Hash256)
+ let lowerTrg = lower.kMap.getOrVoid VertexID(1)
  if upper.src != lowerTrg:
  return err((VertexID(0), FilTrgSrcMismatch))
  if lower.src != beStateRoot:
@@ -96,7 +96,7 @@ proc merge*(
  return err((vid,rc.error))
 
  # Check consistency
- if (newFilter.src == newFilter.kMap.getOrVoid(VertexID 1).to(Hash256)) !=
+ if (newFilter.src == newFilter.kMap.getOrVoid(VertexID 1)) !=
  (newFilter.sTab.len == 0 and newFilter.kMap.len == 0):
  return err((VertexID(0),FilSrcTrgInconsistent))
 
@@ -123,7 +123,7 @@ proc merge*(
  return err((VertexID(0),FilNilFilterRejected))
 
  # Verify stackability
- let lowerTrg = lower.kMap.getOrVoid(VertexID(1)).to(Hash256)
+ let lowerTrg = lower.kMap.getOrVoid VertexID(1)
  if upper.src != lowerTrg:
  return err((VertexID(0), FilTrgSrcMismatch))
 

nimbus/db/aristo/aristo_delta/delta_reverse.nim

@@ -29,7 +29,7 @@ proc revFilter*(
  ## backend (excluding optionally installed read-only filter.)
  ##
  # Register MPT state roots for reverting back
- let rev = FilterRef(src: filter.kMap.getOrVoid(VertexID 1).to(Hash256))
+ let rev = FilterRef(src: filter.kMap.getOrVoid(VertexID 1))
 
  # Get vid generator state on backend
  block:

nimbus/db/aristo/aristo_delta/delta_siblings.nim

@@ -95,7 +95,7 @@ proc update*(ctx: UpdateSiblingsRef): Result[UpdateSiblingsRef,AristoError] =
  # Update distributed filters. Note that the physical backend database
  # must not have been updated, yet. So the new root key for the backend
  # will be `db.roFilter.kMap[$1]`.
- let trg = db.roFilter.kMap.getOrVoid(VertexID 1).to(Hash256)
+ let trg = db.roFilter.kMap.getOrVoid(VertexID 1)
  for w in db.forked:
  let rc = db.merge(w.roFilter, ctx.rev, trg)
  if rc.isErr:

nimbus/db/aristo/aristo_delta/delta_state_root.nim

@@ -17,8 +17,8 @@ import
 type
  LayerStateRoot* = tuple
  ## Helper structure for analysing state roots.
- be: Hash256 ## Backend state root
- fg: Hash256 ## Layer or filter implied state root
+ be: HashKey ## Backend state root
+ fg: HashKey ## Layer or filter implied state root
 
 # ------------------------------------------------------------------------------
 # Public functions
@@ -42,21 +42,18 @@ proc getLayerStateRoots*(
  VOID_HASH_KEY
  else:
  return err(rc.error)
- spr.be = sprBeKey.to(Hash256)
 
- spr.fg = block:
- let key = delta.kMap.getOrVoid VertexID(1)
- if key.isValid:
- key.to(Hash256)
- else:
- EMPTY_ROOT_HASH
+ spr.be = sprBeKey
+ spr.fg = delta.kMap.getOrVoid VertexID(1)
+
  if spr.fg.isValid:
  return ok(spr)
 
  if not delta.kMap.hasKey(VertexID(1)) and
  not delta.sTab.hasKey(VertexID(1)):
  # This layer is unusable, need both: vertex and key
  return err(FilPrettyPointlessLayer)
+
  elif not delta.sTab.getOrVoid(VertexID(1)).isValid:
  # Root key and vertex has been deleted
  return ok(spr)

nimbus/db/aristo/aristo_desc/desc_identifiers.nim

@@ -159,6 +159,13 @@ func `==`*(a, b: PathID): bool =
 func cmp*(a, b: PathID): int =
  if a < b: -1 elif b < a: 1 else: 0
 
+# ------------------------------------------------------------------------------
+# Public helpers: `HashKey` ordered scalar data model
+# ------------------------------------------------------------------------------
+
+func len*(lid: HashKey): int =
+ lid.len.int # if lid.isHash: 32 else: lid.blob.len
+
 template data*(lid: HashKey): openArray[byte] =
  lid.buf.toOpenArray(0, lid.len - 1)
 
@@ -174,13 +181,6 @@ func to*(lid: HashKey; T: type PathID): T =
  else:
  PathID()
 
-# ------------------------------------------------------------------------------
-# Public helpers: `HashKey` ordered scalar data model
-# ------------------------------------------------------------------------------
-
-func len*(lid: HashKey): int =
- lid.len.int # if lid.isHash: 32 else: lid.blob.len
-
 func fromBytes*(T: type HashKey; data: openArray[byte]): Result[T,void] =
  ## Write argument `data` of length 0 or between 2 and 32 bytes as a `HashKey`.
  ##

nimbus/db/aristo/aristo_desc/desc_structural.nim

@@ -74,13 +74,13 @@ type
 
  SavedState* = object
  ## Last saved state
- src*: Hash256 ## Previous state hash
- trg*: Hash256 ## Last state hash
+ src*: HashKey ## Previous state hash
+ trg*: HashKey ## Last state hash
  serial*: uint64 ## Generic identifier froom application
 
  FilterRef* = ref object
  ## Delta layer
- src*: Hash256 ## Applicable to this state root
+ src*: HashKey ## Applicable to this state root
  sTab*: Table[VertexID,VertexRef] ## Filter structural vertex table
  kMap*: Table[VertexID,HashKey] ## Filter Merkle hash key mapping
  vGen*: seq[VertexID] ## Filter unique vertex ID generator

nimbus/db/core_db/backend/aristo_db.nim

@@ -243,7 +243,7 @@ proc toAristoSavedStateBlockNumber*(
  if not mBe.isNil and mBe.parent.isAristo:
  let rc = mBe.parent.AristoCoreDbRef.adbBase.getSavedState()
  if rc.isOk:
- return (rc.value.src, rc.value.serial.toBlockNumber)
+ return (rc.value.src.to(Hash256), rc.value.serial.toBlockNumber)
  (EMPTY_ROOT_HASH, 0.toBlockNumber)
 
 # ------------------------------------------------------------------------------