Enum Node 

pub enum Node {
    Branch(Box<BranchNode>),
    Extension(ExtensionNode),
    Leaf(LeafNode),
}

A Node in an Ethereum Compatible Patricia Merkle Trie

Variants

Branch(Box<BranchNode>)

Extension(ExtensionNode)

Leaf(LeafNode)

Implementations

impl Node

pub fn get( &self, db: &dyn TrieDB, path: Nibbles, ) -> Result<Option<ValueRLP>, TrieError>

Retrieves a value from the subtrie originating from this node given its path

pub fn insert( &mut self, db: &dyn TrieDB, path: Nibbles, value: impl Into<ValueOrHash>, ) -> Result<(), TrieError>

Inserts a value into the subtrie originating from this node.

pub fn remove( &mut self, db: &dyn TrieDB, path: Nibbles, ) -> Result<(bool, Option<ValueRLP>), TrieError>

Removes a value from the subtrie originating from this node given its path Returns a bool indicating if the new subtrie is empty, and the removed value if it existed in the subtrie

pub fn get_path( &self, db: &dyn TrieDB, path: Nibbles, node_path: &mut Vec<Vec<u8>>, ) -> Result<(), TrieError>

Traverses own subtrie until reaching the node containing path Appends all encoded nodes traversed to node_path (including self) Only nodes with encoded len over or equal to 32 bytes are included

pub fn compute_hash(&self, crypto: &dyn Crypto) -> NodeHash

Computes the node’s hash

pub fn compute_hash_no_alloc( &self, buf: &mut Vec<u8>, crypto: &dyn Crypto, ) -> NodeHash

Computes the node’s hash

pub fn memoize_hashes(&self, buf: &mut Vec<u8>, crypto: &dyn Crypto)

Recursively memoizes the hashes of all nodes of the subtrie that has self as root (post-order traversal)

pub fn encode_subtrie( &self, encoded: &mut Vec<NodeRLP>, ) -> Result<(), TrieError>

Recursively encodes all embedded nodes of the subtrie that has self as root.

This won’t encode nodes which are not embedded in self.

Trait Implementations

impl Archive for Node

where Box<BranchNode>: Archive, ExtensionNode: Archive, LeafNode: Archive,

type Archived = ArchivedNode

The archived representation of this type.

type Resolver = NodeResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Self as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Node

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Node

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Node

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Node, __D> for Archived<Node>

where Box<BranchNode>: Archive, <Box<BranchNode> as Archive>::Archived: Deserialize<Box<BranchNode>, __D>, ExtensionNode: Archive, <ExtensionNode as Archive>::Archived: Deserialize<ExtensionNode, __D>, LeafNode: Archive, <LeafNode as Archive>::Archived: Deserialize<LeafNode, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Node, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl From<Box<BranchNode>> for Node

fn from(val: Box<BranchNode>) -> Self

Converts to this type from the input type.

impl From<BranchNode> for Node

fn from(val: BranchNode) -> Self

Converts to this type from the input type.

impl From<ExtensionNode> for Node

fn from(val: ExtensionNode) -> Self

Converts to this type from the input type.

impl From<LeafNode> for Node

fn from(val: LeafNode) -> Self

Converts to this type from the input type.

impl From<Node> for NodeRef

fn from(value: Node) -> Self

Converts to this type from the input type.

impl PartialEq for Node

fn eq(&self, other: &Node) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RLPDecode for Node

fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError>

fn decode(rlp: &[u8]) -> Result<Self, RLPDecodeError>

impl RLPEncode for Node

fn encode(&self, buf: &mut dyn BufMut)

fn length(&self) -> usize

fn encode_to_vec(&self) -> Vec<u8>

impl Serialize for Node

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for Node

where Box<BranchNode>: Serialize<__S>, ExtensionNode: Serialize<__S>, LeafNode: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for Node