Struct merkle_trees::merkle_patricia_trie::MerklePatriciaTrie

pub struct MerklePatriciaTrie<V, H, S: Clone + KnownLength, NS, NH> where
    NS: PatriciaTrieNodeSerializer<H, V, S>,
    NH: NodeHasher<S, H>,  {
    pub root_node: NodeType<H, V>,
    pub phantom_1: PhantomData<V>,
    pub phantom_2: PhantomData<S>,
    // some fields omitted
}

Fields

root_node: NodeType<H, V>

phantom_1: PhantomData<V>

phantom_2: PhantomData<S>

Methods

impl<V: Clone + Default + Eq, H: Clone, S: Clone + KnownLength, NS, NH> MerklePatriciaTrie<V, H, S, NS, NH> where
    NS: PatriciaTrieNodeSerializer<H, V, S>,
    NH: NodeHasher<S, H>, 

pub fn new(hasher: NH, node_serializer: NS) -> Result<Self, MerkleTreeError>

Create a new empty trie

pub fn initialize_with_root_hash(
    hasher: NH,
    node_serializer: NS,
    root_hash: &H,
    hash_db: &mut dyn HashValueDb<H, S>
) -> Result<Self, MerkleTreeError>

Initialize a trie with a given root hash and database. The root hash must be present in the database.

pub fn get_root_hash(&self) -> Result<H, MerkleTreeError>

pub fn get(
    &self,
    key: &dyn Key,
    proof: &mut Option<Vec<NodeType<H, V>>>,
    hash_db: &dyn HashValueDb<H, S>
) -> Result<V, MerkleTreeError>

Get value of the given key. If proof is not None, it is populated with a proof.

pub fn get_from_tree_with_root(
    &self,
    tree_root: &NodeType<H, V>,
    key: &dyn Key,
    proof: &mut Option<Vec<NodeType<H, V>>>,
    hash_db: &dyn HashValueDb<H, S>
) -> Result<V, MerkleTreeError>

Get value of the given key in a tree with root tree_root. If proof is not None, it is populated with a proof.

pub fn insert(
    &mut self,
    key: &dyn Key,
    value: V,
    hash_db: &mut dyn HashValueDb<H, S>
) -> Result<H, MerkleTreeError>

Insert a key-value into the trie.

pub fn verify_proof(
    key: &dyn Key,
    value: &V,
    proof: Vec<NodeType<H, V>>,
    hasher: NH,
    node_serializer: NS,
    root_hash: &H,
    hash_db: &mut dyn HashValueDb<H, S>
) -> Result<bool, MerkleTreeError>

Verify that a tree with root hash root_hash has a key key with value value

pub fn get_key_values<K>(
    &self,
    root_node: &NodeType<H, V>,
    proof: &mut Option<Vec<NodeType<H, V>>>,
    hash_db: &dyn HashValueDb<H, S>,
    nibbles_to_key: &dyn Fn(&[u8]) -> K
) -> Result<Vec<(K, V)>, MerkleTreeError>

Get all key-value pairs in a tree with root root_node. If proof is not None, it is populated with a proof. The argument nibbles_to_key is a function to convert nibbles to keys. Don't want to require Key trait to have a nibble_to_key function as this function might not be needed by all implementations.

pub fn get_keys_values_with_prefix<K>(
    &self,
    prefix_key: &dyn Key,
    node: &NodeType<H, V>,
    proof: &mut Option<Vec<NodeType<H, V>>>,
    hash_db: &dyn HashValueDb<H, S>,
    nibbles_to_key: &dyn Fn(&[u8]) -> K
) -> Result<Vec<(K, V)>, MerkleTreeError>

Get all key-value pairs in a tree with root root_node and prefix prefix_key. If proof is not None, it is populated with a proof.

pub fn verify_proof_multiple_keys(
    keys: Vec<&dyn Key>,
    values: &[V],
    proof: Vec<NodeType<H, V>>,
    hasher: NH,
    node_serializer: NS,
    root_hash: &H,
    hash_db: &mut dyn HashValueDb<H, S>
) -> Result<bool, MerkleTreeError>

Trait Implementations

impl<V: Clone, H: Clone, S: Clone + KnownLength, NS: Clone, NH: Clone> Clone for MerklePatriciaTrie<V, H, S, NS, NH> where
    NS: PatriciaTrieNodeSerializer<H, V, S>,
    NH: NodeHasher<S, H>, 

fn clone(&self) -> MerklePatriciaTrie<V, H, S, NS, NH>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, H: Debug, S: Debug + Clone + KnownLength, NS: Debug, NH: Debug> Debug for MerklePatriciaTrie<V, H, S, NS, NH> where
    NS: PatriciaTrieNodeSerializer<H, V, S>,
    NH: NodeHasher<S, H>, 

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

Formats the value using the given formatter.

impl<'de, V, H, S: Clone + KnownLength, NS, NH> Deserialize<'de> for MerklePatriciaTrie<V, H, S, NS, NH> where
    NS: PatriciaTrieNodeSerializer<H, V, S>,
    NH: NodeHasher<S, H>,
    V: Deserialize<'de>,
    H: Deserialize<'de>,
    NS: Deserialize<'de>,
    NH: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<V, H, S: Clone + KnownLength, NS, NH> Serialize for MerklePatriciaTrie<V, H, S, NS, NH> where
    NS: PatriciaTrieNodeSerializer<H, V, S>,
    NH: NodeHasher<S, H>,
    V: Serialize,
    H: Serialize,
    NS: Serialize,
    NH: Serialize, 

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

Serialize this value into the given Serde serializer.