refactor(core): remove dependency on thiserror (#426)

Author: xJonathanLEI

Cargo.lock

@@ -29,7 +29,6 @@ serde_json = { version = "1.0.96", default-features = false, features = ["alloc"
 serde_json_pythonic = { version = "0.1.2", default-features = false, features = ["alloc", "raw_value"] }
 serde_with = "2.3.2"
 sha3 = "0.10.7"
-thiserror = "1.0.40"
 
 [dev-dependencies]
 criterion = { version = "0.4.0", default-features = false }

starknet-core/Cargo.toml

@@ -2,25 +2,48 @@ use crate::types::FieldElement;
 
 pub use starknet_crypto::{pedersen_hash, ExtendedSignature, Signature};
 use starknet_crypto::{rfc6979_generate_k, sign, verify, SignError, VerifyError};
-use thiserror::Error;
 
-#[derive(Debug, Error)]
-pub enum EcdsaSignError {
-    #[error("message hash out of range")]
-    MessageHashOutOfRange,
-}
+mod errors {
+    use core::fmt::{Display, Formatter, Result};
+    use std::error::Error;
+
+    #[derive(Debug)]
+    pub enum EcdsaSignError {
+        MessageHashOutOfRange,
+    }
+
+    #[derive(Debug)]
+    pub enum EcdsaVerifyError {
+        MessageHashOutOfRange,
+        InvalidPublicKey,
+        SignatureROutOfRange,
+        SignatureSOutOfRange,
+    }
+
+    impl Error for EcdsaSignError {}
 
-#[derive(Debug, Error)]
-pub enum EcdsaVerifyError {
-    #[error("message hash out of range")]
-    MessageHashOutOfRange,
-    #[error("invalid public key")]
-    InvalidPublicKey,
-    #[error("signature r value out of range")]
-    SignatureROutOfRange,
-    #[error("signature s value out of range")]
-    SignatureSOutOfRange,
+    impl Display for EcdsaSignError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            match self {
+                Self::MessageHashOutOfRange => write!(f, "message hash out of range"),
+            }
+        }
+    }
+
+    impl Error for EcdsaVerifyError {}
+
+    impl Display for EcdsaVerifyError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            match self {
+                Self::MessageHashOutOfRange => write!(f, "message hash out of range"),
+                Self::InvalidPublicKey => write!(f, "invalid public key"),
+                Self::SignatureROutOfRange => write!(f, "signature r value out of range"),
+                Self::SignatureSOutOfRange => write!(f, "signature s value out of range"),
+            }
+        }
+    }
 }
+pub use errors::{EcdsaSignError, EcdsaVerifyError};
 
 pub fn compute_hash_on_elements(data: &[FieldElement]) -> FieldElement {
     let mut current_hash = FieldElement::ZERO;

starknet-core/src/crypto.rs

@@ -3,7 +3,7 @@
 //     https://github.com/xJonathanLEI/starknet-jsonrpc-codegen
 
 // Code generated with version:
-//     https://github.com/xJonathanLEI/starknet-jsonrpc-codegen#14c217ef55ee23dcba2a956ddecb6e4bb9d02bb9
+//     https://github.com/xJonathanLEI/starknet-jsonrpc-codegen#73397c9d87962949675bca8fdc08faa88aa8ffb4
 
 // Code generation requested but not implemented for these types:
 // - `BLOCK_ID`
@@ -986,49 +986,60 @@ pub struct SierraEntryPoint {
 }
 
 /// JSON-RPC error codes
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, thiserror::Error)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub enum StarknetError {
     /// Failed to write transaction
-    #[error("Failed to write transaction")]
     FailedToReceiveTransaction,
     /// Contract not found
-    #[error("Contract not found")]
     ContractNotFound,
     /// Block not found
-    #[error("Block not found")]
     BlockNotFound,
     /// Transaction hash not found
-    #[error("Transaction hash not found")]
     TransactionHashNotFound,
     /// Invalid transaction index in a block
-    #[error("Invalid transaction index in a block")]
     InvalidTransactionIndex,
     /// Class hash not found
-    #[error("Class hash not found")]
     ClassHashNotFound,
     /// Requested page size is too big
-    #[error("Requested page size is too big")]
     PageSizeTooBig,
     /// There are no blocks
-    #[error("There are no blocks")]
     NoBlocks,
     /// The supplied continuation token is invalid or unknown
-    #[error("The supplied continuation token is invalid or unknown")]
     InvalidContinuationToken,
     /// Too many keys provided in a filter
-    #[error("Too many keys provided in a filter")]
     TooManyKeysInFilter,
     /// Contract error
-    #[error("Contract error")]
     ContractError,
     /// Invalid contract class
-    #[error("Invalid contract class")]
     InvalidContractClass,
     /// Class already declared
-    #[error("Class already declared")]
     ClassAlreadyDeclared,
 }
 
+impl std::error::Error for StarknetError {}
+
+impl std::fmt::Display for StarknetError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::FailedToReceiveTransaction => write!(f, "Failed to write transaction"),
+            Self::ContractNotFound => write!(f, "Contract not found"),
+            Self::BlockNotFound => write!(f, "Block not found"),
+            Self::TransactionHashNotFound => write!(f, "Transaction hash not found"),
+            Self::InvalidTransactionIndex => write!(f, "Invalid transaction index in a block"),
+            Self::ClassHashNotFound => write!(f, "Class hash not found"),
+            Self::PageSizeTooBig => write!(f, "Requested page size is too big"),
+            Self::NoBlocks => write!(f, "There are no blocks"),
+            Self::InvalidContinuationToken => {
+                write!(f, "The supplied continuation token is invalid or unknown")
+            }
+            Self::TooManyKeysInFilter => write!(f, "Too many keys provided in a filter"),
+            Self::ContractError => write!(f, "Contract error"),
+            Self::InvalidContractClass => write!(f, "Invalid contract class"),
+            Self::ClassAlreadyDeclared => write!(f, "Class already declared"),
+        }
+    }
+}
+
 #[serde_as]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[cfg_attr(feature = "no_unknown_fields", serde(deny_unknown_fields))]

