SolidityError derive macro

examples/erc20/src/erc20.rs

@@ -1,4 +1,4 @@
-use alloc::{string::String, vec::Vec};
+use alloc::string::String;
 use core::marker::PhantomData;
 use stylus_sdk::{
     alloy_primitives::{Address, U256},
@@ -36,21 +36,12 @@ sol! {
     error InsufficientAllowance(address owner, address spender, uint256 have, uint256 want);
 }
 
+#[derive(SolidityError)]
 pub enum Erc20Error {
     InsufficientBalance(InsufficientBalance),
     InsufficientAllowance(InsufficientAllowance),
 }
 
-// We will soon provide a #[derive(SolidityError)] to clean this up
-impl From<Erc20Error> for Vec<u8> {
-    fn from(err: Erc20Error) -> Vec<u8> {
-        match err {
-            Erc20Error::InsufficientBalance(e) => e.encode(),
-            Erc20Error::InsufficientAllowance(e) => e.encode(),
-        }
-    }
-}
-
 // These methods aren't exposed to other contracts
 // Note: modifying storage will become much prettier soon
 impl<T: Erc20Params> Erc20<T> {

stylus-proc/src/lib.rs

@@ -264,6 +264,12 @@ pub fn derive_erase(input: TokenStream) -> TokenStream {
     storage::derive_erase(input)
 }
 
+/// For an error type `E`, implement `From<E>` for `Vec<u8>`.
+#[proc_macro_derive(SolidityError)]
+pub fn derive_solidity_error(input: TokenStream) -> TokenStream {
+    storage::derive_solidity_error(input)
+}
+
 /// Defines the entrypoint, which is where Stylus execution begins.
 /// Without it the contract will fail to pass [`cargo stylus check`][check].
 /// Most commonly this macro is used to annotate the top level storage `struct`.

stylus-proc/src/storage/mod.rs

@@ -5,7 +5,7 @@ use crate::storage::proc::{SolidityField, SolidityFields, SolidityStruct, Solidi
 use proc_macro::TokenStream;
 use quote::{quote, ToTokens};
 use std::mem;
-use syn::{parse_macro_input, punctuated::Punctuated, Index, ItemStruct, Token, Type};
+use syn::{parse_macro_input, punctuated::Punctuated, Fields, Index, ItemEnum, ItemStruct, Token, Type};
 
 mod proc;
 
@@ -223,3 +223,29 @@ pub fn derive_erase(input: TokenStream) -> TokenStream {
     };
     output.into()
 }
+
+pub fn derive_solidity_error(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as ItemEnum);
+    let name = &input.ident;
+    let mut match_arms = quote! {};
+    for variant in input.variants.iter() {
+        let variant_name = &variant.ident;
+        match variant.fields {
+            Fields::Unnamed(_) if variant.fields.len() == 1 => {}
+            _ => panic!("SolidityError: Each variant must be a tuple struct with one field"),
+        }
+        match_arms.extend(quote! {
+            #name::#variant_name(e) => e.encode(),
+        })
+    }
+    let output = quote! {
+        impl From<#name> for ::alloc::vec::Vec<u8> {
+            fn from(err: #name) -> ::alloc::vec::Vec<u8> {
+                match err {
+                    #match_arms
+                }
+            }
+        }
+    };
+    output.into()
+}