status-im
/
nimbus-eth1
mirror of https://github.com/status-im/nimbus-eth1.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fluffy state network refactor (#2200) 

* Add additional getTrieProof test.

* Refactor state network: Removed variant objects for values and split state_content into multiple files.
This commit is contained in:
web3-developer 2024-05-22 09:22:07 +08:00 committed by GitHub
parent 2629d412d7
commit e566e89d03
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
17 changed files with 938 additions and 886 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fluffy/common/common_utils.nim
View File

@ -14,7 +14,7 @@ import
stew/[io2, arrayops],
eth/p2p/discoveryv5/enr
func init*(T: type KeccakHash, hash: openArray[byte]): T =
func fromBytes*(T: type KeccakHash, hash: openArray[byte]): T =
doAssert(hash.len() == 32)
KeccakHash(data: array[32, byte].initCopyFrom(hash))

112
fluffy/network/state/content/content_keys.nim Normal file
View File

@ -0,0 +1,112 @@
# Fluffy
# Copyright (c) 2023-2024 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
# As per spec:
# https://github.com/ethereum/portal-network-specs/blob/master/state-network.md#content-keys-and-content-ids
{.push raises: [].}
import
nimcrypto/[hash, sha2, keccak],
results,
stint,
eth/common/eth_types,
ssz_serialization,
./nibbles
export ssz_serialization, common_types, hash, results
type
NodeHash* = KeccakHash
CodeHash* = KeccakHash
Address* = EthAddress
ContentType* = enum
# Note: Need to add this unused value as a case object with an enum without
# a 0 valueis not allowed: "low(contentType) must be 0 for discriminant".
# For prefix values that are in the enum gap, the deserialization will fail
# at runtime as is wanted.
# In the future it might be possible that this will fail at compile time for
# the SSZ Union type, but currently it is allowed in the implementation, and
# the SSZ spec is not explicit about disallowing this.
unused = 0x00
accountTrieNode = 0x20
contractTrieNode = 0x21
contractCode = 0x22
AccountTrieNodeKey* = object
path*: Nibbles
nodeHash*: NodeHash
ContractTrieNodeKey* = object
address*: Address
path*: Nibbles
nodeHash*: NodeHash
ContractCodeKey* = object
address*: Address
codeHash*: CodeHash
ContentKey* = object
case contentType*: ContentType
of unused:
discard
of accountTrieNode:
accountTrieNodeKey*: AccountTrieNodeKey
of contractTrieNode:
contractTrieNodeKey*: ContractTrieNodeKey
of contractCode:
contractCodeKey*: ContractCodeKey
func init*(T: type AccountTrieNodeKey, path: Nibbles, nodeHash: NodeHash): T =
AccountTrieNodeKey(path: path, nodeHash: nodeHash)
func init*(
T: type ContractTrieNodeKey, address: Address, path: Nibbles, nodeHash: NodeHash
): T =
ContractTrieNodeKey(address: address, path: path, nodeHash: nodeHash)
func init*(T: type ContractCodeKey, address: Address, codeHash: CodeHash): T =
ContractCodeKey(address: address, codeHash: codeHash)
func initAccountTrieNodeKey*(path: Nibbles, nodeHash: NodeHash): ContentKey =
ContentKey(
contentType: accountTrieNode,
accountTrieNodeKey: AccountTrieNodeKey.init(path, nodeHash),
)
func initContractTrieNodeKey*(
address: Address, path: Nibbles, nodeHash: NodeHash
): ContentKey =
ContentKey(
contentType: contractTrieNode,
contractTrieNodeKey: ContractTrieNodeKey.init(address, path, nodeHash),
)
func initContractCodeKey*(address: Address, codeHash: CodeHash): ContentKey =
ContentKey(
contentType: contractCode, contractCodeKey: ContractCodeKey.init(address, codeHash)
)
proc readSszBytes*(data: openArray[byte], val: var ContentKey) {.raises: [SszError].} =
mixin readSszValue
if data.len() > 0 and data[0] == ord(unused):
raise newException(MalformedSszError, "SSZ selector is unused value")
readSszValue(data, val)
func encode*(contentKey: ContentKey): ByteList =
doAssert(contentKey.contentType != unused)
ByteList.init(SSZ.encode(contentKey))
func decode*(T: type ContentKey, contentKey: ByteList): Result[T, string] =
decodeSsz(contentKey.asSeq(), T)
func toContentId*(contentKey: ByteList): ContentId =
# TODO: Should we try to parse the content key here for invalid ones?
let idHash = sha256.digest(contentKey.asSeq())
readUintBE[256](idHash.data)

97
fluffy/network/state/content/content_values.nim Normal file
View File

@ -0,0 +1,97 @@
# Fluffy
# Copyright (c) 2023-2024 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
# As per spec:
# https://github.com/ethereum/portal-network-specs/blob/master/state-network.md#content-keys-and-content-ids
{.push raises: [].}
import results, eth/common/eth_types, ssz_serialization, ../../../common/common_types
export ssz_serialization, common_types, hash, results
const
MAX_TRIE_NODE_LEN = 1024
MAX_TRIE_PROOF_LEN = 65
MAX_BYTECODE_LEN = 32768
type
TrieNode* = List[byte, MAX_TRIE_NODE_LEN]
TrieProof* = List[TrieNode, MAX_TRIE_PROOF_LEN]
Bytecode* = List[byte, MAX_BYTECODE_LEN]
AccountTrieNodeOffer* = object
proof*: TrieProof
blockHash*: BlockHash
AccountTrieNodeRetrieval* = object
node*: TrieNode
ContractTrieNodeOffer* = object
storageProof*: TrieProof
accountProof*: TrieProof
blockHash*: BlockHash
ContractTrieNodeRetrieval* = object
node*: TrieNode
ContractCodeOffer* = object
code*: Bytecode
accountProof*: TrieProof
blockHash*: BlockHash
ContractCodeRetrieval* = object
code*: Bytecode
ContentValue* =
AccountTrieNodeOffer | ContractTrieNodeOffer | ContractCodeOffer |
AccountTrieNodeRetrieval | ContractTrieNodeRetrieval | ContractCodeRetrieval
func init*(T: type AccountTrieNodeOffer, proof: TrieProof, blockHash: BlockHash): T =
AccountTrieNodeOffer(proof: proof, blockHash: blockHash)
func init*(T: type AccountTrieNodeRetrieval, node: TrieNode): T =
AccountTrieNodeRetrieval(node: node)
func init*(
T: type ContractTrieNodeOffer,
storageProof: TrieProof,
accountProof: TrieProof,
blockHash: BlockHash,
): T =
ContractTrieNodeOffer(
storageProof: storageProof, accountProof: accountProof, blockHash: blockHash
)
func init*(T: type ContractTrieNodeRetrieval, node: TrieNode): T =
ContractTrieNodeRetrieval(node: node)
func init*(
T: type ContractCodeOffer,
code: Bytecode,
accountProof: TrieProof,
blockHash: BlockHash,
): T =
ContractCodeOffer(code: code, accountProof: accountProof, blockHash: blockHash)
func init*(T: type ContractCodeRetrieval, code: Bytecode): T =
ContractCodeRetrieval(code: code)
func toRetrievalValue*(offer: AccountTrieNodeOffer): AccountTrieNodeRetrieval =
AccountTrieNodeRetrieval.init(offer.proof[^1])
func toRetrievalValue*(offer: ContractTrieNodeOffer): ContractTrieNodeRetrieval =
ContractTrieNodeRetrieval.init(offer.storageProof[^1])
func toRetrievalValue*(offer: ContractCodeOffer): ContractCodeRetrieval =
ContractCodeRetrieval.init(offer.code)
func encode*(value: ContentValue): seq[byte] =
SSZ.encode(value)
func decode*(T: type ContentValue, bytes: openArray[byte]): Result[T, string] =
decodeSsz(bytes, T)

101
fluffy/network/state/content/nibbles.nim Normal file
View File

@ -0,0 +1,101 @@
# Fluffy
# Copyright (c) 2023-2024 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
# As per spec:
# https://github.com/ethereum/portal-network-specs/blob/master/state-network.md#content-keys-and-content-ids
{.push raises: [].}
import
nimcrypto/hash,
results,
stint,
eth/common/eth_types,
ssz_serialization,
../../../common/common_types
export ssz_serialization, common_types, hash, results
const
MAX_PACKED_NIBBLES_LEN = 33
MAX_UNPACKED_NIBBLES_LEN = 64
type Nibbles* = List[byte, MAX_PACKED_NIBBLES_LEN]
func init*(T: type Nibbles, packed: openArray[byte], isEven: bool): T =
doAssert(packed.len() <= MAX_PACKED_NIBBLES_LEN)
var output = newSeqOfCap[byte](packed.len() + 1)
if isEven:
output.add(0x00)
else:
doAssert(packed.len() > 0)
# set the first nibble to 1 and copy the second nibble from the input
output.add((packed[0] and 0x0F) or 0x10)
let startIdx = if isEven: 0 else: 1
for i in startIdx ..< packed.len():
output.add(packed[i])
Nibbles(output)
func encode*(nibbles: Nibbles): seq[byte] =
SSZ.encode(nibbles)
func decode*(T: type Nibbles, bytes: openArray[byte]): Result[T, string] =
decodeSsz(bytes, T)
func packNibbles*(unpacked: openArray[byte]): Nibbles =
doAssert(
unpacked.len() <= MAX_UNPACKED_NIBBLES_LEN, "Can't pack more than 64 nibbles"
)
if unpacked.len() == 0:
return Nibbles(@[byte(0x00)])
let isEvenLength = unpacked.len() mod 2 == 0
var
output = newSeqOfCap[byte](unpacked.len() div 2 + 1)
highNibble = isEvenLength
currentByte: byte = 0
if isEvenLength:
output.add(0x00)
else:
currentByte = 0x10
for i, nibble in unpacked:
if highNibble:
currentByte = nibble shl 4
else:
output.add(currentByte or nibble)
currentByte = 0
highNibble = not highNibble
Nibbles(output)
func unpackNibbles*(packed: Nibbles): seq[byte] =
doAssert(packed.len() <= MAX_PACKED_NIBBLES_LEN, "Packed nibbles length is too long")
var output = newSeqOfCap[byte](packed.len() * 2)
for i, pair in packed:
if i == 0 and pair == 0x00:
continue
let
first = (pair and 0xF0) shr 4
second = pair and 0x0F
if i == 0 and first == 0x01:
output.add(second)
else:
output.add(first)
output.add(second)
output

