Struct ExtensionNode 

pub struct ExtensionNode {
    pub prefix: Nibbles,
    pub child: NodeRef,
}

Extension Node of an an Ethereum Compatible Patricia Merkle Trie Contains the node’s prefix and a its child node hash, doesn’t store any value

Fields

prefix: Nibbles

child: NodeRef

Implementations

impl ExtensionNode

pub const fn new(prefix: Nibbles, child: NodeRef) -> Self

Creates a new extension node given its child hash and prefix

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<Option<Node>, TrieError>

Inserts a value into the subtrie originating from this node and returns the new root of the subtrie. If the new root happens to be self (potentially mutated), returns None. Otherwise, returns Some(node).

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

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

pub fn take(&mut self) -> Self

Creates a new node by emptying self prefix and cloning the child ref

This is a way to “consume” the node when we just have a mutable reference to it

Trait Implementations

impl Archive for ExtensionNode

where Nibbles: Archive, NodeRef: 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 = ArchivedExtensionNode

The archived representation of this type.

type Resolver = ExtensionNodeResolver

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 ExtensionNode

fn clone(&self) -> ExtensionNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExtensionNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExtensionNode

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

where Nibbles: Archive, <Nibbles as Archive>::Archived: Deserialize<Nibbles, __D>, NodeRef: Archive, <NodeRef as Archive>::Archived: Deserialize<NodeRef, __D>,

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

Deserializes using the given deserializer

impl From<ExtensionNode> for Node

fn from(val: ExtensionNode) -> Self

Converts to this type from the input type.

impl PartialEq for ExtensionNode

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

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

fn length(&self) -> usize

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

impl Serialize for ExtensionNode

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 ExtensionNode

where Nibbles: Serialize<__S>, NodeRef: 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 ExtensionNode