Introduce consistent typed error handling

crates/imt/Cargo.toml

@@ -8,4 +8,5 @@ description = "Incremental Merkle Tree"
 
 [dependencies]
 hex = "0.4.3"
+thiserror = "2"
 tiny-keccak = { version = "2.0.0", features = ["keccak"] }

crates/imt/src/errors.rs

@@ -0,0 +1,16 @@
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq, Eq)]
+pub enum ImtError {
+    #[error("Too many leaves: got {got}, max for arity {arity} and depth {depth} is max {max}")]
+    TooManyLeaves {
+        got: usize,
+        arity: usize,
+        depth: usize,
+        max: usize,
+    },
+    #[error("The tree is full")]
+    TreeFull,
+    #[error("The leaf does not exist in this tree")]
+    NotContained,
+}

crates/imt/src/imt.rs

@@ -1,3 +1,5 @@
+use crate::errors::ImtError;
+
 pub struct IMT {
     nodes: Vec<Vec<IMTNode>>,
     zeroes: Vec<IMTNode>,
@@ -23,9 +25,16 @@ impl IMT {
         zero_value: IMTNode,
         arity: usize,
         leaves: Vec<IMTNode>,
-    ) -> Result<IMT, &'static str> {
-        if leaves.len() > arity.pow(depth as u32) {
-            return Err("The tree cannot contain more than arity^depth leaves");
+    ) -> Result<IMT, ImtError> {
+        let got = leaves.len();
+        let max = arity.pow(depth as u32);
+        if got > max {
+            return Err(ImtError::TooManyLeaves {
+                got,
+                arity,
+                depth,
+                max,
+            });
         }
 
         let mut imt = IMT {
@@ -93,19 +102,19 @@ impl IMT {
         self.nodes.get(0)?.iter().position(|n| n == &leaf)
     }
 
-    pub fn insert(&mut self, leaf: IMTNode) -> Result<(), &'static str> {
+    pub fn insert(&mut self, leaf: IMTNode) -> Result<(), ImtError> {
         if self.nodes[0].len() >= self.arity.pow(self.depth as u32) {
-            return Err("The tree is full");
+            return Err(ImtError::TreeFull);
         }
 
         let index = self.nodes[0].len();
         self.nodes[0].push(leaf);
         self.update(index, self.nodes[0][index].clone())
     }
 
-    pub fn update(&mut self, mut index: usize, new_leaf: IMTNode) -> Result<(), &'static str> {
+    pub fn update(&mut self, mut index: usize, new_leaf: IMTNode) -> Result<(), ImtError> {
         if index >= self.nodes[0].len() {
-            return Err("The leaf does not exist in this tree");
+            return Err(ImtError::NotContained);
         }
 
         let mut node = new_leaf;
@@ -138,13 +147,13 @@ impl IMT {
         Ok(())
     }
 
-    pub fn delete(&mut self, index: usize) -> Result<(), &'static str> {
+    pub fn delete(&mut self, index: usize) -> Result<(), ImtError> {
         self.update(index, self.zeroes[0].clone())
     }
 
-    pub fn create_proof(&self, index: usize) -> Result<IMTMerkleProof, &'static str> {
+    pub fn create_proof(&self, index: usize) -> Result<IMTMerkleProof, ImtError> {
         if index >= self.nodes[0].len() {
-            return Err("The leaf does not exist in this tree");
+            return Err(ImtError::NotContained);
         }
 
         let mut siblings = Vec::with_capacity(self.depth);

crates/imt/src/lib.rs

@@ -1,2 +1,5 @@
+pub mod errors;
 pub mod hash;
 pub mod imt;
+
+pub use errors::ImtError;

crates/smt/Cargo.toml

@@ -10,3 +10,4 @@ description = "Sparse Merkle Tree"
 
 [dependencies]
 num-bigint = "0.4.6"
+thiserror = "2"

crates/smt/src/errors.rs

@@ -0,0 +1,13 @@
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq, Eq)]
+pub enum SMTError {
+    #[error("Key {0} already exists")]
+    KeyAlreadyExist(String),
+    #[error("Key {0} does not exist")]
+    KeyDoesNotExist(String),
+    #[error("Parameter {name} must be a {expected_type}")]
+    InvalidParameterType { name: String, expected_type: String },
+    #[error("Invalid sibling index")]
+    InvalidSiblingIndex,
+}

crates/smt/src/lib.rs

@@ -1,2 +1,5 @@
+pub mod errors;
 pub mod smt;
 mod utils;
+
+pub use errors::SMTError;

crates/smt/src/smt.rs

@@ -2,35 +2,13 @@ use std::{collections::HashMap, str::FromStr};
 
 use num_bigint::BigInt;
 
+pub use crate::errors::SMTError;
 use crate::utils::{
     get_first_common_elements, get_index_of_last_non_zero_element, is_hexadecimal, key_to_path,
 };
 
 use std::fmt;
 
-#[derive(Debug, PartialEq)]
-pub enum SMTError {
-    KeyAlreadyExist(String),
-    KeyDoesNotExist(String),
-    InvalidParameterType(String, String),
-    InvalidSiblingIndex,
-}
-
-impl fmt::Display for SMTError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            SMTError::KeyAlreadyExist(s) => write!(f, "Key {} already exists", s),
-            SMTError::KeyDoesNotExist(s) => write!(f, "Key {} does not exist", s),
-            SMTError::InvalidParameterType(p, t) => {
-                write!(f, "Parameter {} must be a {}", p, t)
-            },
-            SMTError::InvalidSiblingIndex => write!(f, "Invalid sibling index"),
-        }
-    }
-}
-
-impl std::error::Error for SMTError {}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Node {
     Str(String),
@@ -55,10 +33,10 @@ impl FromStr for Node {
         } else if is_hexadecimal(s) {
             Ok(Node::Str(s.to_string()))
         } else {
-            Err(SMTError::InvalidParameterType(
-                s.to_string(),
-                "BigInt or hexadecimal string".to_string(),
-            ))
+            Err(SMTError::InvalidParameterType {
+                name: s.to_string(),
+                expected_type: "BigInt or hexadecimal string".to_string(),
+            })
         }
     }
 }