271
fluffy/network/state/state_content.nim
View File

@ -5,273 +5,6 @@
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
# As per spec:
# https://github.com/ethereum/portal-network-specs/blob/master/state-network.md#content-keys-and-content-ids
import ./content/content_keys, ./content/content_values, ./content/nibbles
{.push raises: [].}
import
nimcrypto/[hash, sha2, keccak],
results,
stint,
eth/common/eth_types,
ssz_serialization,
../../common/common_types
export ssz_serialization, common_types, hash, results
const
MAX_PACKED_NIBBLES_LEN = 33
MAX_UNPACKED_NIBBLES_LEN = 64
MAX_TRIE_NODE_LEN = 1024
MAX_TRIE_PROOF_LEN = 65
MAX_BYTECODE_LEN = 32768
type
NodeHash* = KeccakHash
CodeHash* = KeccakHash
Address* = EthAddress
ContentType* = enum
# Note: Need to add this unused value as a case object with an enum without
# a 0 valueis not allowed: "low(contentType) must be 0 for discriminant".
# For prefix values that are in the enum gap, the deserialization will fail
# at runtime as is wanted.
# In the future it might be possible that this will fail at compile time for
# the SSZ Union type, but currently it is allowed in the implementation, and
# the SSZ spec is not explicit about disallowing this.
unused = 0x00
accountTrieNode = 0x20
contractTrieNode = 0x21
contractCode = 0x22
Nibbles* = List[byte, MAX_PACKED_NIBBLES_LEN]
TrieNode* = List[byte, MAX_TRIE_NODE_LEN]
TrieProof* = List[TrieNode, MAX_TRIE_PROOF_LEN]
Bytecode* = List[byte, MAX_BYTECODE_LEN]
AccountTrieNodeKey* = object
path*: Nibbles
nodeHash*: NodeHash
ContractTrieNodeKey* = object
address*: Address
path*: Nibbles
nodeHash*: NodeHash
ContractCodeKey* = object
address*: Address
codeHash*: CodeHash
ContentKey* = object
case contentType*: ContentType
of unused:
discard
of accountTrieNode:
accountTrieNodeKey*: AccountTrieNodeKey
of contractTrieNode:
contractTrieNodeKey*: ContractTrieNodeKey
of contractCode:
contractCodeKey*: ContractCodeKey
AccountTrieNodeOffer* = object
proof*: TrieProof
blockHash*: BlockHash
AccountTrieNodeRetrieval* = object
node*: TrieNode
ContractTrieNodeOffer* = object
storageProof*: TrieProof
accountProof*: TrieProof
blockHash*: BlockHash
ContractTrieNodeRetrieval* = object
node*: TrieNode
ContractCodeOffer* = object
code*: Bytecode
accountProof*: TrieProof
blockHash*: BlockHash
ContractCodeRetrieval* = object
code*: Bytecode
OfferContentValueType* = enum
accountTrieNodeOffer
contractTrieNodeOffer
contractCodeOffer
OfferContentValue* = object
case contentType*: ContentType
of unused:
discard
of accountTrieNode:
accountTrieNode*: AccountTrieNodeOffer
of contractTrieNode:
contractTrieNode*: ContractTrieNodeOffer
of contractCode:
contractCode*: ContractCodeOffer
RetrievalContentValue* = object
case contentType*: ContentType
of unused:
discard
of accountTrieNode:
accountTrieNode*: AccountTrieNodeRetrieval
of contractTrieNode:
contractTrieNode*: ContractTrieNodeRetrieval
of contractCode:
contractCode*: ContractCodeRetrieval
func encode*(contentKey: ContentKey): ByteList =
doAssert(contentKey.contentType != unused)
ByteList.init(SSZ.encode(contentKey))
proc readSszBytes*(data: openArray[byte], val: var ContentKey) {.raises: [SszError].} =
mixin readSszValue
if data.len() > 0 and data[0] == ord(unused):
raise newException(MalformedSszError, "SSZ selector is unused value")
readSszValue(data, val)
func decode*(contentKey: ByteList): Opt[ContentKey] =
try:
Opt.some(SSZ.decode(contentKey.asSeq(), ContentKey))
except SerializationError:
return Opt.none(ContentKey)
func toContentId*(contentKey: ByteList): ContentId =
# TODO: Should we try to parse the content key here for invalid ones?
let idHash = sha2.sha256.digest(contentKey.asSeq())
readUintBE[256](idHash.data)
func toContentId*(contentKey: ContentKey): ContentId =
toContentId(encode(contentKey))
func initAccountTrieNodeKey*(path: Nibbles, nodeHash: NodeHash): ContentKey =
ContentKey(
contentType: accountTrieNode,
accountTrieNodeKey: AccountTrieNodeKey(path: path, nodeHash: nodeHash),
)
func initContractTrieNodeKey*(
address: Address, path: Nibbles, nodeHash: NodeHash
): ContentKey =
ContentKey(
contentType: contractTrieNode,
contractTrieNodeKey:
ContractTrieNodeKey(address: address, path: path, nodeHash: nodeHash),
)
func initContractCodeKey*(address: Address, codeHash: CodeHash): ContentKey =
ContentKey(
contentType: contractCode,
contractCodeKey: ContractCodeKey(address: address, codeHash: codeHash),
)
func offerContentToRetrievalContent*(
offerContent: OfferContentValue
): RetrievalContentValue =
case offerContent.contentType
of unused:
raiseAssert "Converting content with unused content type"
of accountTrieNode:
RetrievalContentValue(
contentType: accountTrieNode,
accountTrieNode:
AccountTrieNodeRetrieval(node: offerContent.accountTrieNode.proof[^1]),
) # TODO implement properly
of contractTrieNode:
RetrievalContentValue(
contentType: contractTrieNode,
contractTrieNode:
ContractTrieNodeRetrieval(node: offerContent.contractTrieNode.storageProof[^1]),
) # TODO implement properly
of contractCode:
RetrievalContentValue(
contentType: contractCode,
contractCode: ContractCodeRetrieval(code: offerContent.contractCode.code),
)
func encode*(content: RetrievalContentValue): seq[byte] =
case content.contentType
of unused:
raiseAssert "Encoding content with unused content type"
of accountTrieNode:
SSZ.encode(content.accountTrieNode)
of contractTrieNode:
SSZ.encode(content.contractTrieNode)
of contractCode:
SSZ.encode(content.contractCode)
func init*(T: type Nibbles, packed: openArray[byte], isEven: bool): T =
doAssert(packed.len() <= MAX_PACKED_NIBBLES_LEN)
var output = newSeqOfCap[byte](packed.len() + 1)
if isEven:
output.add(0x00)
else:
doAssert(packed.len() > 0)
# set the first nibble to 1 and copy the second nibble from the input
output.add((packed[0] and 0x0F) or 0x10)
let startIdx = if isEven: 0 else: 1
for i in startIdx ..< packed.len():
output.add(packed[i])
Nibbles(output)
func packNibbles*(unpacked: openArray[byte]): Nibbles =
doAssert(
unpacked.len() <= MAX_UNPACKED_NIBBLES_LEN, "Can't pack more than 64 nibbles"
)
if unpacked.len() == 0:
return Nibbles(@[byte(0x00)])
let isEvenLength = unpacked.len() mod 2 == 0
var
output = newSeqOfCap[byte](unpacked.len() div 2 + 1)
highNibble = isEvenLength
currentByte: byte = 0
if isEvenLength:
output.add(0x00)
else:
currentByte = 0x10
for i, nibble in unpacked:
if highNibble:
currentByte = nibble shl 4
else:
output.add(currentByte or nibble)
currentByte = 0
highNibble = not highNibble
Nibbles(output)
func unpackNibbles*(packed: Nibbles): seq[byte] =
doAssert(packed.len() <= MAX_PACKED_NIBBLES_LEN, "Packed nibbles length is too long")
var output = newSeqOfCap[byte](packed.len() * 2)
for i, pair in packed:
if i == 0 and pair == 0x00:
continue
let
first = (pair and 0xF0) shr 4
second = pair and 0x0F
if i == 0 and first == 0x01:
output.add(second)
else:
output.add(first)
output.add(second)
output
export content_keys, content_values, nibbles

97
fluffy/network/state/state_gossip.nim Normal file
View File

