Method insert

crates/proof/mpt/src/node.rs:195–305

Inserts a [`TrieNode`] at the given path into the trie rooted at Self. ## Takes - `self` - The root trie node - `path` - The nibbles representation of the path to the leaf node - `node` - The node to insert at the given path - `fetcher` - The preimage fetcher for intermediate blinded nodes ## Returns - `Err(_)` - Could not insert the node at the given path in the trie. - `Ok(())` - The node was

(
        &mut self,
        path: &Nibbles,
        value: Bytes,
        fetcher: &F,
    )

    /// - `Err(_)` - Could not insert the node at the given path in the trie.
    /// - `Ok(())` - The node was successfully inserted at the given path.
    pub fn insert<F: TrieProvider>(
        &mut self,
        path: &Nibbles,
        value: Bytes,
        fetcher: &F,
    ) -> TrieNodeResult<()> {
        match self {
            Self::Empty => {
                // If the trie node is null, insert the leaf node at the current path.
                *self = Self::Leaf { prefix: *path, value };
                Ok(())
            }
            Self::Leaf { prefix, value: leaf_value } => {
                let shared_extension_nibbles = path.common_prefix_length(prefix);

                // If all nibbles are shared, update the leaf node with the new value.
                if path == prefix {
                    *self = Self::Leaf { prefix: *prefix, value };
                    return Ok(());
                }

                // Create a branch node stack containing the leaf node and the new value.
                let mut stack = vec![Self::Empty; BRANCH_LIST_LENGTH];

                // Insert the shortened extension into the branch stack.
                let extension_nibble =
                    prefix.get(shared_extension_nibbles).ok_or(TrieNodeError::PathTooShort)?
                        as usize;
                stack[extension_nibble] = Self::Leaf {
                    prefix: prefix.slice(shared_extension_nibbles + BRANCH_NODE_NIBBLES..),
                    value: leaf_value.clone(),
                };

                // Insert the new value into the branch stack.
                let branch_nibble_new =
                    path.get(shared_extension_nibbles).ok_or(TrieNodeError::PathTooShort)? as usize;
                stack[branch_nibble_new] = Self::Leaf {
                    prefix: path.slice(shared_extension_nibbles + BRANCH_NODE_NIBBLES..),
                    value,
                };

                // Replace the leaf node with the branch if no nibbles are shared, else create an
                // extension.
                if shared_extension_nibbles == 0 {
                    *self = Self::Branch { stack };
                } else {
                    let raw_ext_nibbles = path.slice(..shared_extension_nibbles);
                    *self = Self::Extension {
                        prefix: raw_ext_nibbles,
                        node: Box::new(Self::Branch { stack }),
                    };
                }
                Ok(())
            }
            Self::Extension { prefix, node } => {
                let shared_extension_nibbles = path.common_prefix_length(prefix);
                if shared_extension_nibbles == prefix.len() {
                    node.insert(&path.slice(shared_extension_nibbles..), value, fetcher)?;