Struct BranchNode 

pub struct BranchNode {
    pub choices: [NodeRef; 16],
    pub value: ValueRLP,
}

Branch Node of an an Ethereum Compatible Patricia Merkle Trie Contains the node’s value and the hash of its children nodes

Fields

choices: [NodeRef; 16]

value: ValueRLP

Implementations

impl BranchNode

pub const EMPTY_CHOICES: [NodeRef; 16]

Empty choice array for more convenient node-building

pub fn new(choices: [NodeRef; 16]) -> Self

Creates a new branch node given its children, without any stored value

pub const fn new_with_value(choices: [NodeRef; 16], value: ValueRLP) -> Self

Creates a new branch node given its children and value

pub fn update(&mut self, new_value: ValueRLP)

Updates the node’s path and value

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: ValueOrHash, ) -> Result<(), TrieError>

Inserts a value into the subtrie originating from this node

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

Removes a value from the subtrie originating from this node given its path Returns the new root of the subtrie (or a Mutated variant if the new root is self) and the removed value if it existed in the subtrie.

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, using the provided buffer

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

Trait Implementations

impl Archive for BranchNode

where [NodeRef; 16]: Archive, ValueRLP: Archive,

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.

type Archived = ArchivedBranchNode

The archived representation of this type.

type Resolver = BranchNodeResolver

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::Resolver, out: Place<Self::Archived>)

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

impl Clone for BranchNode

fn clone(&self) -> BranchNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BranchNode

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

Formats the value using the given formatter.

impl Default for BranchNode

fn default() -> BranchNode

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BranchNode

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<BranchNode, __D> for Archived<BranchNode>

where [NodeRef; 16]: Archive, <[NodeRef; 16] as Archive>::Archived: Deserialize<[NodeRef; 16], __D>, ValueRLP: Archive, <ValueRLP as Archive>::Archived: Deserialize<ValueRLP, __D>,

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

Deserializes using the given deserializer

impl From<BranchNode> for Node

fn from(val: BranchNode) -> Self

Converts to this type from the input type.

impl PartialEq for BranchNode

fn eq(&self, other: &BranchNode) -> 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 RLPEncode for BranchNode

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

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

fn length(&self) -> usize

impl Serialize for BranchNode

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 BranchNode

where [NodeRef; 16]: Serialize<__S>, ValueRLP: 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 BranchNode