@ -0,0 +1,97 @@
# Fluffy
# Copyright (c) 2021-2024 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
import
results,
chronos,
chronicles,
eth/common/eth_hash,
eth/common,
eth/p2p/discoveryv5/[protocol, enr],
../../database/content_db,
../history/history_network,
../wire/[portal_protocol, portal_stream],
./state_content
export results
logScope:
topics = "portal_state"
proc gossipOffer*(
p: PortalProtocol,
maybeSrcNodeId: Opt[NodeId],
decodedKey: AccountTrieNodeKey,
decodedValue: AccountTrieNodeOffer,
): Future[void] {.async.} =
var
nibbles = decodedKey.path.unpackNibbles()
proof = decodedValue.proof
# When nibbles is empty this means the root node was received. Recursive
# gossiping is finished.
if nibbles.len() == 0:
return
# TODO: Review this logic.
# Removing a single nibble will not work for extension nodes with multiple prefix nibbles
discard nibbles.pop()
discard (distinctBase proof).pop()
let
updatedValue = AccountTrieNodeOffer(proof: proof, blockHash: decodedValue.blockHash)
updatedNodeHash = keccakHash(distinctBase proof[^1])
encodedValue = SSZ.encode(updatedValue)
updatedKey =
AccountTrieNodeKey(path: nibbles.packNibbles(), nodeHash: updatedNodeHash)
encodedKey =
ContentKey(accountTrieNodeKey: updatedKey, contentType: accountTrieNode).encode()
await p.neighborhoodGossipDiscardPeers(
maybeSrcNodeId, ContentKeysList.init(@[encodedKey]), @[encodedValue]
)
proc gossipOffer*(
p: PortalProtocol,
maybeSrcNodeId: Opt[NodeId],
decodedKey: ContractTrieNodeKey,
decodedValue: ContractTrieNodeOffer,
): Future[void] {.async.} =
# TODO: Recursive gossiping for contract trie nodes
return
proc gossipOffer*(
p: PortalProtocol,
maybeSrcNodeId: Opt[NodeId],
decodedKey: ContractCodeKey,
decodedValue: ContractCodeOffer,
): Future[void] {.async.} =
# TODO: Recursive gossiping for bytecode?
return
# proc gossipContent*(
# p: PortalProtocol,
# maybeSrcNodeId: Opt[NodeId],
# contentKey: ByteList,
# decodedKey: ContentKey,
# contentValue: seq[byte],
# decodedValue: OfferContentValue,
# ): Future[void] {.async.} =
# case decodedKey.contentType
# of unused:
# raiseAssert "Gossiping content with unused content type"
# of accountTrieNode:
# await recursiveGossipAccountTrieNode(
# p, maybeSrcNodeId, decodedKey, decodedValue.accountTrieNode
# )
# of contractTrieNode:
# await recursiveGossipContractTrieNode(
# p, maybeSrcNodeId, decodedKey, decodedValue.contractTrieNode
# )
# of contractCode:
# await p.neighborhoodGossipDiscardPeers(
# maybeSrcNodeId, ContentKeysList.init(@[contentKey]), @[contentValue]
# )

388
fluffy/network/state/state_network.nim
View File

