# nimbus-eth1 # Copyright (c) 2021 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. import std/[algorithm, sequtils, tables], chronicles, eth/[common, p2p, rlp, trie/nibbles], stew/byteutils, ../../range_desc, "."/[hexary_desc, hexary_error, hexary_import, hexary_interpolate, hexary_inspect, hexary_paths, snapdb_desc, snapdb_persistent] {.push raises: [Defect].} logScope: topics = "snap-db" type SnapDbAccountsRef* = ref object of SnapDbBaseRef peer: Peer ## For log messages getClsFn: AccountsGetFn ## Persistent database `get()` closure const extraTraceMessages = false or true # ------------------------------------------------------------------------------ # Private helpers # ------------------------------------------------------------------------------ proc to(h: Hash256; T: type NodeKey): T = h.data.T proc convertTo(data: openArray[byte]; T: type Hash256): T = discard result.data.NodeKey.init(data) # size error => zero proc getFn(ps: SnapDbAccountsRef): HexaryGetFn = ## Derive from `GetClsFn` closure => `HexaryGetFn`. There reason for that ## seemingly redundant mapping is that here is space for additional localised ## and locked parameters as done with the `StorageSlotsGetFn`. return proc(key: openArray[byte]): Blob = ps.getClsFn(key) template noKeyError(info: static[string]; code: untyped) = try: code except KeyError as e: raiseAssert "Not possible (" & info & "): " & e.msg template noRlpExceptionOops(info: static[string]; code: untyped) = try: code except RlpError: return err(RlpEncoding) except KeyError as e: raiseAssert "Not possible (" & info & "): " & e.msg except Defect as e: raise e except Exception as e: raiseAssert "Ooops " & info & ": name=" & $e.name & " msg=" & e.msg # ------------------------------------------------------------------------------ # Private functions # ------------------------------------------------------------------------------ proc persistentAccounts( db: HexaryTreeDbRef; ## Current table ps: SnapDbAccountsRef; ## For persistent database ): Result[void,HexaryDbError] {.gcsafe, raises: [Defect,OSError,KeyError].} = ## Store accounts trie table on databse if ps.rockDb.isNil: let rc = db.persistentAccountsPut(ps.kvDb) if rc.isErr: return rc else: let rc = db.persistentAccountsPut(ps.rockDb) if rc.isErr: return rc ok() proc collectAccounts( peer: Peer, ## for log messages base: NodeTag; acc: seq[PackedAccount]; ): Result[seq[RLeafSpecs],HexaryDbError] {.gcsafe, raises: [Defect, RlpError].} = ## Repack account records into a `seq[RLeafSpecs]` queue. The argument data ## `acc` are as received with the snap message `AccountRange`). ## ## The returned list contains leaf node information for populating a repair ## table. The accounts, together with some hexary trie records for proofs ## can be used for validating the argument account data. var rcAcc: seq[RLeafSpecs] if 0 < acc.len: let pathTag0 = acc[0].accKey.to(NodeTag) # Verify lower bound if pathTag0 < base: let error = LowerBoundAfterFirstEntry trace "collectAccounts()", peer, base, accounts=acc.len, error return err(error) # Add first account rcAcc.add RLeafSpecs(pathTag: pathTag0, payload: acc[0].accBlob) # Veify & add other accounts for n in 1 ..< acc.len: let nodeTag = acc[n].accKey.to(NodeTag) if nodeTag <= rcAcc[^1].pathTag: let error = AccountsNotSrictlyIncreasing trace "collectAccounts()", peer, item=n, base, accounts=acc.len, error return err(error) rcAcc.add RLeafSpecs(pathTag: nodeTag, payload: acc[n].accBlob) ok(rcAcc) # ------------------------------------------------------------------------------ # Public constructor # ------------------------------------------------------------------------------ proc init*( T: type SnapDbAccountsRef; pv: SnapDbRef; root: Hash256; peer: Peer = nil ): T = ## Constructor, starts a new accounts session. let db = pv.kvDb new result result.init(pv, root.to(NodeKey)) result.peer = peer result.getClsFn = db.persistentAccountsGetFn() proc dup*( ps: SnapDbAccountsRef; root: Hash256; peer: Peer; ): SnapDbAccountsRef = ## Resume an accounts session with different `root` key and `peer`. new result result[].shallowCopy(ps[]) result.root = root.to(NodeKey) result.peer = peer proc dup*( ps: SnapDbAccountsRef; root: Hash256; ): SnapDbAccountsRef = ## Variant of `dup()` without the `peer` argument. new result result[].shallowCopy(ps[]) result.root = root.to(NodeKey) # ------------------------------------------------------------------------------ # Public functions # ------------------------------------------------------------------------------ proc importAccounts*( ps: SnapDbAccountsRef; ## Re-usable session descriptor base: NodeTag; ## before or at first account entry in `data` data: PackedAccountRange; ## re-packed `snap/1 ` reply data persistent = false; ## store data on disk noBaseBoundCheck = false; ## Ignore left boundary proof check if `true` ): Result[seq[NodeSpecs],HexaryDbError] = ## Validate and import accounts (using proofs as received with the snap ## message `AccountRange`). This function accumulates data in a memory table ## which can be written to disk with the argument `persistent` set `true`. The ## memory table is held in the descriptor argument`ps`. ## ## On success, the function returns a list of dangling node links from the ## argument `proof` list of nodes after the populating with accounts. The ## following example may illustrate the case: ## ## Assume an accounts hexary trie ## :: ## | 0 1 2 3 4 5 6 7 8 9 a b c d e f -- nibble positions ## | root -> (a, .. b, .. c, .. d, .. ,) -- root branch node ## | | | | | ## | ... v v v ## | (x,X) (y,Y) (z,Z) ## ## with `a`,`b`,`c`,`d` node hashes, `x`,`y`,`z` partial paths and account ## hashes `3&x`,`7&y`,`b&z` for account values `X`,`Y`,`Z`. All other ## links in the *root branch node* are assumed nil. ## ## The passing to this function ## * base: `3&x` ## * data.proof: *root branch node* ## * data.accounts: `(3&x,X)`, `(7&y,Y)`, `(b&z,Z)` ## a partial tree can be fully constructed and boundary proofs succeed. ## The return value will be an empty list. ## ## Leaving out `(7&y,Y)` the boundary proofs still succeed but the ## return value will be @[`(7&y,c)`]. ## ## The left boundary proof might be omitted by passing `true` for the ## `noBaseBoundCheck` argument. In this case, the boundary check must be ## performed on the return code as ## * if `data.accounts` is empty, the return value must be an empty list ## * otherwise, all type `NodeSpecs` items `w` of the return code must ## satisfy ## :: ## let leastAccountPath = data.accounts[0].accKey.to(NodeTag) ## leastAccountPath <= w.partialPath.max(NodeKey).to(NodeTag) ## ## Note that the `peer` argument is for log messages, only. var accounts: seq[RLeafSpecs] dangling: seq[NodeSpecs] try: if 0 < data.proof.len: let rc = ps.mergeProofs(ps.peer, data.proof) if rc.isErr: return err(rc.error) block: let rc = ps.peer.collectAccounts(base, data.accounts) if rc.isErr: return err(rc.error) accounts = rc.value if 0 < accounts.len: var innerSubTrie: seq[NodeSpecs] if 0 < data.proof.len: # Inspect trie for dangling nodes. This is not a big deal here as the # proof data is typically small. let proofStats = ps.hexaDb.hexaryInspectTrie(ps.root, @[]) topTag = accounts[^1].pathTag for w in proofStats.dangling: if base <= w.partialPath.max(NodeKey).to(NodeTag) and w.partialPath.min(NodeKey).to(NodeTag) <= topTag: # Extract dangling links which are inside the accounts range innerSubTrie.add w # Build partial hexary trie let rc = ps.hexaDb.hexaryInterpolate( ps.root, accounts, bootstrap = (data.proof.len == 0)) if rc.isErr: return err(rc.error) # Collect missing inner sub-trees in the reconstructed partial hexary # trie (if any). let bottomTag = accounts[0].pathTag for w in innerSubTrie: if ps.hexaDb.tab.hasKey(w.nodeKey.to(RepairKey)): continue # Verify that `base` is to the left of the first account and there is # nothing in between. Without proof, there can only be a complete # set/list of accounts. There must be a proof for an empty list. if not noBaseBoundCheck and w.partialPath.max(NodeKey).to(NodeTag) < bottomTag: return err(LowerBoundProofError) # Otherwise register left over entry dangling.add w if persistent: let rc = ps.hexaDb.persistentAccounts(ps) if rc.isErr: return err(rc.error) elif data.proof.len == 0: # There must be a proof for an empty argument list. return err(LowerBoundProofError) except RlpError: return err(RlpEncoding) except KeyError as e: raiseAssert "Not possible @ importAccounts: " & e.msg except OSError as e: error "Import Accounts exception", peer=ps.peer, name=($e.name), msg=e.msg return err(OSErrorException) #when extraTraceMessages: # trace "Accounts imported", peer=ps.peer, root=ps.root.ByteArray32.toHex, # proof=data.proof.len, base, accounts=data.accounts.len, # top=accounts[^1].pathTag, danglingLen=dangling.len ok(dangling) proc importAccounts*( pv: SnapDbRef; ## Base descriptor on `BaseChainDB` peer: Peer; ## For log messages root: Hash256; ## State root base: NodeTag; ## Before or at first account entry in `data` data: PackedAccountRange; ## Re-packed `snap/1 ` reply data noBaseBoundCheck = false; ## Ignore left bound proof check if `true` ): Result[seq[NodeSpecs],HexaryDbError] = ## Variant of `importAccounts()` SnapDbAccountsRef.init( pv, root, peer).importAccounts( base, data, persistent=true, noBaseBoundCheck) proc importRawAccountsNodes*( ps: SnapDbAccountsRef; ## Re-usable session descriptor nodes: openArray[NodeSpecs]; ## List of `(key,data)` records reportNodes = {Leaf}; ## Additional node types to report persistent = false; ## store data on disk ): seq[HexaryNodeReport] = ## Store data nodes given as argument `nodes` on the persistent database. ## ## If there were an error when processing a particular argument `notes` item, ## it will be reported with the return value providing argument slot/index, ## node type, end error code. ## ## If there was an error soring persistent data, the last report item will ## have an error code, only. ## ## Additional node items might be reported if the node type is in the ## argument set `reportNodes`. These reported items will have no error ## code set (i.e. `NothingSerious`.) ## let peer = ps.peer db = HexaryTreeDbRef.init(ps) nItems = nodes.len var nErrors = 0 slot: Option[int] try: # Import nodes for n,node in nodes: if 0 < node.data.len: # otherwise ignore empty placeholder slot = some(n) var rep = db.hexaryImport(node) if rep.error != NothingSerious: rep.slot = slot result.add rep nErrors.inc trace "Error importing account nodes", peer, inx=n, nItems, error=rep.error, nErrors elif rep.kind.isSome and rep.kind.unsafeGet in reportNodes: rep.slot = slot result.add rep # Store to disk if persistent and 0 < db.tab.len: slot = none(int) let rc = db.persistentAccounts(ps) if rc.isErr: result.add HexaryNodeReport(slot: slot, error: rc.error) except RlpError: result.add HexaryNodeReport(slot: slot, error: RlpEncoding) nErrors.inc trace "Error importing account nodes", peer, slot, nItems, error=RlpEncoding, nErrors except KeyError as e: raiseAssert "Not possible @ importRawAccountNodes: " & e.msg except OSError as e: result.add HexaryNodeReport(slot: slot, error: OSErrorException) nErrors.inc error "Import account nodes exception", peer, slot, nItems, name=($e.name), msg=e.msg, nErrors when extraTraceMessages: if nErrors == 0: trace "Raw account nodes imported", peer, slot, nItems, report=result.len proc importRawAccountsNodes*( pv: SnapDbRef; ## Base descriptor on `BaseChainDB` peer: Peer, ## For log messages, only nodes: openArray[NodeSpecs]; ## List of `(key,data)` records reportNodes = {Leaf}; ## Additional node types to report ): seq[HexaryNodeReport] = ## Variant of `importRawNodes()` for persistent storage. SnapDbAccountsRef.init( pv, Hash256(), peer).importRawAccountsNodes( nodes, reportNodes, persistent=true) proc inspectAccountsTrie*( ps: SnapDbAccountsRef; ## Re-usable session descriptor pathList = seq[Blob].default; ## Starting nodes for search persistent = false; ## Read data from disk ignoreError = false; ## Always return partial results if available ): Result[TrieNodeStat, HexaryDbError] = ## Starting with the argument list `pathSet`, find all the non-leaf nodes in ## the hexary trie which have at least one node key reference missing in ## the trie database. Argument `pathSet` list entries that do not refer to a ## valid node are silently ignored. ## let peer = ps.peer var stats: TrieNodeStat noRlpExceptionOops("inspectAccountsTrie()"): if persistent: stats = ps.getFn.hexaryInspectTrie(ps.root, pathList) else: stats = ps.hexaDb.hexaryInspectTrie(ps.root, pathList) block checkForError: var error = TrieIsEmpty if stats.stopped: error = TrieLoopAlert trace "Inspect account trie failed", peer, nPathList=pathList.len, nDangling=stats.dangling.len, stoppedAt=stats.level, error elif 0 < stats.level: break checkForError if ignoreError: return ok(stats) return err(error) #when extraTraceMessages: # trace "Inspect account trie ok", peer, nPathList=pathList.len, # nDangling=stats.dangling.len, level=stats.level return ok(stats) proc inspectAccountsTrie*( pv: SnapDbRef; ## Base descriptor on `BaseChainDB` peer: Peer; ## For log messages, only root: Hash256; ## state root pathList = seq[Blob].default; ## Starting paths for search ignoreError = false; ## Always return partial results when avail. ): Result[TrieNodeStat, HexaryDbError] = ## Variant of `inspectAccountsTrie()` for persistent storage. SnapDbAccountsRef.init( pv, root, peer).inspectAccountsTrie(pathList, persistent=true, ignoreError) proc getAccountsNodeKey*( ps: SnapDbAccountsRef; ## Re-usable session descriptor path: Blob; ## Partial node path persistent = false; ## Read data from disk ): Result[NodeKey,HexaryDbError] = ## For a partial node path argument `path`, return the raw node key. var rc: Result[NodeKey,void] noRlpExceptionOops("getAccountsNodeKey()"): if persistent: rc = ps.getFn.hexaryInspectPath(ps.root, path) else: rc = ps.hexaDb.hexaryInspectPath(ps.root, path) if rc.isOk: return ok(rc.value) err(NodeNotFound) proc getAccountsNodeKey*( pv: SnapDbRef; ## Base descriptor on `BaseChainDB` peer: Peer; ## For log messages, only root: Hash256; ## state root path: Blob; ## Partial node path ): Result[NodeKey,HexaryDbError] = ## Variant of `getAccountsNodeKey()` for persistent storage. SnapDbAccountsRef.init( pv, root, peer).getAccountsNodeKey(path, persistent=true) proc getAccountsData*( ps: SnapDbAccountsRef; ## Re-usable session descriptor path: NodeKey; ## Account to visit persistent = false; ## Read data from disk ): Result[Account,HexaryDbError] = ## Fetch account data. ## ## Caveat: There is no unit test yet for the non-persistent version let peer = ps.peer var acc: Account noRlpExceptionOops("getAccountData()"): var leaf: Blob if persistent: leaf = path.hexaryPath(ps.root, ps.getFn).leafData else: leaf = path.hexaryPath(ps.root.to(RepairKey),ps.hexaDb).leafData if leaf.len == 0: return err(AccountNotFound) acc = rlp.decode(leaf,Account) return ok(acc) proc getAccountsData*( pv: SnapDbRef; ## Base descriptor on `BaseChainDB` peer: Peer; ## For log messages, only root: Hash256; ## State root path: NodeKey; ## Account to visit ): Result[Account,HexaryDbError] = ## Variant of `getAccountsData()` for persistent storage. SnapDbAccountsRef.init( pv, root, peer).getAccountsData(path, persistent=true) # ------------------------------------------------------------------------------ # Public functions: additional helpers # ------------------------------------------------------------------------------ proc sortMerge*(base: openArray[NodeTag]): NodeTag = ## Helper for merging several `(NodeTag,seq[PackedAccount])` data sets ## so that there are no overlap which would be rejected by `merge()`. ## ## This function selects a `NodeTag` from a list. result = high(NodeTag) for w in base: if w < result: result = w proc sortMerge*(acc: openArray[seq[PackedAccount]]): seq[PackedAccount] = ## Helper for merging several `(NodeTag,seq[PackedAccount])` data sets ## so that there are no overlap which would be rejected by `merge()`. ## ## This function flattens and sorts the argument account lists. noKeyError("sortMergeAccounts"): var accounts: Table[NodeTag,PackedAccount] for accList in acc: for item in accList: accounts[item.accKey.to(NodeTag)] = item result = toSeq(accounts.keys).sorted(cmp).mapIt(accounts[it]) proc getAccountsChainDb*( ps: SnapDbAccountsRef; accKey: NodeKey; ): Result[Account,HexaryDbError] = ## Fetch account via `BaseChainDB` ps.getAccountsData(accKey, persistent = true) proc nextAccountsChainDbKey*( ps: SnapDbAccountsRef; accKey: NodeKey; ): Result[NodeKey,HexaryDbError] = ## Fetch the account path on the `BaseChainDB`, the one next to the ## argument account key. noRlpExceptionOops("getChainDbAccount()"): let path = accKey .hexaryPath(ps.root, ps.getFn) .next(ps.getFn) .getNibbles if 64 == path.len: return ok(path.getBytes.convertTo(Hash256).to(NodeKey)) err(AccountNotFound) proc prevAccountsChainDbKey*( ps: SnapDbAccountsRef; accKey: NodeKey; ): Result[NodeKey,HexaryDbError] = ## Fetch the account path on the `BaseChainDB`, the one before to the ## argument account. noRlpExceptionOops("getChainDbAccount()"): let path = accKey .hexaryPath(ps.root, ps.getFn) .prev(ps.getFn) .getNibbles if 64 == path.len: return ok(path.getBytes.convertTo(Hash256).to(NodeKey)) err(AccountNotFound) # ------------------------------------------------------------------------------ # End # ------------------------------------------------------------------------------