feat: add generalized contract error with derive macro (#104)

Cargo.toml

@@ -7,6 +7,7 @@ error-stack = { version = "0.4.0", features = ["eyre"] }
 events = { version = "^0.1.0", path = "packages/events" }
 events-derive = { version = "^0.1.0", path = "packages/events-derive" }
 axelar-wasm-std = { version = "^0.1.0", path = "packages/axelar-wasm-std" }
+axelar-wasm-std-derive = { version = "^0.1.0", path = "packages/axelar-wasm-std-derive" }
 itertools = "0.11.0"
 voting-verifier = { version = "^0.1.0", path = "contracts/voting-verifier" }
 multisig = { version = "^0.1.0", path = "contracts/multisig" }

packages/axelar-wasm-std-derive/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "axelar-wasm-std-derive"
+version = "0.1.0"
+edition = "2021"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+proc-macro = true
+
+[dependencies]
+axelar-wasm-std = { workspace = true }
+error-stack = { workspace = true }
+quote = "1.0.33"
+report = { workspace = true }
+syn = "2.0.29"
+thiserror = { workspace = true }

packages/axelar-wasm-std-derive/src/lib.rs

@@ -0,0 +1,25 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::DeriveInput;
+
+#[proc_macro_derive(IntoContractError)]
+pub fn into_contract_error_derive(input: TokenStream) -> TokenStream {
+    let ast: DeriveInput = syn::parse(input).unwrap();
+
+    let name = &ast.ident;
+
+    let gen = quote! {
+        use axelar_wasm_std::ContractError as _ContractError;
+
+        impl From<#name> for _ContractError {
+            fn from(error: #name) -> Self {
+                use report::LoggableError;
+                use error_stack::report;
+
+                LoggableError::from(&report!(error)).into()
+            }
+        }
+    };
+
+    gen.into()
+}

packages/axelar-wasm-std-derive/tests/derive.rs

@@ -0,0 +1,14 @@
+use axelar_wasm_std::ContractError;
+use axelar_wasm_std_derive::IntoContractError;
+use thiserror::Error;
+
+#[derive(Error, Debug, IntoContractError)]
+enum TestError {
+    #[error("error")]
+    Something,
+}
+
+#[test]
+fn can_convert_error() {
+    _ = ContractError::from(TestError::Something);
+}

packages/axelar-wasm-std/Cargo.toml

@@ -32,8 +32,10 @@ cosmwasm-schema = "1.1.3"
 cosmwasm-std = "1.2.1"
 cosmwasm-storage = "1.1.3"
 cw-storage-plus = "1.1.0"
+error-stack = { workspace = true }
 flagset = { version = "0.4.3", features = ["serde"] }
 num-traits = { version = "0.2.14", default-features = false }
+report = { workspace = true }
 schemars = "0.8.10"
 serde = { version = "1.0.145", default-features = false, features = ["derive"] }
 serde_json = "1.0.89"

packages/axelar-wasm-std/src/error.rs

@@ -0,0 +1,11 @@
+use cosmwasm_std::StdError;
+use report::LoggableError;
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq)]
+pub enum ContractError {
+    #[error(transparent)]
+    Std(#[from] StdError),
+    #[error(transparent)]
+    Structured(#[from] LoggableError),
+}

packages/axelar-wasm-std/src/lib.rs

@@ -1,10 +1,12 @@
 pub use crate::{
+    error::ContractError,
     fn_ext::FnExt,
     snapshot::{Participant, Snapshot},
     threshold::Threshold,
 };
 
 pub mod counter;
+mod error;
 pub mod flagset;
 mod fn_ext;
 pub mod nonempty;

packages/report/src/loggable.rs

@@ -41,11 +41,6 @@ impl Display for LoggableError {
 
 impl Error for LoggableError {}
 
-#[derive(Valuable, PartialEq, Eq, Debug)]
-pub struct LoggableBacktrace {
-    pub lines: Vec<String>,
-}
-
 impl<T> From<&Report<T>> for LoggableError {
     fn from(report: &Report<T>) -> Self {
         let mut errors: Vec<LoggableError> = Vec::new();
@@ -93,6 +88,22 @@ impl<T> From<&Report<T>> for LoggableError {
     }
 }
 
+fn chain_causes(errors: Vec<LoggableError>) -> Option<LoggableError> {
+    errors
+        .into_iter()
+        // the outermost error appears first in the vector, so the iterator for the causal dependency needs to be reversed
+        .rev()
+        .fold(None, |acc: Option<LoggableError>, mut e: LoggableError| {
+            e.cause = acc.map(Box::new);
+            Some(e)
+        })
+}
+
+#[derive(Valuable, PartialEq, Eq, Debug)]
+pub struct LoggableBacktrace {
+    pub lines: Vec<String>,
+}
+
 impl From<&Backtrace> for LoggableBacktrace {
     fn from(backtrace: &Backtrace) -> Self {
         LoggableBacktrace {
@@ -105,17 +116,6 @@ impl From<&Backtrace> for LoggableBacktrace {
     }
 }
 
-fn chain_causes(errors: Vec<LoggableError>) -> Option<LoggableError> {
-    errors
-        .into_iter()
-        // the outermost error appears first in the vector, so the iterator for the causal dependency needs to be reversed
-        .rev()
-        .fold(None, |acc: Option<LoggableError>, mut e: LoggableError| {
-            e.cause = acc.map(Box::new);
-            Some(e)
-        })
-}
-
 enum FrameType<'a> {
     Context(&'a dyn Context),
     Location(&'a Location<'a>),