@ -16,7 +16,8 @@ import
../history/history_network,
../wire/[portal_protocol, portal_stream, portal_protocol_config],
./state_content,
./state_validation
./state_validation,
./state_gossip
export results
@ -35,228 +36,6 @@ type StateNetwork* = ref object
func toContentIdHandler(contentKey: ByteList): results.Opt[ContentId] =
ok(toContentId(contentKey))
func decodeKV*(
contentKey: ByteList, contentValue: seq[byte]
): Opt[(ContentKey, OfferContentValue)] =
const empty = Opt.none((ContentKey, OfferContentValue))
let
key = contentKey.decode().valueOr:
return empty
value =
case key.contentType
of unused:
return empty
of accountTrieNode:
let val = decodeSsz(contentValue, AccountTrieNodeOffer).valueOr:
return empty
OfferContentValue(contentType: accountTrieNode, accountTrieNode: val)
of contractTrieNode:
let val = decodeSsz(contentValue, ContractTrieNodeOffer).valueOr:
return empty
OfferContentValue(contentType: contractTrieNode, contractTrieNode: val)
of contractCode:
let val = decodeSsz(contentValue, ContractCodeOffer).valueOr:
return empty
OfferContentValue(contentType: contractCode, contractCode: val)
Opt.some((key, value))
func decodeValue*(
contentKey: ContentKey, contentValue: seq[byte]
): Opt[RetrievalContentValue] =
const empty = Opt.none(RetrievalContentValue)
let value =
case contentKey.contentType
of unused:
return empty
of accountTrieNode:
let val = decodeSsz(contentValue, AccountTrieNodeRetrieval).valueOr:
return empty
RetrievalContentValue(contentType: accountTrieNode, accountTrieNode: val)
of contractTrieNode:
let val = decodeSsz(contentValue, ContractTrieNodeRetrieval).valueOr:
return empty
RetrievalContentValue(contentType: contractTrieNode, contractTrieNode: val)
of contractCode:
let val = decodeSsz(contentValue, ContractCodeRetrieval).valueOr:
return empty
RetrievalContentValue(contentType: contractCode, contractCode: val)
Opt.some(value)
proc validateContent*(
n: StateNetwork, contentKey: ContentKey, contentValue: RetrievalContentValue
): bool =
doAssert(contentKey.contentType == contentValue.contentType)
let res =
case contentKey.contentType
of unused:
Result[void, string].err("Received content with unused content type")
of accountTrieNode:
validateFetchedAccountTrieNode(
contentKey.accountTrieNodeKey, contentValue.accountTrieNode
)
of contractTrieNode:
validateFetchedContractTrieNode(
contentKey.contractTrieNodeKey, contentValue.contractTrieNode
)
of contractCode:
validateFetchedContractCode(contentKey.contractCodeKey, contentValue.contractCode)
res.isOkOr:
warn "Validation of fetched content failed: ", error
res.isOk()
proc getContent*(n: StateNetwork, key: ContentKey): Future[Opt[seq[byte]]] {.async.} =
let
keyEncoded = encode(key)
contentId = toContentId(key)
contentInRange = n.portalProtocol.inRange(contentId)
# When the content id is in the radius range, try to look it up in the db.
if contentInRange:
let contentFromDB = n.contentDB.get(contentId)
if contentFromDB.isSome():
return contentFromDB
let content = await n.portalProtocol.contentLookup(keyEncoded, contentId)
if content.isNone():
return Opt.none(seq[byte])
let
contentResult = content.get()
decodedValue = decodeValue(key, contentResult.content).valueOr:
error "Unable to decode offered Key/Value"
return Opt.none(seq[byte])
if not validateContent(n, key, decodedValue):
return Opt.none(seq[byte])
# When content is found on the network and is in the radius range, store it.
if content.isSome() and contentInRange:
# TODO Add poke when working on state network
# TODO When working on state network, make it possible to pass different
# distance functions to store content
n.portalProtocol.storeContent(keyEncoded, contentId, contentResult.content)
# TODO: for now returning bytes, ultimately it would be nice to return proper
# domain types.
return Opt.some(contentResult.content)
proc getStateRootByBlockHash(
n: StateNetwork, hash: BlockHash
): Future[Opt[KeccakHash]] {.async.} =
if n.historyNetwork.isNone():
warn "History network is not available. Unable to get state root by block hash"
return Opt.none(KeccakHash)
let header = (await n.historyNetwork.get().getVerifiedBlockHeader(hash)).valueOr:
warn "Failed to get block header by hash", hash
return Opt.none(KeccakHash)
Opt.some(header.stateRoot)
proc validateContent*(
n: StateNetwork, contentKey: ContentKey, contentValue: OfferContentValue
): Future[Result[void, string]] {.async.} =
doAssert(contentKey.contentType == contentValue.contentType)
case contentKey.contentType
of unused:
Result[void, string].err("Received content with unused content type")
of accountTrieNode:
let stateRoot = (
await n.getStateRootByBlockHash(contentValue.accountTrieNode.blockHash)
).valueOr:
return Result[void, string].err("Failed to get state root by block hash")
validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValue.accountTrieNode
)
of contractTrieNode:
let stateRoot = (
await n.getStateRootByBlockHash(contentValue.contractTrieNode.blockHash)
).valueOr:
return Result[void, string].err("Failed to get state root by block hash")
validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValue.contractTrieNode
)
of contractCode:
let stateRoot = (
await n.getStateRootByBlockHash(contentValue.contractCode.blockHash)
).valueOr:
return Result[void, string].err("Failed to get state root by block hash")
validateOfferedContractCode(
stateRoot, contentKey.contractCodeKey, contentValue.contractCode
)
proc recursiveGossipAccountTrieNode(
p: PortalProtocol,
maybeSrcNodeId: Opt[NodeId],
decodedKey: ContentKey,
decodedValue: AccountTrieNodeOffer,
): Future[void] {.async.} =
var
nibbles = decodedKey.accountTrieNodeKey.path.unpackNibbles()
proof = decodedValue.proof
# When nibbles is empty this means the root node was received. Recursive
# gossiping is finished.
if nibbles.len() == 0:
return
discard nibbles.pop()
discard (distinctBase proof).pop()
let
updatedValue = AccountTrieNodeOffer(proof: proof, blockHash: decodedValue.blockHash)
updatedNodeHash = keccakHash(distinctBase proof[^1])
encodedValue = SSZ.encode(updatedValue)
updatedKey =
AccountTrieNodeKey(path: nibbles.packNibbles(), nodeHash: updatedNodeHash)
encodedKey =
ContentKey(accountTrieNodeKey: updatedKey, contentType: accountTrieNode).encode()
await neighborhoodGossipDiscardPeers(
p, maybeSrcNodeId, ContentKeysList.init(@[encodedKey]), @[encodedValue]
)
proc recursiveGossipContractTrieNode(
p: PortalProtocol,
maybeSrcNodeId: Opt[NodeId],
decodedKey: ContentKey,
decodedValue: ContractTrieNodeOffer,
): Future[void] {.async.} =
return
proc gossipContent*(
p: PortalProtocol,
maybeSrcNodeId: Opt[NodeId],
contentKey: ByteList,
decodedKey: ContentKey,
contentValue: seq[byte],
decodedValue: OfferContentValue,
): Future[void] {.async.} =
case decodedKey.contentType
of unused:
raiseAssert "Gossiping content with unused content type"
of accountTrieNode:
await recursiveGossipAccountTrieNode(
p, maybeSrcNodeId, decodedKey, decodedValue.accountTrieNode
)
of contractTrieNode:
await recursiveGossipContractTrieNode(
p, maybeSrcNodeId, decodedKey, decodedValue.contractTrieNode
)
of contractCode:
await p.neighborhoodGossipDiscardPeers(
maybeSrcNodeId, ContentKeysList.init(@[contentKey]), @[contentValue]
)
proc new*(
T: type StateNetwork,
baseProtocol: protocol.Protocol,
@ -290,34 +69,161 @@ proc new*(
historyNetwork: historyNetwork,
)
# TODO: implement content lookups for each type
proc getContent*(
n: StateNetwork, contentKey: ContentKey
): Future[Opt[seq[byte]]] {.async.} =
let
contentKeyBytes = contentKey.encode()
contentId = contentKeyBytes.toContentId()
contentInRange = n.portalProtocol.inRange(contentId)
# When the content id is in the radius range, try to look it up in the db.
if contentInRange:
let contentFromDB = n.contentDB.get(contentId)
if contentFromDB.isSome():
return contentFromDB
let
contentLookupResult = (
await n.portalProtocol.contentLookup(contentKeyBytes, contentId)
).valueOr:
return Opt.none(seq[byte])
contentValueBytes = contentLookupResult.content
case contentKey.contentType
of unused:
error "Received content with unused content type"
return Opt.none(seq[byte])
of accountTrieNode:
let contentValue = AccountTrieNodeRetrieval.decode(contentValueBytes).valueOr:
error "Unable to decode AccountTrieNodeRetrieval content value"
return Opt.none(seq[byte])
validateRetrieval(contentKey.accountTrieNodeKey, contentValue).isOkOr:
error "Validation of retrieval content failed: ", error
return Opt.none(seq[byte])
of contractTrieNode:
let contentValue = ContractTrieNodeRetrieval.decode(contentValueBytes).valueOr:
error "Unable to decode ContractTrieNodeRetrieval content value"
return Opt.none(seq[byte])
validateRetrieval(contentKey.contractTrieNodeKey, contentValue).isOkOr:
error "Validation of retrieval content failed: ", error
return Opt.none(seq[byte])
of contractCode:
let contentValue = ContractCodeRetrieval.decode(contentValueBytes).valueOr:
error "Unable to decode ContractCodeRetrieval content value"
return Opt.none(seq[byte])
validateRetrieval(contentKey.contractCodeKey, contentValue).isOkOr:
error "Validation of retrieval content failed: ", error
return Opt.none(seq[byte])
# When content is in the radius range, store it.
if contentInRange:
# TODO Add poke when working on state network
# TODO When working on state network, make it possible to pass different
# distance functions to store content
n.portalProtocol.storeContent(contentKeyBytes, contentId, contentValueBytes)
# TODO: for now returning bytes, ultimately it would be nice to return proper
# domain types.
return Opt.some(contentValueBytes)
func decodeKey(contentKey: ByteList): Opt[ContentKey] =
let key = ContentKey.decode(contentKey).valueOr:
return Opt.none(ContentKey)
Opt.some(key)
proc getStateRootByBlockHash(
n: StateNetwork, hash: BlockHash
): Future[Opt[KeccakHash]] {.async.} =
if n.historyNetwork.isNone():
warn "History network is not available. Unable to get state root by block hash"
return Opt.none(KeccakHash)
let header = (await n.historyNetwork.get().getVerifiedBlockHeader(hash)).valueOr:
warn "Failed to get block header by hash", hash
return Opt.none(KeccakHash)
Opt.some(header.stateRoot)
proc processOffer[K, V](
n: StateNetwork,
maybeSrcNodeId: Opt[NodeId],
contentKeyBytes: ByteList,
contentKey: K,
contentValue: V,
): Future[Result[void, string]] {.async.} =
mixin blockHash, validateOffer, toRetrievalValue, gossipOffer
let stateRoot = (await n.getStateRootByBlockHash(contentValue.blockHash)).valueOr:
return err("Failed to get state root by block hash")
let res = validateOffer(stateRoot, contentKey, contentValue)
if res.isErr():
return err("Received offered content failed validation: " & res.error())
let contentId = n.portalProtocol.toContentId(contentKeyBytes).valueOr:
return err("Received offered content with invalid content key")
n.portalProtocol.storeContent(
contentKeyBytes, contentId, contentValue.toRetrievalValue().encode()
)
info "Received offered content validated successfully", contentKeyBytes
await gossipOffer(n.portalProtocol, maybeSrcNodeId, contentKey, contentValue)
proc processContentLoop(n: StateNetwork) {.async.} =
try:
while true:
let (maybeSrcNodeId, contentKeys, contentValues) = await n.contentQueue.popFirst()
for i, contentValue in contentValues:
for i, contentValueBytes in contentValues:
let
contentKey = contentKeys[i]
(decodedKey, decodedValue) = decodeKV(contentKey, contentValue).valueOr:
error "Unable to decode offered Key/Value"
contentKeyBytes = contentKeys[i]
contentKey = decodeKey(contentKeyBytes).valueOr:
error "Unable to decode offered content key", contentKeyBytes
continue
(await n.validateContent(decodedKey, decodedValue)).isOkOr:
error "Received offered content failed validation", contentKey, error
continue
let
valueForRetrieval = decodedValue.offerContentToRetrievalContent().encode()
contentId = n.portalProtocol.toContentId(contentKey).valueOr:
error "Received offered content with invalid content key", contentKey
let offerRes =
case contentKey.contentType
of unused:
error "Received content with unused content type"
continue
of accountTrieNode:
let contentValue = AccountTrieNodeOffer.decode(contentValueBytes).valueOr:
error "Unable to decode offered AccountTrieNodeOffer content value"
continue
n.portalProtocol.storeContent(contentKey, contentId, valueForRetrieval)
info "Received offered content validated successfully", contentKey
await processOffer(
n, maybeSrcNodeId, contentKeyBytes, contentKey.accountTrieNodeKey,
contentValue,
)
of contractTrieNode:
let contentValue = ContractTrieNodeOffer.decode(contentValueBytes).valueOr:
error "Unable to decode offered ContractTrieNodeOffer content value"
continue
await gossipContent(
n.portalProtocol, maybeSrcNodeId, contentKey, decodedKey, contentValue,
decodedValue,
)
await processOffer(
n, maybeSrcNodeId, contentKeyBytes, contentKey.contractTrieNodeKey,
contentValue,
)
of contractCode:
let contentValue = ContractCodeOffer.decode(contentValueBytes).valueOr:
error "Unable to decode offered ContractCodeOffer content value"
continue
await processOffer(
n, maybeSrcNodeId, contentKeyBytes, contentKey.contractCodeKey,
contentValue,
)
if offerRes.isOk():
info "Offered content processed successfully", contentKeyBytes
else:
error "Offered content processing failed",
contentKeyBytes, error = offerRes.error()
except CancelledError:
trace "processContentLoop canceled"

50
fluffy/network/state/state_validation.nim
View File

@ -11,7 +11,7 @@ import
../../common/[common_types, common_utils],
./state_content
export results
export results, state_content
# private functions
@ -31,7 +31,7 @@ proc isValidNextNode(thisNodeRlp: Rlp, rlpIdx: int, nextNode: TrieNode): bool =
let hash = hashOrShortRlp.toBytes()
if hash.len() != 32:
return false
KeccakHash.init(hash)
KeccakHash.fromBytes(hash)
nextNode.hashEquals(nextHash)
@ -48,6 +48,23 @@ proc decodePrefix(nodePrefixRlp: Rlp): (byte, bool, Nibbles) =
(firstNibble.byte, isLeaf, nibbles)
proc rlpDecodeAccountTrieNode(accountNode: TrieNode): Result[Account, string] =
let accNodeRlp = rlpFromBytes(accountNode.asSeq())
if accNodeRlp.isEmpty() or accNodeRlp.listLen() != 2:
return err("invalid account trie node - malformed")
let accNodePrefixRlp = accNodeRlp.listElem(0)
if accNodePrefixRlp.isEmpty():
return err("invalid account trie node - empty prefix")
let (_, isLeaf, _) = decodePrefix(accNodePrefixRlp)
if not isLeaf:
return err("invalid account trie node - leaf prefix expected")
decodeRlp(accNodeRlp.listElem(1).toBytes(), Account)
# public functions
proc validateTrieProof*(
expectedRootHash: KeccakHash, path: Nibbles, proof: TrieProof
): Result[void, string] =
@ -122,24 +139,7 @@ proc validateTrieProof*(
else:
ok()
proc rlpDecodeAccountTrieNode(accountNode: TrieNode): Result[Account, string] =
let accNodeRlp = rlpFromBytes(accountNode.asSeq())
if accNodeRlp.isEmpty() or accNodeRlp.listLen() != 2:
return err("invalid account trie node - malformed")
let accNodePrefixRlp = accNodeRlp.listElem(0)
if accNodePrefixRlp.isEmpty():
return err("invalid account trie node - empty prefix")
let (_, isLeaf, _) = decodePrefix(accNodePrefixRlp)
if not isLeaf:
return err("invalid account trie node - leaf prefix expected")
decodeRlp(accNodeRlp.listElem(1).toBytes(), Account)
# public functions
proc validateFetchedAccountTrieNode*(
proc validateRetrieval*(
trustedAccountTrieNodeKey: AccountTrieNodeKey,
accountTrieNode: AccountTrieNodeRetrieval,
): Result[void, string] =
@ -148,7 +148,7 @@ proc validateFetchedAccountTrieNode*(
else:
err("hash of fetched account trie node doesn't match the expected node hash")
proc validateFetchedContractTrieNode*(
proc validateRetrieval*(
trustedContractTrieNodeKey: ContractTrieNodeKey,
contractTrieNode: ContractTrieNodeRetrieval,
): Result[void, string] =
@ -157,7 +157,7 @@ proc validateFetchedContractTrieNode*(
else:
err("hash of fetched contract trie node doesn't match the expected node hash")
proc validateFetchedContractCode*(
proc validateRetrieval*(
trustedContractCodeKey: ContractCodeKey, contractCode: ContractCodeRetrieval
): Result[void, string] =
if contractCode.code.hashEquals(trustedContractCodeKey.codeHash):
@ -165,7 +165,7 @@ proc validateFetchedContractCode*(
else:
err("hash of fetched bytecode doesn't match the expected code hash")
proc validateOfferedAccountTrieNode*(
proc validateOffer*(
trustedStateRoot: KeccakHash,
accountTrieNodeKey: AccountTrieNodeKey,
accountTrieNode: AccountTrieNodeOffer,
@ -177,7 +177,7 @@ proc validateOfferedAccountTrieNode*(
else:
err("hash of offered account trie node doesn't match the expected node hash")
proc validateOfferedContractTrieNode*(
proc validateOffer*(
trustedStateRoot: KeccakHash,
contractTrieNodeKey: ContractTrieNodeKey,
contractTrieNode: ContractTrieNodeOffer,
@ -198,7 +198,7 @@ proc validateOfferedContractTrieNode*(
else:
err("hash of offered contract trie node doesn't match the expected node hash")
proc validateOfferedContractCode*(
proc validateOffer*(
trustedStateRoot: KeccakHash,
contractCodeKey: ContractCodeKey,
contractCode: ContractCodeOffer,

1
fluffy/tests/state_network_tests/all_state_network_tests.nim
View File

@ -10,6 +10,7 @@
import
./test_state_content_keys,
./test_state_content_values,
./test_state_content_nibbles,
./test_state_network,
#./test_state_network_gossip,
./test_state_validation,

106
fluffy/tests/state_network_tests/test_state_content_keys.nim
View File

@ -14,90 +14,6 @@ import
const testVectorDir = "./vendor/portal-spec-tests/tests/mainnet/state/serialization/"
suite "State Content Keys":
test "Encode/decode empty nibbles":
const
expected = "00"
nibbles: seq[byte] = @[]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode zero nibble":
const
expected = "10"
nibbles: seq[byte] = @[0]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode one nibble":
const
expected = "11"
nibbles: seq[byte] = @[1]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode even nibbles":
const
expected = "008679e8ed"
nibbles: seq[byte] = @[8, 6, 7, 9, 14, 8, 14, 13]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode odd nibbles":
const
expected = "138679e8ed"
nibbles: seq[byte] = @[3, 8, 6, 7, 9, 14, 8, 14, 13]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode max length nibbles":
const
expected = "008679e8eda65bd257638cf8cf09b8238888947cc3c0bea2aa2cc3f1c4ac7a3002"
nibbles: seq[byte] =
@[
8, 6, 7, 9, 0xe, 8, 0xe, 0xd, 0xa, 6, 5, 0xb, 0xd, 2, 5, 7, 6, 3, 8, 0xc, 0xf,
8, 0xc, 0xf, 0, 9, 0xb, 8, 2, 3, 8, 8, 8, 8, 9, 4, 7, 0xc, 0xc, 3, 0xc, 0,
0xb, 0xe, 0xa, 2, 0xa, 0xa, 2, 0xc, 0xc, 3, 0xf, 1, 0xc, 4, 0xa, 0xc, 7, 0xa,
3, 0, 0, 2,
]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode AccountTrieNodeKey":
const file = testVectorDir & "account_trie_node_key.yaml"
@ -120,7 +36,7 @@ suite "State Content Keys":
encoded.asSeq() == testCase.content_key.hexToSeqByte()
encoded.toContentId().toBytesBE() == testCase.content_id.hexToSeqByte()
let decoded = encoded.decode()
let decoded = ContentKey.decode(encoded)
check:
decoded.isOk()
decoded.value().contentType == accountTrieNode
@ -151,7 +67,7 @@ suite "State Content Keys":
encoded.asSeq() == testCase.content_key.hexToSeqByte()
encoded.toContentId().toBytesBE() == testCase.content_id.hexToSeqByte()
let decoded = encoded.decode()
let decoded = ContentKey.decode(encoded)
check:
decoded.isOk()
decoded.value().contentType == contractTrieNode
@ -180,7 +96,7 @@ suite "State Content Keys":
encoded.asSeq() == testCase.content_key.hexToSeqByte()
encoded.toContentId().toBytesBE() == testCase.content_id.hexToSeqByte()
let decoded = encoded.decode()
let decoded = ContentKey.decode(encoded)
check:
decoded.isOk()
decoded.value().contentType == contractCode
@ -189,24 +105,24 @@ suite "State Content Keys":
test "Invalid prefix - 0 value":
let encoded = ByteList.init(@[byte 0x00])
let decoded = decode(encoded)
let decoded = ContentKey.decode(encoded)
check decoded.isNone()
check decoded.isErr()
test "Invalid prefix - before valid range":
let encoded = ByteList.init(@[byte 0x01])
let decoded = decode(encoded)
let decoded = ContentKey.decode(encoded)
check decoded.isNone()
check decoded.isErr()
test "Invalid prefix - after valid range":
let encoded = ByteList.init(@[byte 0x25])
let decoded = decode(encoded)
let decoded = ContentKey.decode(encoded)
check decoded.isNone()
check decoded.isErr()
test "Invalid key - empty input":
let encoded = ByteList.init(@[])
let decoded = decode(encoded)
let decoded = ContentKey.decode(encoded)
check decoded.isNone()
check decoded.isErr()

93
fluffy/tests/state_network_tests/test_state_content_nibbles.nim Normal file
View File

@ -0,0 +1,93 @@
# Fluffy
# Copyright (c) 2023-2024 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
import unittest2, stew/byteutils, ../../network/state/state_content
suite "State Content Nibbles":
test "Encode/decode empty nibbles":
const
expected = "00"
nibbles: seq[byte] = @[]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode zero nibble":
const
expected = "10"
nibbles: seq[byte] = @[0]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode one nibble":
const
expected = "11"
nibbles: seq[byte] = @[1]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode even nibbles":
const
expected = "008679e8ed"
nibbles: seq[byte] = @[8, 6, 7, 9, 14, 8, 14, 13]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode odd nibbles":
const
expected = "138679e8ed"
nibbles: seq[byte] = @[3, 8, 6, 7, 9, 14, 8, 14, 13]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles
test "Encode/decode max length nibbles":
const
expected = "008679e8eda65bd257638cf8cf09b8238888947cc3c0bea2aa2cc3f1c4ac7a3002"
nibbles: seq[byte] =
@[
8, 6, 7, 9, 0xe, 8, 0xe, 0xd, 0xa, 6, 5, 0xb, 0xd, 2, 5, 7, 6, 3, 8, 0xc, 0xf,
8, 0xc, 0xf, 0, 9, 0xb, 8, 2, 3, 8, 8, 8, 8, 9, 4, 7, 0xc, 0xc, 3, 0xc, 0,
0xb, 0xe, 0xa, 2, 0xa, 0xa, 2, 0xc, 0xc, 3, 0xf, 1, 0xc, 4, 0xa, 0xc, 7, 0xa,
3, 0, 0, 2,
]
packedNibbles = packNibbles(nibbles)
unpackedNibbles = unpackNibbles(packedNibbles)
let encoded = SSZ.encode(packedNibbles)
check:
encoded.toHex() == expected
unpackedNibbles == nibbles

26
fluffy/tests/state_network_tests/test_state_content_values.nim
View File

@ -30,11 +30,11 @@ suite "State Content Values":
blockHash = BlockHash.fromHex(testCase.block_hash)
proof =
TrieProof.init(testCase.proof.map((hex) => TrieNode.init(hex.hexToSeqByte())))
accountTrieNodeOffer = AccountTrieNodeOffer(blockHash: blockHash, proof: proof)
accountTrieNodeOffer = AccountTrieNodeOffer.init(proof, blockHash)
encoded = SSZ.encode(accountTrieNodeOffer)
encoded = accountTrieNodeOffer.encode()
expected = testCase.content_value.hexToSeqByte()
decoded = SSZ.decode(encoded, AccountTrieNodeOffer)
decoded = AccountTrieNodeOffer.decode(encoded).get()
check:
encoded == expected
@ -54,9 +54,9 @@ suite "State Content Values":
node = TrieNode.init(testCase.trie_node.hexToSeqByte())
accountTrieNodeRetrieval = AccountTrieNodeRetrieval(node: node)
encoded = SSZ.encode(accountTrieNodeRetrieval)
encoded = accountTrieNodeRetrieval.encode()
expected = testCase.content_value.hexToSeqByte()
decoded = SSZ.decode(encoded, AccountTrieNodeRetrieval)
decoded = AccountTrieNodeRetrieval.decode(encoded).get()
check:
encoded == expected
@ -86,9 +86,9 @@ suite "State Content Values":
blockHash: blockHash, storage_proof: storageProof, account_proof: accountProof
)
encoded = SSZ.encode(contractTrieNodeOffer)
encoded = contractTrieNodeOffer.encode()
expected = testCase.content_value.hexToSeqByte()
decoded = SSZ.decode(encoded, ContractTrieNodeOffer)
decoded = ContractTrieNodeOffer.decode(encoded).get()
check:
encoded == expected
@ -111,9 +111,9 @@ suite "State Content Values":
node = TrieNode.init(testCase.trie_node.hexToSeqByte())
contractTrieNodeRetrieval = ContractTrieNodeRetrieval(node: node)
encoded = SSZ.encode(contractTrieNodeRetrieval)
encoded = contractTrieNodeRetrieval.encode()
expected = testCase.content_value.hexToSeqByte()
decoded = SSZ.decode(encoded, ContractTrieNodeRetrieval)
decoded = ContractTrieNodeRetrieval.decode(encoded).get()
check:
encoded == expected
@ -140,9 +140,9 @@ suite "State Content Values":
contractCodeOffer =
ContractCodeOffer(code: code, blockHash: blockHash, accountProof: accountProof)
encoded = SSZ.encode(contractCodeOffer)
encoded = contractCodeOffer.encode()
expected = testCase.content_value.hexToSeqByte()
decoded = SSZ.decode(encoded, ContractCodeOffer)
decoded = ContractCodeOffer.decode(encoded).get()
check:
encoded == expected
@ -162,9 +162,9 @@ suite "State Content Values":
code = Bytecode.init(testCase.bytecode.hexToSeqByte())
contractCodeRetrieval = ContractCodeRetrieval(code: code)
encoded = SSZ.encode(contractCodeRetrieval)
encoded = contractCodeRetrieval.encode()
expected = testCase.content_value.hexToSeqByte()
decoded = SSZ.decode(encoded, ContractCodeRetrieval)
decoded = ContractCodeRetrieval.decode(encoded).get()
check:
encoded == expected

16
fluffy/tests/state_network_tests/test_state_network.nim
View File

@ -53,11 +53,8 @@ procSuite "State Network":
contentKey = ContentKey(
contentType: accountTrieNode, accountTrieNodeKey: accountTrieNodeKey
)
contentId = toContentId(contentKey)
value = RetrievalContentValue(
contentType: accountTrieNode,
accountTrieNode: AccountTrieNodeRetrieval(node: TrieNode.init(v)),
)
contentId = toContentId(contentKey.encode())
value = AccountTrieNodeRetrieval(node: TrieNode.init(v))
discard proto1.contentDB.put(
contentId, value.encode(), proto1.portalProtocol.localNode.id
@ -72,7 +69,7 @@ procSuite "State Network":
contentKey = ContentKey(
contentType: accountTrieNode, accountTrieNodeKey: accountTrieNodeKey
)
contentId = toContentId(contentKey)
contentId = toContentId(contentKey.encode())
# Note: GetContent and thus the lookup here is not really needed, as we
# only have to request data to one node.
@ -129,11 +126,8 @@ procSuite "State Network":
contentKey = ContentKey(
contentType: accountTrieNode, accountTrieNodeKey: accountTrieNodeKey
)
contentId = toContentId(contentKey)
value = RetrievalContentValue(
contentType: accountTrieNode,
accountTrieNode: AccountTrieNodeRetrieval(node: TrieNode.init(v)),
)
contentId = toContentId(contentKey.encode())
value = AccountTrieNodeRetrieval(node: TrieNode.init(v))
discard proto2.contentDB.put(
contentId, value.encode(), proto2.portalProtocol.localNode.id

24
fluffy/tests/state_network_tests/test_state_network_gossip.nim
View File

@ -13,7 +13,7 @@ import
eth/p2p/discoveryv5/protocol as discv5_protocol,
../../network/wire/[portal_protocol, portal_stream],
../../network/history/[history_content, history_network],
../../network/state/[state_content, state_network],
../../network/state/[state_content, state_network, state_gossip],
../../database/content_db,
.././test_helpers,
../../eth_data/yaml_utils
@ -74,7 +74,7 @@ procSuite "State Network Gossip":
header: ByteList.init(headerRlp), proof: BlockHeaderProof.init()
)
value = recursiveGossipSteps[0].content_value.hexToSeqByte()
decodedValue = SSZ.decode(value, AccountTrieNodeOffer)
decodedValue = AccountTrieNodeOffer.decode(value).get()
contentKey = history_content.ContentKey
.init(history_content.ContentType.blockHeader, decodedValue.blockHash)
.encode()
@ -89,28 +89,22 @@ procSuite "State Network Gossip":
nextNode = clients[i + 1]
key = ByteList.init(pair.content_key.hexToSeqByte())
decodedKey = state_content.decode(key).valueOr:
decodedKey = state_content.ContentKey.decode(key).valueOr:
raiseAssert "Cannot decode key"
nextKey = ByteList.init(recursiveGossipSteps[1].content_key.hexToSeqByte())
decodedNextKey = state_content.decode(nextKey).valueOr:
decodedNextKey = state_content.ContentKey.decode(nextKey).valueOr:
raiseAssert "Cannot decode key"
value = pair.content_value.hexToSeqByte()
decodedValue = SSZ.decode(value, AccountTrieNodeOffer)
offerValue =
OfferContentValue(contentType: accountTrieNode, accountTrieNode: decodedValue)
decodedValue = AccountTrieNodeOffer.decode(value).get()
nextValue = recursiveGossipSteps[1].content_value.hexToSeqByte()
nextDecodedValue = SSZ.decode(nextValue, AccountTrieNodeOffer)
nextOfferValue = OfferContentValue(
contentType: accountTrieNode, accountTrieNode: nextDecodedValue
)
nextRetrievalValue = nextOfferValue.offerContentToRetrievalContent().encode()
nextDecodedValue = AccountTrieNodeOffer.decode(nextValue).get()
nextRetrievalValue = nextDecodedValue.toRetrievalValue().encode()
if i == 0:
await currentNode.portalProtocol.gossipContent(
Opt.none(NodeId), key, decodedKey, value, offerValue
await currentNode.portalProtocol.gossipOffer(
Opt.none(NodeId), decodedKey.accountTrieNodeKey, decodedValue
)
await sleepAsync(100.milliseconds) #TODO figure out how to get rid of this sleep

346
fluffy/tests/state_network_tests/test_state_validation.nim
View File

@ -60,16 +60,14 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for testData in testCase:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueRetrieval = SSZ.decode(
testData.content_value_retrieval.hexToSeqByte(), AccountTrieNodeRetrieval
)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueRetrieval = AccountTrieNodeRetrieval
.decode(testData.content_value_retrieval.hexToSeqByte())
.get()
check:
validateFetchedAccountTrieNode(
contentKey.accountTrieNodeKey, contentValueRetrieval
)
.isOk()
validateRetrieval(contentKey.accountTrieNodeKey, contentValueRetrieval).isOk()
test "Validate invalid AccountTrieNodeRetrieval nodes":
const file = testVectorDir / "account_trie_node.yaml"
@ -78,16 +76,15 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for testData in testCase:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueRetrieval = SSZ.decode(
testData.content_value_retrieval.hexToSeqByte(), AccountTrieNodeRetrieval
)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueRetrieval = AccountTrieNodeRetrieval
.decode(testData.content_value_retrieval.hexToSeqByte())
.get()
contentValueRetrieval.node[^1] += 1 # Modify node hash
let res = validateFetchedAccountTrieNode(
contentKey.accountTrieNodeKey, contentValueRetrieval
)
let res = validateRetrieval(contentKey.accountTrieNodeKey, contentValueRetrieval)
check:
res.isErr()
res.error() ==
@ -100,16 +97,14 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for testData in testCase:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueRetrieval = SSZ.decode(
testData.content_value_retrieval.hexToSeqByte(), ContractTrieNodeRetrieval
)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueRetrieval = ContractTrieNodeRetrieval
.decode(testData.content_value_retrieval.hexToSeqByte())
.get()
check:
validateFetchedContractTrieNode(
contentKey.contractTrieNodeKey, contentValueRetrieval
)
.isOk()
validateRetrieval(contentKey.contractTrieNodeKey, contentValueRetrieval).isOk()
test "Validate invalid ContractTrieNodeRetrieval nodes":
const file = testVectorDir / "contract_storage_trie_node.yaml"
@ -118,16 +113,15 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for testData in testCase:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueRetrieval = SSZ.decode(
testData.content_value_retrieval.hexToSeqByte(), ContractTrieNodeRetrieval
)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueRetrieval = ContractTrieNodeRetrieval
.decode(testData.content_value_retrieval.hexToSeqByte())
.get()
contentValueRetrieval.node[^1] += 1 # Modify node hash
let res = validateFetchedContractTrieNode(
contentKey.contractTrieNodeKey, contentValueRetrieval
)
let res = validateRetrieval(contentKey.contractTrieNodeKey, contentValueRetrieval)
check:
res.isErr()
res.error() ==
@ -140,14 +134,14 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for testData in testCase:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueRetrieval = SSZ.decode(
testData.content_value_retrieval.hexToSeqByte(), ContractCodeRetrieval
)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueRetrieval = ContractCodeRetrieval
.decode(testData.content_value_retrieval.hexToSeqByte())
.get()
check:
validateFetchedContractCode(contentKey.contractCodeKey, contentValueRetrieval)
.isOk()
validateRetrieval(contentKey.contractCodeKey, contentValueRetrieval).isOk()
test "Validate invalid ContractCodeRetrieval nodes":
const file = testVectorDir / "contract_bytecode.yaml"
@ -156,15 +150,15 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for testData in testCase:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueRetrieval = SSZ.decode(
testData.content_value_retrieval.hexToSeqByte(), ContractCodeRetrieval
)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueRetrieval = ContractCodeRetrieval
.decode(testData.content_value_retrieval.hexToSeqByte())
.get()
contentValueRetrieval.code[^1] += 1 # Modify node hash
let res =
validateFetchedContractCode(contentKey.contractCodeKey, contentValueRetrieval)
let res = validateRetrieval(contentKey.contractCodeKey, contentValueRetrieval)
check:
res.isErr()
res.error() == "hash of fetched bytecode doesn't match the expected code hash"
@ -178,34 +172,30 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), AccountTrieNodeOffer)
AccountTrieNodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
check:
validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValueOffer
)
validateOffer(stateRoot, contentKey.accountTrieNodeKey, contentValueOffer)
.isOk()
if i == 1:
continue # second test case only has root node and no recursive gossip
let contentKey =
decode(testData.recursive_gossip.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer = SSZ.decode(
testData.recursive_gossip.content_value_offer.hexToSeqByte(),
AccountTrieNodeOffer,
)
let contentKey = ContentKey
.decode(testData.recursive_gossip.content_key.hexToSeqByte().ByteList)
.get()
let contentValueOffer = AccountTrieNodeOffer
.decode(testData.recursive_gossip.content_value_offer.hexToSeqByte())
.get()
check:
validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValueOffer
)
.isOk()
validateOffer(stateRoot, contentKey.accountTrieNodeKey, contentValueOffer).isOk()
test "Validate invalid AccountTrieNodeOffer nodes - bad state roots":
const file = testVectorDir / "account_trie_node.yaml"
@ -219,15 +209,15 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(stateRoots[i].hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(stateRoots[i].hexToSeqByte())
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), AccountTrieNodeOffer)
AccountTrieNodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
let res = validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.accountTrieNodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
@ -239,17 +229,17 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), AccountTrieNodeOffer)
AccountTrieNodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
contentValueOffer.proof[0][0] += 1.byte
let res = validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.accountTrieNodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
@ -257,33 +247,33 @@ suite "State Validation":
for i, testData in testCase:
if i == 1:
continue # second test case only has root node
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), AccountTrieNodeOffer)
AccountTrieNodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
contentValueOffer.proof[^2][^2] += 1.byte
let res = validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.accountTrieNodeKey, contentValueOffer)
check:
res.isErr()
"hash of next node doesn't match the expected" in res.error()
for i, testData in testCase:
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), AccountTrieNodeOffer)
AccountTrieNodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
contentValueOffer.proof[^1][^1] += 1.byte
let res = validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.accountTrieNodeKey, contentValueOffer)
check:
res.isErr()
@ -296,34 +286,31 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractTrieNodeOffer)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer = ContractTrieNodeOffer
.decode(testData.content_value_offer.hexToSeqByte())
.get()
check:
validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
.isOk()
if i == 1:
continue # second test case has no recursive gossip
let contentKey =
decode(testData.recursive_gossip.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer = SSZ.decode(
testData.recursive_gossip.content_value_offer.hexToSeqByte(),
ContractTrieNodeOffer,
)
let contentKey = ContentKey
.decode(testData.recursive_gossip.content_key.hexToSeqByte().ByteList)
.get()
let contentValueOffer = ContractTrieNodeOffer
.decode(testData.recursive_gossip.content_value_offer.hexToSeqByte())
.get()
check:
validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
.isOk()
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer).isOk()
test "Validate invalid ContractTrieNodeOffer nodes - bad state roots":
const file = testVectorDir / "contract_storage_trie_node.yaml"
@ -336,15 +323,15 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(stateRoots[i].hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(stateRoots[i].hexToSeqByte())
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractTrieNodeOffer)
ContractTrieNodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
let res = validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
@ -356,73 +343,75 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractTrieNodeOffer)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer = ContractTrieNodeOffer
.decode(testData.content_value_offer.hexToSeqByte())
.get()
contentValueOffer.accountProof[0][0] += 1.byte
let res = validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractTrieNodeOffer)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer = ContractTrieNodeOffer
.decode(testData.content_value_offer.hexToSeqByte())
.get()
contentValueOffer.storageProof[0][0] += 1.byte
let res = validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractTrieNodeOffer)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer = ContractTrieNodeOffer
.decode(testData.content_value_offer.hexToSeqByte())
.get()
contentValueOffer.accountProof[^1][^1] += 1.byte
check:
validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
.isErr()
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractTrieNodeOffer)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer = ContractTrieNodeOffer
.decode(testData.content_value_offer.hexToSeqByte())
.get()
contentValueOffer.storageProof[^1][^1] += 1.byte
check:
validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
.isErr()
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractTrieNodeOffer)
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer = ContractTrieNodeOffer
.decode(testData.content_value_offer.hexToSeqByte())
.get()
contentValueOffer.accountProof[^2][^2] += 1.byte
check:
validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
.isErr()
# Contract bytecode offer validation tests
@ -434,17 +423,15 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractCodeOffer)
ContractCodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
check:
validateOfferedContractCode(
stateRoot, contentKey.contractCodeKey, contentValueOffer
)
.isOk()
validateOffer(stateRoot, contentKey.contractCodeKey, contentValueOffer).isOk()
test "Validate invalid ContractCodeOffer nodes - bad state root":
const file = testVectorDir / "contract_bytecode.yaml"
@ -455,15 +442,14 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(stateRoots[i].hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(stateRoots[i].hexToSeqByte())
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractCodeOffer)
ContractCodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
let res = validateOfferedContractCode(
stateRoot, contentKey.contractCodeKey, contentValueOffer
)
let res = validateOffer(stateRoot, contentKey.contractCodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
@ -475,59 +461,57 @@ suite "State Validation":
raiseAssert "Cannot read test vector: " & error
for i, testData in testCase:
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractCodeOffer)
ContractCodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
contentValueOffer.accountProof[0][0] += 1.byte
let res = validateOfferedContractCode(
stateRoot, contentKey.contractCodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.contractCodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractCodeOffer)
ContractCodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
contentValueOffer.code[0] += 1.byte
let res = validateOfferedContractCode(
stateRoot, contentKey.contractCodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.contractCodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of offered bytecode doesn't match the expected code hash"
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractCodeOffer)
ContractCodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
contentValueOffer.accountProof[^1][^1] += 1.byte
check:
validateOfferedContractCode(
stateRoot, contentKey.contractCodeKey, contentValueOffer
)
.isErr()
validateOffer(stateRoot, contentKey.contractCodeKey, contentValueOffer).isErr()
block:
let contentKey = decode(testData.content_key.hexToSeqByte().ByteList).get()
let contentKey =
ContentKey.decode(testData.content_key.hexToSeqByte().ByteList).get()
var contentValueOffer =
SSZ.decode(testData.content_value_offer.hexToSeqByte(), ContractCodeOffer)
ContractCodeOffer.decode(testData.content_value_offer.hexToSeqByte()).get()
contentValueOffer.code[^1] += 1.byte
let res = validateOfferedContractCode(
stateRoot, contentKey.contractCodeKey, contentValueOffer
)
let res =
validateOffer(stateRoot, contentKey.contractCodeKey, contentValueOffer)
check:
res.isErr()
res.error() == "hash of offered bytecode doesn't match the expected code hash"
@ -549,17 +533,15 @@ suite "State Validation":
if i == 1:
continue
var stateRoot = KeccakHash.init(stateRoots[i].hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(stateRoots[i].hexToSeqByte())
for kv in testData.recursive_gossip:
let contentKey = decode(kv.content_key.hexToSeqByte().ByteList).get()
let contentKey = ContentKey.decode(kv.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(kv.content_value.hexToSeqByte(), AccountTrieNodeOffer)
AccountTrieNodeOffer.decode(kv.content_value.hexToSeqByte()).get()
check:
validateOfferedAccountTrieNode(
stateRoot, contentKey.accountTrieNodeKey, contentValueOffer
)
validateOffer(stateRoot, contentKey.accountTrieNodeKey, contentValueOffer)
.isOk()
test "Validate valid ContractTrieNodeOffer recursive gossip nodes":
@ -572,15 +554,13 @@ suite "State Validation":
if i != 1:
continue
var stateRoot = KeccakHash.init(testData.state_root.hexToSeqByte())
var stateRoot = KeccakHash.fromBytes(testData.state_root.hexToSeqByte())
for kv in testData.recursive_gossip:
let contentKey = decode(kv.content_key.hexToSeqByte().ByteList).get()
let contentKey = ContentKey.decode(kv.content_key.hexToSeqByte().ByteList).get()
let contentValueOffer =
SSZ.decode(kv.content_value.hexToSeqByte(), ContractTrieNodeOffer)
ContractTrieNodeOffer.decode(kv.content_value.hexToSeqByte()).get()
check:
validateOfferedContractTrieNode(
stateRoot, contentKey.contractTrieNodeKey, contentValueOffer
)
validateOffer(stateRoot, contentKey.contractTrieNodeKey, contentValueOffer)
.isOk()

22
fluffy/tests/state_network_tests/test_state_validation_genesis.nim
View File

@ -33,18 +33,15 @@ template checkValidProofsForExistingLeafs(
nodeHash: keccakHash(accountProof[^1].asSeq()),
)
accountTrieOffer = AccountTrieNodeOffer(proof: accountProof)
proofResult = validateOfferedAccountTrieNode(
accountState.rootHash(), accountTrieNodeKey, accountTrieOffer
)
proofResult =
validateOffer(accountState.rootHash(), accountTrieNodeKey, accountTrieOffer)
check proofResult.isOk()
let
contractCodeKey = ContractCodeKey(address: address, codeHash: acc.codeHash)
contractCode =
ContractCodeOffer(code: Bytecode.init(account.code), accountProof: accountProof)
codeResult = validateOfferedContractCode(
accountState.rootHash(), contractCodeKey, contractCode
)
codeResult = validateOffer(accountState.rootHash(), contractCodeKey, contractCode)
check codeResult.isOk()
if account.code.len() > 0:
@ -62,7 +59,7 @@ template checkValidProofsForExistingLeafs(
contractTrieOffer = ContractTrieNodeOffer(
storageProof: storageProof, accountProof: accountProof
)
proofResult = validateOfferedContractTrieNode(
proofResult = validateOffer(
accountState.rootHash(), contractTrieNodeKey, contractTrieOffer
)
check proofResult.isOk()
@ -85,9 +82,8 @@ template checkInvalidProofsWithBadValue(
accountProof[^1][^1] += 1 # bad account leaf value
let
accountTrieOffer = AccountTrieNodeOffer(proof: accountProof)
proofResult = validateOfferedAccountTrieNode(
accountState.rootHash(), accountTrieNodeKey, accountTrieOffer
)
proofResult =
validateOffer(accountState.rootHash(), accountTrieNodeKey, accountTrieOffer)
check proofResult.isErr()
let
@ -96,9 +92,7 @@ template checkInvalidProofsWithBadValue(
code: Bytecode.init(@[1u8, 2, 3]), # bad code value
accountProof: accountProof,
)
codeResult = validateOfferedContractCode(
accountState.rootHash(), contractCodeKey, contractCode
)
codeResult = validateOffer(accountState.rootHash(), contractCodeKey, contractCode)
check codeResult.isErr()
if account.code.len() > 0:
@ -118,7 +112,7 @@ template checkInvalidProofsWithBadValue(
contractTrieOffer = ContractTrieNodeOffer(
storageProof: storageProof, accountProof: accountProof
)
proofResult = validateOfferedContractTrieNode(
proofResult = validateOffer(
accountState.rootHash(), contractTrieNodeKey, contractTrieOffer
)
check proofResult.isErr()

72
fluffy/tests/state_network_tests/test_state_validation_trieproof.nim
View File

@ -16,7 +16,7 @@ import
stint,
nimcrypto/hash,
eth/trie/[hexary, db, trie_defs],
../../network/state/state_validation,
../../network/state/[state_content, state_validation],
./state_test_helpers
proc getKeyBytes(i: int): seq[byte] =
@ -88,8 +88,8 @@ suite "MPT trie proof verification":
check:
res.isOk()
test "Validate proof bytes":
var trie = initHexaryTrie(newMemoryDB(), isPruning = false)
test "Validate proof bytes - 3 keys":
var trie = initHexaryTrie(newMemoryDB())
trie.put("doe".toBytes, "reindeer".toBytes)
trie.put("dog".toBytes, "puppy".toBytes)
@ -101,35 +101,25 @@ suite "MPT trie proof verification":
let
key = "doe".toBytes
proof = trie.getTrieProof(key)
res = validateTrieProof(rootHash, key.asNibbles(), proof)
check:
res.isOk()
check validateTrieProof(rootHash, key.asNibbles(), proof).isOk()
block:
let
key = "dog".toBytes
proof = trie.getTrieProof(key)
res = validateTrieProof(rootHash, key.asNibbles(), proof)
check:
res.isOk()
check validateTrieProof(rootHash, key.asNibbles(), proof).isOk()
block:
let
key = "dogglesworth".toBytes
proof = trie.getTrieProof(key)
res = validateTrieProof(rootHash, key.asNibbles(), proof)
check:
res.isOk()
check validateTrieProof(rootHash, key.asNibbles(), proof).isOk()
block:
let
key = "dogg".toBytes
proof = trie.getTrieProof(key)
res = validateTrieProof(rootHash, key.asNibbles(), proof)
check:
res.isErr()
res.error() == "not enough nibbles to validate node prefix"
@ -139,7 +129,6 @@ suite "MPT trie proof verification":
key = "dogz".toBytes
proof = trie.getTrieProof(key)
res = validateTrieProof(rootHash, key.asNibbles(), proof)
check:
res.isErr()
res.error() == "path contains more nibbles than expected for proof"
@ -149,7 +138,6 @@ suite "MPT trie proof verification":
key = "doe".toBytes
proof = newSeq[seq[byte]]().asTrieProof()
res = validateTrieProof(rootHash, key.asNibbles(), proof)
check:
res.isErr()
res.error() == "proof is empty"
@ -159,7 +147,53 @@ suite "MPT trie proof verification":
key = "doe".toBytes
proof = @["aaa".toBytes, "ccc".toBytes].asTrieProof()
res = validateTrieProof(rootHash, key.asNibbles(), proof)
check:
res.isErr()
res.error() == "hash of proof root node doesn't match the expected root hash"
test "Validate proof bytes - 4 keys":
var trie = initHexaryTrie(newMemoryDB())
let
# leaf nodes
kv1 = "0xa7113550".hexToSeqByte()
kv2 = "0xa77d3370".hexToSeqByte()
kv3 = "0xa7f93650".hexToSeqByte()
kv4 = "0xa77d3970".hexToSeqByte()
kv5 = "".hexToSeqByte() # root/first extension node
kv6 = "0xa7".hexToSeqByte() # first branch node
# leaf nodes without key ending
kv7 = "0xa77d33".hexToSeqByte()
kv8 = "0xa77d39".hexToSeqByte()
# failure cases
kv9 = "0xa0".hexToSeqByte()
kv10 = "0xa77d".hexToSeqByte()
kv11 = "0xa71135".hexToSeqByte()
kv12 = "0xa711355000".hexToSeqByte()
kv13 = "0xa711".hexToSeqByte()
trie.put(kv1, kv1)
trie.put(kv2, kv2)
trie.put(kv3, kv3)
trie.put(kv4, kv4)
let rootHash = trie.rootHash
check:
validateTrieProof(rootHash, kv1.asNibbles(), trie.getTrieProof(kv1)).isOk()
validateTrieProof(rootHash, kv2.asNibbles(), trie.getTrieProof(kv2)).isOk()
validateTrieProof(rootHash, kv3.asNibbles(), trie.getTrieProof(kv3)).isOk()
validateTrieProof(rootHash, kv4.asNibbles(), trie.getTrieProof(kv4)).isOk()
validateTrieProof(rootHash, kv5.asNibbles(), trie.getTrieProof(kv5)).isOk()
validateTrieProof(rootHash, kv6.asNibbles(), trie.getTrieProof(kv6)).isOk()
validateTrieProof(rootHash, kv7.asNibbles(), trie.getTrieProof(kv7)).isOk()
validateTrieProof(rootHash, kv8.asNibbles(), trie.getTrieProof(kv8)).isOk()
validateTrieProof(rootHash, kv9.asNibbles(), trie.getTrieProof(kv9)).isErr()
validateTrieProof(rootHash, kv10.asNibbles(), trie.getTrieProof(kv10)).isErr()
validateTrieProof(rootHash, kv11.asNibbles(), trie.getTrieProof(kv11)).isErr()
validateTrieProof(rootHash, kv12.asNibbles(), trie.getTrieProof(kv12)).isErr()
validateTrieProof(rootHash, kv13.asNibbles(), trie.getTrieProof(kv13)).isErr()