307 lines
9.3 KiB
Nim
307 lines
9.3 KiB
Nim
# nimbus-eth1
|
|
# Copyright (c) 2024 Status Research & Development GmbH
|
|
# 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
|
|
std/[sets, sequtils],
|
|
eth/common,
|
|
results,
|
|
".."/[aristo_desc, aristo_get, aristo_vid],
|
|
./part_desc
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Private helpers
|
|
# ------------------------------------------------------------------------------
|
|
|
|
proc read(rlp: var Rlp; T: type PrfNode): T {.gcsafe, raises: [RlpError].} =
|
|
## Mixin for RLP reader. The decoder with error return code in a `Leaf`
|
|
## node if needed.
|
|
##
|
|
func readError(error: AristoError): PrfNode =
|
|
## Prettify return code expression
|
|
PrfNode(vtx: VertexRef(vType: Leaf), prfType: isError, error: error)
|
|
|
|
if not rlp.isList:
|
|
# Otherwise `rlp.items` would raise a `Defect`
|
|
return readError(PartRlp2Or17ListEntries)
|
|
|
|
var
|
|
blobs = newSeq[Blob](2) # temporary, cache
|
|
links: array[16,HashKey] # reconstruct branch node
|
|
top = 0 # count entries and positions
|
|
|
|
# Collect lists of either 2 or 17 blob entries.
|
|
for w in rlp.items:
|
|
case top
|
|
of 0, 1:
|
|
if not w.isBlob:
|
|
return readError(PartRlpBlobExpected)
|
|
blobs[top] = rlp.read(Blob)
|
|
of 2 .. 15:
|
|
let blob = rlp.read(Blob)
|
|
links[top] = HashKey.fromBytes(blob).valueOr:
|
|
return readError(PartRlpBranchHashKeyExpected)
|
|
of 16:
|
|
if not w.isBlob or 0 < rlp.read(Blob).len:
|
|
return readError(PartRlpEmptyBlobExpected)
|
|
else:
|
|
return readError(PartRlp2Or17ListEntries)
|
|
top.inc
|
|
|
|
# Verify extension data
|
|
case top
|
|
of 2:
|
|
if blobs[0].len == 0:
|
|
return readError(PartRlpNonEmptyBlobExpected)
|
|
let (isLeaf, pathSegment) = NibblesBuf.fromHexPrefix blobs[0]
|
|
if isLeaf:
|
|
return PrfNode(
|
|
prfType: ignore,
|
|
|
|
vtx: VertexRef(
|
|
vType: Leaf,
|
|
pfx: pathSegment,
|
|
lData: LeafPayload(
|
|
pType: RawData,
|
|
rawBlob: blobs[1])))
|
|
else:
|
|
var node = PrfNode(
|
|
prfType: isExtension,
|
|
vtx: VertexRef(
|
|
vType: Branch,
|
|
pfx: pathSegment))
|
|
node.key[0] = HashKey.fromBytes(blobs[1]).valueOr:
|
|
return readError(PartRlpExtHashKeyExpected)
|
|
return node
|
|
of 17:
|
|
for n in [0,1]:
|
|
links[n] = HashKey.fromBytes(blobs[n]).valueOr:
|
|
return readError(PartRlpBranchHashKeyExpected)
|
|
return PrfNode(
|
|
vtx: VertexRef(
|
|
vType: Branch),
|
|
prfType: ignore,
|
|
key: links)
|
|
else:
|
|
discard
|
|
|
|
readError(PartRlp2Or17ListEntries)
|
|
|
|
proc read(rlp: var Rlp; T: type PrfPayload): T {.gcsafe, raises: [RlpError].} =
|
|
## Mixin for RLP reader decoding `Account` or storage slot payload.
|
|
##
|
|
case rlp.listLen:
|
|
of 1:
|
|
result.prfType = isStoValue
|
|
result.num = rlp.read UInt256
|
|
of 4:
|
|
result.prfType = isAccount
|
|
result.acc = rlp.read Account
|
|
else:
|
|
result.prfType = isError
|
|
result.error = PartRlp1r4ListEntries
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# Public functions
|
|
# ------------------------------------------------------------------------------
|
|
|
|
func toNodesTab*(
|
|
proof: openArray[Blob]; # List of RLP encoded nodes
|
|
mode: PartStateMode; # How to decode `Leaf` nodes
|
|
): Result[TableRef[HashKey,PrfNode],AristoError] =
|
|
## Convert RLP encoded argument list `proof` to a nodes table indexed by
|
|
## the `HashKey` values of the `proof` list entries.
|
|
var
|
|
exts: Table[HashKey,PrfNode] # need to be processed separately
|
|
nodes = newTable[HashKey,PrfNode]()
|
|
|
|
# populate tables
|
|
for w in proof:
|
|
# Decode blob `w`
|
|
let nd = block:
|
|
try: rlp.decode(w, PrfNode)
|
|
except RlpError:
|
|
return err(PartRlpNodeException)
|
|
|
|
case nd.prfType:
|
|
of isExtension:
|
|
# For a moment, hold extensions on a separate cache
|
|
exts[w.digestTo HashKey] = nd
|
|
|
|
of ignore:
|
|
# Store `Branch` and `Leaf` nodes in final lookup table
|
|
nodes[w.digestTo HashKey] = nd
|
|
|
|
# Special decoding for account `Leaf` nodes
|
|
if nd.vtx.vType == Leaf and mode != ForceGenericPayload:
|
|
# Decode payload to deficated format for storage or accounts
|
|
var pyl: PrfPayload
|
|
try:
|
|
pyl = rlp.decode(nd.vtx.lData.rawBlob, PrfPayload)
|
|
except RlpError:
|
|
pyl = PrfPayload(prfType: isError, error: PartRlpPayloadException)
|
|
|
|
case pyl.prfType:
|
|
of isStoValue:
|
|
# Single value encoding might not be unique so it cannot be
|
|
# automatically detected
|
|
if mode != AutomaticPayload:
|
|
nd.vtx.lData = LeafPayload(pType: StoData, stoData: pyl.num)
|
|
of isAccount:
|
|
nd.key[0] = pyl.acc.storageRoot.to(HashKey)
|
|
nd.vtx.lData = LeafPayload(
|
|
pType: AccountData,
|
|
account: AristoAccount(
|
|
nonce: pyl.acc.nonce,
|
|
balance: pyl.acc.balance,
|
|
codeHash: pyl.acc.codeHash))
|
|
elif mode == AutomaticPayload:
|
|
discard
|
|
else:
|
|
return err(pyl.error)
|
|
else:
|
|
return err(nd.error)
|
|
|
|
# Postprocess extension nodes
|
|
for (xKey,xNode) in exts.pairs:
|
|
# Combine `xNode + nodes[w.ePfx]`
|
|
let nd = nodes.getOrDefault xNode.key[0]
|
|
if nd.isNil:
|
|
# Need to store raw extension
|
|
nodes[xKey] = xNode
|
|
continue
|
|
if nd.vtx.pfx.len != 0:
|
|
return err(PartGarbledExtsInProofs)
|
|
# Move extended `nd` branch node
|
|
nd.prfType = ignore
|
|
nd.vtx.pfx = xNode.vtx.pfx
|
|
nodes.del xNode.key[0]
|
|
nodes[xKey] = nd
|
|
|
|
ok nodes
|
|
|
|
|
|
proc backLinks*(nTab: TableRef[HashKey,PrfNode]): PrfBackLinks =
|
|
## tuple[chains: seq[seq[HashKey]], links: Table[HashKey,HashKey]] =
|
|
## Classify argument table
|
|
##
|
|
## * chains: key list of back chains
|
|
## * links: `(child,parent)` lookup table
|
|
##
|
|
new result
|
|
|
|
# Collect predecessor list
|
|
for (key,nd) in nTab.pairs:
|
|
if nd.vtx.vType == Leaf:
|
|
if nd.vtx.lData.pType == AccountData and nd.key[0].isValid:
|
|
result.links[nd.key[0]] = key
|
|
elif nd.prfType == isExtension:
|
|
result.links[nd.key[0]] = key
|
|
else:
|
|
for w in nd.key:
|
|
if w.isValid:
|
|
result.links[w] = key
|
|
|
|
# Compute leafs list, i.e. keys without children in `nTab[]`
|
|
var leafs = nTab.keys.toSeq.toHashSet
|
|
for (child,parent) in result.links.pairs:
|
|
if child in nTab:
|
|
leafs.excl parent # `parent` has `child` => not a leaf
|
|
|
|
# Compute chains starting at leafs
|
|
for leaf in leafs:
|
|
var q = @[leaf]
|
|
while true:
|
|
let up = result.links.getOrVoid q[^1]
|
|
if up.isValid:
|
|
q.add up
|
|
else:
|
|
break
|
|
result.chains.add q
|
|
|
|
|
|
proc getTreeRootVid*(
|
|
ps: PartStateRef;
|
|
key: HashKey;
|
|
): Result[VertexID,AristoError] =
|
|
## Find root ID in `ps[]` or create a new ID
|
|
##
|
|
# Use root from `ps` descriptor
|
|
let rvid = ps[key]
|
|
if rvid.isValid:
|
|
return ok(rvid.vid)
|
|
|
|
# Try next free VID
|
|
for n in 2 .. LEAST_FREE_VID:
|
|
let rvid = (VertexID(n),VertexID(n))
|
|
if not ps.db.getVtx(rvid).isValid:
|
|
ps[key] = rvid
|
|
return ok(VertexID n)
|
|
|
|
err(PartNoMoreRootVidsLeft)
|
|
|
|
|
|
proc getRvid*(
|
|
ps: PartStateRef;
|
|
root: VertexID;
|
|
key: HashKey;
|
|
): Result[tuple[rvid: RootedVertexID, fromStateDb: bool],AristoError] =
|
|
## Find key in `ps[]` or create a new key. the value `onStateDb` is
|
|
## return `false` if a new entry was created.
|
|
##
|
|
var (rvid, fromStateDb) = (ps[key], true)
|
|
if not rvid.isValid:
|
|
# Create new one
|
|
(rvid, fromStateDb) = ((root, ps.db.vidFetch()), false)
|
|
ps[key] = rvid
|
|
elif root != rvid.root:
|
|
# Oops
|
|
return err(PartRootVidsDontMatch)
|
|
ok((rvid, fromStateDb))
|
|
|
|
|
|
proc updateAccountsTree*(
|
|
ps: PartStateRef; # Partial database descriptor
|
|
nodes: TableRef[HashKey,PrfNode]; # Node lookup table
|
|
bl: PrfBackLinks; # Uplink lists
|
|
mode: PartStateMode; # Try accounts, otherwise generic
|
|
): Result[void,AristoError] =
|
|
## Check wether the chain has an accounts leaf node and update the
|
|
## argument descriptor `ps` accordingly.
|
|
##
|
|
if mode == ForceGenericPayload or VertexID(1) in ps.core:
|
|
return ok()
|
|
|
|
var accRootKey = VOID_HASH_KEY
|
|
for chain in bl.chains:
|
|
for key in chain:
|
|
nodes[].withValue(key,node):
|
|
if node.vtx.vType == Leaf and node.vtx.lData.pType == AccountData:
|
|
|
|
# Ok, got an accounts leaf node
|
|
if not accRootKey.isValid:
|
|
# Register accounts root
|
|
accRootKey = chain[^1]
|
|
ps[accRootKey] = (VertexID(1),VertexID(1))
|
|
elif accRootKey != chain[^1]:
|
|
# Two account chains with different root keys
|
|
return err(PartRootKeysDontMatch)
|
|
|
|
# Register storage root (if any)
|
|
if node.key[0].isValid:
|
|
let vid = ps.db.vidFetch()
|
|
ps[node.key[0]] = (vid,vid)
|
|
ok()
|
|
|
|
# ------------------------------------------------------------------------------
|
|
# End
|
|
# ------------------------------------------------------------------------------
|