perf(core,levm): remove some unnecessary clones and make functions const (#2438)

**Motivation**

Increase perfomance, improve code.
<!-- Why does this pull request exist? What are its goals? -->

**Description**

Some methods took Vec by value just to take it's length, requiring a
costly clone each time.

Some methods could be made const, if the compiler can make use of this
it may increase perfomance.

Changed a drain to a into_iter, which is simpler and has better
perfomance.

Aided by the following clippy command:
```
cargo clippy --all-features -- -D clippy::perfomance -D clippy::nursery -A clippy::use_self -A clippy::too_long_first_doc_paragraph -A clippy::derive_partial_eq_without_eq -A clippy::option_if_let_else
```

Author: edg-l

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### 2025-04-11
 
+- Removed some unnecessary clones and made some functions const: [2438](https://github.com/lambdaclass/ethrex/pull/2438)
+
 - Asyncify some DB read APIs, as well as its users [#2430](https://github.com/lambdaclass/ethrex/pull/2430)
 
 ### 2025-04-09

crates/common/rlp/error.rs

@@ -1,7 +1,7 @@
 use thiserror::Error;
 
 // TODO: improve errors
-#[derive(Debug, Error, PartialEq)]
+#[derive(Debug, Error, PartialEq, Eq)]
 pub enum RLPDecodeError {
     #[error("InvalidLength")]
     InvalidLength,

crates/common/rlp/structs.rs

@@ -95,7 +95,7 @@ impl<'a> Decoder<'a> {
 
     /// Finishes encoding the struct and returns the remaining bytes after the item.
     /// If the item's payload is not empty, returns an error.
-    pub fn finish(self) -> Result<&'a [u8], RLPDecodeError> {
+    pub const fn finish(self) -> Result<&'a [u8], RLPDecodeError> {
         if self.payload.is_empty() {
             Ok(self.remaining)
         } else {
@@ -104,13 +104,13 @@ impl<'a> Decoder<'a> {
     }
 
     /// Returns true if the decoder has finished decoding the given input
-    pub fn is_done(&self) -> bool {
+    pub const fn is_done(&self) -> bool {
         self.payload.is_empty()
     }
 
     /// Same as [`finish`](Self::finish), but discards the item's remaining payload
     /// instead of failing.
-    pub fn finish_unchecked(self) -> &'a [u8] {
+    pub const fn finish_unchecked(self) -> &'a [u8] {
         self.remaining
     }
 }

crates/common/trie/db.rs

@@ -17,7 +17,7 @@ pub struct InMemoryTrieDB {
 }
 
 impl InMemoryTrieDB {
-    pub fn new(map: Arc<Mutex<HashMap<Vec<u8>, Vec<u8>>>>) -> Self {
+    pub const fn new(map: Arc<Mutex<HashMap<Vec<u8>, Vec<u8>>>>) -> Self {
         Self { inner: map }
     }
     pub fn new_empty() -> Self {

crates/common/trie/nibbles.rs

@@ -15,7 +15,7 @@ pub struct Nibbles {
 
 impl Nibbles {
     /// Create `Nibbles` from  hex-encoded nibbles
-    pub fn from_hex(hex: Vec<u8>) -> Self {
+    pub const fn from_hex(hex: Vec<u8>) -> Self {
         Self { data: hex }
     }
 

crates/common/trie/node/branch.rs

@@ -43,7 +43,7 @@ impl BranchNode {
     }
 
     /// Creates a new branch node given its children and value
-    pub fn new_with_value(choices: Box<[NodeHash; 16]>, value: ValueRLP) -> Self {
+    pub const fn new_with_value(choices: Box<[NodeHash; 16]>, value: ValueRLP) -> Self {
         Self { choices, value }
     }
 

crates/common/trie/node/extension.rs

@@ -18,7 +18,7 @@ pub struct ExtensionNode {
 
 impl ExtensionNode {
     /// Creates a new extension node given its child hash and prefix
-    pub(crate) fn new(prefix: Nibbles, child: NodeHash) -> Self {
+    pub(crate) const fn new(prefix: Nibbles, child: NodeHash) -> Self {
         Self { prefix, child }
     }
 
@@ -60,8 +60,7 @@ impl ExtensionNode {
             let child_node = state
                 .get_node(self.child)?
                 .ok_or(TrieError::InconsistentTree)?;
-            let new_child_node =
-                child_node.insert(state, path.offset(match_index), value.clone())?;
+            let new_child_node = child_node.insert(state, path.offset(match_index), value)?;
             self.child = new_child_node.insert_self(state)?;
             Ok(self.into())
         } else if match_index == 0 {

crates/common/trie/node/leaf.rs

@@ -16,7 +16,7 @@ pub struct LeafNode {
 
 impl LeafNode {
     /// Creates a new leaf node and stores the given (path, value) pair
-    pub fn new(partial: Nibbles, value: ValueRLP) -> Self {
+    pub const fn new(partial: Nibbles, value: ValueRLP) -> Self {
         Self { partial, value }
     }
 
@@ -64,7 +64,7 @@ impl LeafNode {
                 // Create a branch node with self as a child and store the value in the branch node
                 // Branch { [Self,...], Value }
                 let mut choices = BranchNode::EMPTY_CHOICES;
-                choices[self_choice_idx] = self.clone().insert_self(state)?;
+                choices[self_choice_idx] = self.insert_self(state)?;
                 BranchNode::new_with_value(Box::new(choices), value)
             } else {
                 // Create a new leaf node and store the path and value in it
@@ -73,7 +73,7 @@ impl LeafNode {
                 let new_leaf = LeafNode::new(path.offset(match_index + 1), value);
                 let mut choices = BranchNode::EMPTY_CHOICES;
                 choices[new_leaf_choice_idx] = new_leaf.insert_self(state)?;
-                choices[self_choice_idx] = self.clone().insert_self(state)?;
+                choices[self_choice_idx] = self.insert_self(state)?;
                 BranchNode::new(Box::new(choices))
             };
 

crates/common/trie/rlp.rs

@@ -16,7 +16,7 @@ enum NodeType {
 }
 
 impl NodeType {
-    fn from_u8(val: u8) -> Option<Self> {
+    const fn from_u8(val: u8) -> Option<Self> {
         match val {
             0 => Some(Self::Branch),
             1 => Some(Self::Extension),

crates/common/trie/trie.rs

@@ -90,8 +90,7 @@ impl Trie {
             .flatten()
         {
             // If the trie is not empty, call the root node's insertion logic
-            let root_node =
-                root_node.insert(&mut self.state, Nibbles::from_bytes(&path), value.clone())?;
+            let root_node = root_node.insert(&mut self.state, Nibbles::from_bytes(&path), value)?;
             self.root = Some(root_node.insert_self(&mut self.state)?)
         } else {
             // If the trie is empty, just add a leaf.
@@ -195,7 +194,7 @@ impl Trie {
         // dedup
         // TODO: really inefficient, by making the traversing smarter we can avoid having
         // duplicates
-        let node_path: HashSet<_> = node_path.drain(..).collect();
+        let node_path: HashSet<_> = node_path.into_iter().collect();
         let node_path = Vec::from_iter(node_path);
         Ok((Some(root_node.encode_raw()), node_path))
     }