starknet-core/src/types/codegen.rs

@@ -238,27 +238,58 @@ pub enum EventFieldKind {
     Nested,
 }
 
-#[derive(Debug, thiserror::Error)]
-pub enum ComputeClassHashError {
-    #[error("invalid builtin name")]
-    InvalidBuiltinName,
-    #[error("json serialization error: {0}")]
-    Json(JsonError),
-}
+mod errors {
+    use core::fmt::{Display, Formatter, Result};
+    use std::error::Error;
+
+    #[derive(Debug)]
+    pub enum ComputeClassHashError {
+        InvalidBuiltinName,
+        Json(JsonError),
+    }
 
-#[derive(Debug, thiserror::Error)]
-pub enum CompressProgramError {
-    #[error("json serialization error: {0}")]
-    Json(JsonError),
-    #[error("compression io error: {0}")]
-    Io(std::io::Error),
-}
+    #[derive(Debug)]
+    pub enum CompressProgramError {
+        Json(JsonError),
+        Io(std::io::Error),
+    }
+
+    #[derive(Debug)]
+    pub struct JsonError {
+        pub(crate) message: String,
+    }
+
+    impl Error for ComputeClassHashError {}
 
-#[derive(Debug, thiserror::Error)]
-#[error("{message}")]
-pub struct JsonError {
-    pub(crate) message: String,
+    impl Display for ComputeClassHashError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            match self {
+                Self::InvalidBuiltinName => write!(f, "invalid builtin name"),
+                Self::Json(inner) => write!(f, "json serialization error: {}", inner),
+            }
+        }
+    }
+
+    impl Error for CompressProgramError {}
+
+    impl Display for CompressProgramError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            match self {
+                Self::Json(inner) => write!(f, "json serialization error: {}", inner),
+                Self::Io(inner) => write!(f, "compression io error: {}", inner),
+            }
+        }
+    }
+
+    impl Error for JsonError {}
+
+    impl Display for JsonError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            write!(f, "{}", self.message)
+        }
+    }
 }
+pub use errors::{CompressProgramError, ComputeClassHashError, JsonError};
 
 impl SierraClass {
     pub fn class_hash(&self) -> Result<FieldElement, ComputeClassHashError> {

starknet-core/src/types/contract/mod.rs

@@ -2,7 +2,6 @@ use crate::{crypto::compute_hash_on_elements, types::FieldElement};
 
 use sha3::{Digest, Keccak256};
 use starknet_crypto::pedersen_hash;
-use thiserror::Error;
 
 const DEFAULT_ENTRY_POINT_NAME: &str = "__default__";
 const DEFAULT_L1_ENTRY_POINT_NAME: &str = "__l1_default__";
@@ -36,25 +35,60 @@ pub struct UdcUniqueSettings {
     pub udc_contract_address: FieldElement,
 }
 
-#[derive(Debug, Error)]
-#[error("the provided name contains non-ASCII characters")]
-pub struct NonAsciiNameError;
+mod errors {
+    use core::fmt::{Display, Formatter, Result};
+    use std::error::Error;
 
-#[derive(Debug, Error)]
-pub enum CairoShortStringToFeltError {
-    #[error("Cairo string can only contain ASCII characters")]
-    NonAsciiCharacter,
-    #[error("short string exceeds maximum length of 31 characters")]
-    StringTooLong,
-}
+    #[derive(Debug)]
+    pub struct NonAsciiNameError;
+
+    #[derive(Debug)]
+    pub enum CairoShortStringToFeltError {
+        NonAsciiCharacter,
+        StringTooLong,
+    }
+
+    #[derive(Debug)]
+    pub enum ParseCairoShortStringError {
+        ValueOutOfRange,
+        UnexpectedNullTerminator,
+    }
+
+    impl Error for NonAsciiNameError {}
+
+    impl Display for NonAsciiNameError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            write!(f, "the provided name contains non-ASCII characters")
+        }
+    }
 
-#[derive(Debug, Error)]
-pub enum ParseCairoShortStringError {
-    #[error("field element value out of range")]
-    ValueOutOfRange,
-    #[error("unexpected null terminator")]
-    UnexpectedNullTerminator,
+    impl Error for CairoShortStringToFeltError {}
+
+    impl Display for CairoShortStringToFeltError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            match self {
+                Self::NonAsciiCharacter => {
+                    write!(f, "Cairo string can only contain ASCII characters")
+                }
+                Self::StringTooLong => {
+                    write!(f, "short string exceeds maximum length of 31 characters")
+                }
+            }
+        }
+    }
+
+    impl Error for ParseCairoShortStringError {}
+
+    impl Display for ParseCairoShortStringError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+            match self {
+                Self::ValueOutOfRange => write!(f, "field element value out of range"),
+                Self::UnexpectedNullTerminator => write!(f, "unexpected null terminator"),
+            }
+        }
+    }
 }
+pub use errors::{CairoShortStringToFeltError, NonAsciiNameError, ParseCairoShortStringError};
 
 /// A variant of eth-keccak that computes a value that fits in a Starknet field element.
 pub fn starknet_keccak(data: &[u8]) -> FieldElement {