2023-05-30 11:47:47 +00:00
|
|
|
# nimbus-eth1
|
2024-02-01 21:27:48 +00:00
|
|
|
# Copyright (c) 2023-2024 Status Research & Development GmbH
|
2023-05-30 11:47:47 +00:00
|
|
|
# Licensed under either of
|
|
|
|
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0)
|
|
|
|
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
|
|
|
|
# http://opensource.org/licenses/MIT)
|
|
|
|
# at your option. This file may not be copied, modified, or distributed
|
|
|
|
# except according to those terms.
|
|
|
|
|
|
|
|
{.push raises: [].}
|
|
|
|
|
|
|
|
import
|
2024-06-22 20:33:37 +00:00
|
|
|
eth/common,
|
2023-09-12 18:45:12 +00:00
|
|
|
results,
|
2023-06-12 18:16:03 +00:00
|
|
|
"."/[aristo_desc, aristo_get]
|
2023-05-30 11:47:47 +00:00
|
|
|
|
|
|
|
type
|
|
|
|
Leg* = object
|
|
|
|
## For constructing a `VertexPath`
|
|
|
|
wp*: VidVtxPair ## Vertex ID and data ref
|
|
|
|
nibble*: int8 ## Next vertex selector for `Branch` (if any)
|
|
|
|
|
|
|
|
Hike* = object
|
|
|
|
## Trie traversal path
|
|
|
|
root*: VertexID ## Handy for some fringe cases
|
|
|
|
legs*: seq[Leg] ## Chain of vertices and IDs
|
2024-06-22 20:33:37 +00:00
|
|
|
tail*: NibblesBuf ## Portion of non completed path
|
2023-05-30 11:47:47 +00:00
|
|
|
|
2024-02-08 16:32:16 +00:00
|
|
|
const
|
|
|
|
HikeAcceptableStopsNotFound* = {
|
|
|
|
HikeBranchTailEmpty,
|
|
|
|
HikeBranchMissingEdge,
|
|
|
|
HikeExtTailEmpty,
|
|
|
|
HikeExtTailMismatch,
|
|
|
|
HikeLeafUnexpected,
|
|
|
|
HikeNoLegs}
|
|
|
|
## When trying to find a leaf vertex the Patricia tree, there are several
|
|
|
|
## conditions where the search stops which do not constitute a problem
|
|
|
|
## with the trie (aka sysetm error.)
|
|
|
|
|
2023-05-30 11:47:47 +00:00
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
# Private functions
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
2024-06-22 20:33:37 +00:00
|
|
|
func getNibblesImpl(hike: Hike; start = 0; maxLen = high(int)): NibblesBuf =
|
2023-05-30 11:47:47 +00:00
|
|
|
## May be needed for partial rebuild, as well
|
|
|
|
for n in start ..< min(hike.legs.len, maxLen):
|
|
|
|
let leg = hike.legs[n]
|
|
|
|
case leg.wp.vtx.vType:
|
|
|
|
of Branch:
|
2024-06-22 20:33:37 +00:00
|
|
|
result = result & NibblesBuf.nibble(leg.nibble.byte)
|
2023-05-30 11:47:47 +00:00
|
|
|
of Extension:
|
|
|
|
result = result & leg.wp.vtx.ePfx
|
|
|
|
of Leaf:
|
|
|
|
result = result & leg.wp.vtx.lPfx
|
|
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
# Public functions
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
|
2024-02-08 16:32:16 +00:00
|
|
|
func to*(rc: Result[Hike,(VertexID,AristoError,Hike)]; T: type Hike): T =
|
2023-09-15 15:23:53 +00:00
|
|
|
## Extract `Hike` from either ok ot error part of argument `rc`.
|
2024-02-08 16:32:16 +00:00
|
|
|
if rc.isOk: rc.value else: rc.error[2]
|
2023-09-15 15:23:53 +00:00
|
|
|
|
2024-06-22 20:33:37 +00:00
|
|
|
func to*(hike: Hike; T: type NibblesBuf): T =
|
2023-05-30 11:47:47 +00:00
|
|
|
## Convert back
|
|
|
|
hike.getNibblesImpl() & hike.tail
|
|
|
|
|
2024-06-22 20:33:37 +00:00
|
|
|
func legsTo*(hike: Hike; T: type NibblesBuf): T =
|
2023-05-30 11:47:47 +00:00
|
|
|
## Convert back
|
|
|
|
hike.getNibblesImpl()
|
|
|
|
|
2024-06-22 20:33:37 +00:00
|
|
|
func legsTo*(hike: Hike; numLegs: int; T: type NibblesBuf): T =
|
2023-12-04 20:39:26 +00:00
|
|
|
## variant of `legsTo()`
|
|
|
|
hike.getNibblesImpl(0, numLegs)
|
|
|
|
|
2023-05-30 11:47:47 +00:00
|
|
|
# --------
|
|
|
|
|
|
|
|
proc hikeUp*(
|
2024-06-22 20:33:37 +00:00
|
|
|
path: NibblesBuf; # Partial path
|
2023-05-30 11:47:47 +00:00
|
|
|
root: VertexID; # Start vertex
|
2023-07-04 18:24:03 +00:00
|
|
|
db: AristoDbRef; # Database
|
2024-02-08 16:32:16 +00:00
|
|
|
): Result[Hike,(VertexID,AristoError,Hike)] =
|
2023-05-30 11:47:47 +00:00
|
|
|
## For the argument `path`, find and return the logest possible path in the
|
|
|
|
## argument database `db`.
|
2023-09-15 15:23:53 +00:00
|
|
|
var hike = Hike(
|
2023-05-30 11:47:47 +00:00
|
|
|
root: root,
|
|
|
|
tail: path)
|
|
|
|
|
2023-06-12 13:48:47 +00:00
|
|
|
if not root.isValid:
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((VertexID(0),HikeRootMissing,hike))
|
2023-10-27 21:36:51 +00:00
|
|
|
if path.len == 0:
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((VertexID(0),HikeEmptyPath,hike))
|
2023-09-15 15:23:53 +00:00
|
|
|
|
|
|
|
var vid = root
|
2024-05-03 17:38:17 +00:00
|
|
|
while true:
|
2023-09-15 15:23:53 +00:00
|
|
|
var leg = Leg(wp: VidVtxPair(vid: vid), nibble: -1)
|
|
|
|
|
2023-12-19 12:39:23 +00:00
|
|
|
# Fetch next vertex
|
|
|
|
leg.wp.vtx = db.getVtxRc(vid).valueOr:
|
|
|
|
if error != GetVtxNotFound:
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((vid,error,hike))
|
2023-12-19 12:39:23 +00:00
|
|
|
if hike.legs.len == 0:
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((vid,HikeNoLegs,hike))
|
2024-05-03 17:38:17 +00:00
|
|
|
# The vertex ID `vid` was a follow up from a parent vertex, but there is
|
|
|
|
# no child vertex on the database. So `vid` is a dangling link which is
|
|
|
|
# allowed only if there is a partial trie (e.g. with `snap` sync.)
|
|
|
|
return err((vid,HikeDanglingEdge,hike))
|
2023-09-15 15:23:53 +00:00
|
|
|
|
|
|
|
case leg.wp.vtx.vType:
|
|
|
|
of Leaf:
|
2024-05-03 17:38:17 +00:00
|
|
|
# This must be the last vertex, so there cannot be any `tail` left.
|
2023-09-15 15:23:53 +00:00
|
|
|
if hike.tail.len == hike.tail.sharedPrefixLen(leg.wp.vtx.lPfx):
|
|
|
|
# Bingo, got full path
|
|
|
|
hike.legs.add leg
|
2024-06-22 20:33:37 +00:00
|
|
|
hike.tail = NibblesBuf()
|
2024-05-03 17:38:17 +00:00
|
|
|
# This is the only loop exit
|
2023-09-15 15:23:53 +00:00
|
|
|
break
|
|
|
|
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((vid,HikeLeafUnexpected,hike))
|
2023-09-15 15:23:53 +00:00
|
|
|
|
|
|
|
of Branch:
|
2024-05-03 17:38:17 +00:00
|
|
|
# There must be some more data (aka `tail`) after a `Branch` vertex.
|
2023-09-15 15:23:53 +00:00
|
|
|
if hike.tail.len == 0:
|
|
|
|
hike.legs.add leg
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((vid,HikeBranchTailEmpty,hike))
|
2023-09-15 15:23:53 +00:00
|
|
|
|
|
|
|
let
|
|
|
|
nibble = hike.tail[0].int8
|
|
|
|
nextVid = leg.wp.vtx.bVid[nibble]
|
|
|
|
|
|
|
|
if not nextVid.isValid:
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((vid,HikeBranchMissingEdge,hike))
|
2023-09-15 15:23:53 +00:00
|
|
|
|
|
|
|
leg.nibble = nibble
|
|
|
|
hike.legs.add leg
|
|
|
|
hike.tail = hike.tail.slice(1)
|
|
|
|
vid = nextVid
|
|
|
|
|
|
|
|
of Extension:
|
2024-05-03 17:38:17 +00:00
|
|
|
# There must be some more data (aka `tail`) after an `Extension` vertex.
|
2023-09-15 15:23:53 +00:00
|
|
|
if hike.tail.len == 0:
|
|
|
|
hike.legs.add leg
|
2024-06-22 20:33:37 +00:00
|
|
|
hike.tail = NibblesBuf()
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((vid,HikeExtTailEmpty,hike)) # Well, somehow odd
|
2023-09-15 15:23:53 +00:00
|
|
|
|
|
|
|
if leg.wp.vtx.ePfx.len != hike.tail.sharedPrefixLen(leg.wp.vtx.ePfx):
|
2024-02-08 16:32:16 +00:00
|
|
|
return err((vid,HikeExtTailMismatch,hike)) # Need to branch from here
|
2023-09-15 15:23:53 +00:00
|
|
|
|
2024-05-03 17:38:17 +00:00
|
|
|
let nextVid = leg.wp.vtx.eVid
|
|
|
|
if not nextVid.isValid:
|
|
|
|
return err((vid,HikeExtMissingEdge,hike))
|
|
|
|
|
2023-09-15 15:23:53 +00:00
|
|
|
hike.legs.add leg
|
|
|
|
hike.tail = hike.tail.slice(leg.wp.vtx.ePfx.len)
|
2024-05-03 17:38:17 +00:00
|
|
|
vid = nextVid
|
2023-09-15 15:23:53 +00:00
|
|
|
|
|
|
|
ok hike
|
|
|
|
|
2024-02-08 16:32:16 +00:00
|
|
|
proc hikeUp*(
|
|
|
|
lty: LeafTie;
|
|
|
|
db: AristoDbRef;
|
|
|
|
): Result[Hike,(VertexID,AristoError,Hike)] =
|
2023-05-30 11:47:47 +00:00
|
|
|
## Variant of `hike()`
|
2024-06-22 20:33:37 +00:00
|
|
|
lty.path.to(NibblesBuf).hikeUp(lty.root, db)
|
2023-05-30 11:47:47 +00:00
|
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
# End
|
|
|
|
# ------------------------------------------------------------------------------
|