nimbus-eth1/stateless/multi_keys.nim

142 lines
4.1 KiB
Nim
Raw Normal View History

2020-05-04 11:52:45 +00:00
import
eth/common, eth/trie/[db, nibbles], algorithm,
2020-05-04 11:52:45 +00:00
./witness_types
type
KeyHash* = array[32, byte]
KeyData* = object
visited*: bool
hash*: KeyHash
case storageMode*: bool
of true:
storageSlot*: StorageSlot
of false:
storageKeys*: MultikeysRef
address*: EthAddress
2020-05-05 08:05:17 +00:00
codeTouched*: bool
2020-05-04 11:52:45 +00:00
Multikeys* = object
2020-05-05 08:05:17 +00:00
keys*: seq[KeyData]
MultikeysRef* = ref Multikeys
2020-05-04 11:52:45 +00:00
Group* = object
first*, last*: int16
2020-05-04 11:52:45 +00:00
BranchGroup* = object
mask*: uint
groups*: array[16, Group]
2020-05-05 08:05:17 +00:00
AccountKey* = tuple[address: EthAddress, codeTouched: bool, storageKeys: MultikeysRef]
MatchGroup* = tuple[match: bool, group: Group]
2020-05-04 11:52:45 +00:00
func cmpHash(a, b: KeyHash): int =
var i = 0
var m = min(a.len, b.len)
while i < m:
result = a[i].int - b[i].int
if result != 0: return
inc(i)
result = a.len - b.len
func cmpHash(a, b: KeyData): int =
2020-05-04 11:52:45 +00:00
cmpHash(a.hash, b.hash)
func getNibble(x: openArray[byte], i: int): byte =
if(i and 0x01) == 0x01:
result = x[i shr 1] and 0x0F
else:
result = x[i shr 1] shr 4
func compareNibbles(x: openArray[byte], start: int, n: NibblesSeq): bool =
var i = 0
while i < n.len:
if getNibble(x, start + i) != n[i]:
return false
inc i
result = true
proc newMultiKeys*(keys: openArray[AccountKey]): MultikeysRef =
result = new Multikeys
result.keys = newSeq[KeyData](keys.len)
for i, a in keys:
result.keys[i] = KeyData(
storageMode: false,
hash: keccak(a.address).data,
address: a.address,
2020-05-05 08:05:17 +00:00
codeTouched: a.codeTouched,
storageKeys: a.storageKeys)
result.keys.sort(cmpHash)
proc newMultiKeys*(keys: openArray[StorageSlot]): MultikeysRef =
result = new Multikeys
result.keys = newSeq[KeyData](keys.len)
for i, a in keys:
result.keys[i] = KeyData(storageMode: true, hash: keccak(a).data, storageSlot: a)
result.keys.sort(cmpHash)
func initGroup*(m: MultikeysRef): Group =
type T = type result.last
result = Group(first: 0'i16, last: (m.keys.len - 1).T)
func groups*(m: MultikeysRef, parentGroup: Group, depth: int): BranchGroup =
2020-05-04 11:52:45 +00:00
# similar to a branch node, the product of this func
# is a 16 bits bitmask and an array of max 16 groups
# if the bit is set, the n-th elem of array have a group
# each group consist of at least one key
var g = Group(first: parentGroup.first, last: parentGroup.first)
var nibble = getNibble(m.keys[g.first].hash, depth)
let last = parentGroup.last
for i in parentGroup.first..parentGroup.last:
let currNibble = getNibble(m.keys[i].hash, depth)
if currNibble != nibble:
g.last = i - 1
setBranchMaskBit(result.mask, nibble.int)
result.groups[nibble.int] = g
nibble = currNibble
g.first = i
if i == last:
g.last = last
setBranchMaskBit(result.mask, nibble.int)
result.groups[nibble.int] = g
2020-05-04 11:52:45 +00:00
iterator groups*(m: MultikeysRef, depth: int, n: NibblesSeq, parentGroup: Group): MatchGroup =
2020-05-04 11:52:45 +00:00
# using common-prefix comparison, this iterator
# will produce groups, usually only one match group
# the rest will be not match
# in case of wrong path, there will be no match at all
var g = Group(first: parentGroup.first, last: parentGroup.first)
var match = compareNibbles(m.keys[g.first].hash, depth, n)
let last = parentGroup.last
var haveGroup = false
var groupResult: Group
var matchResult: bool
for i in parentGroup.first..parentGroup.last:
if compareNibbles(m.keys[i].hash, depth, n) != match:
g.last = i - 1
haveGroup = true
matchResult = match
groupResult = g
2020-05-04 11:52:45 +00:00
match = not match
g = Group(first: g.last, last: g.last)
2020-05-04 11:52:45 +00:00
if i == last:
haveGroup = true
g.last = last
groupResult = g
matchResult = match
if haveGroup:
haveGroup = false
yield (matchResult, groupResult)
2020-05-05 08:05:17 +00:00
iterator keyDatas*(m: MultikeysRef, g: Group): var KeyData =
for i in g.first..g.last:
yield m.keys[i]
iterator storageKeys*(m :MultikeysRef): MultikeysRef =
for x in m.keys:
yield x.storageKeys
2020-05-05 08:05:17 +00:00
func match*(kd: KeyData, n: NibblesSeq, depth: int): bool {.inline.} =
compareNibbles(kd.hash, depth, n)