Merge pull request #97 from OffchainLabs/SolidityError

SolidityError derive macro

README.md

@@ -16,7 +16,7 @@
 
 The Stylus SDK enables smart contract developers to write programs for **Arbitrum chains** written in the [Rust](https://www.rust-lang.org/tools/install) programming language. Stylus programs are compiled to [WebAssembly](https://webassembly.org/) and can then be deployed on-chain to execute alongside Solidity smart contracts. Stylus programs are not only orders of magnitude cheaper and faster but also enable what was thought to be previously impossible for WebAssembly: **EVM-interoperability**.
 
-For information about deploying Rust smart contracts, see the [Cargo Stylus CLI Tool](CargoStylus). For more information about Stylus, see [Stylus: A Gentle Introduction](https://docs.arbitrum.io/stylus/stylus-gentle-introduction). For a simpler intro to Stylus Rust development, see the [Quick Start guide](https://docs.arbitrum.io/stylus/stylus-quickstart).
+For information about deploying Rust smart contracts, see the [Cargo Stylus CLI Tool](https://github.com/OffchainLabs/cargo-stylus). For more information about Stylus, see [Stylus: A Gentle Introduction](https://docs.arbitrum.io/stylus/stylus-gentle-introduction). For a simpler intro to Stylus Rust development, see the [Quick Start guide](https://docs.arbitrum.io/stylus/stylus-quickstart).
 
 Comprehensive documentation on the Rust SDK can be found [here](https://docs.arbitrum.io/stylus/rust-sdk-guide).
 

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,35 @@ pub fn derive_erase(input: TokenStream) -> TokenStream {
     storage::derive_erase(input)
 }
 
+/// Allows an error `enum` to be used in method signatures.
+///
+/// ```ignore
+/// sol! {
+///     error InsufficientBalance(address from, uint256 have, uint256 want);
+///     error InsufficientAllowance(address owner, address spender, uint256 have, uint256 want);
+/// }
+///
+/// #[derive(SolidityError)]
+/// pub enum Erc20Error {
+///     InsufficientBalance(InsufficientBalance),
+///     InsufficientAllowance(InsufficientAllowance),
+/// }
+///
+/// #[external]
+/// impl Contract {
+///     pub fn fallible_method() -> Result<(), Erc20Error> {
+///         // code that might revert
+///     }
+/// }
+/// ```
+///
+/// Under the hood, the above macro works by implementing `From<Erc20Error>` for `Vec<u8>`
+/// along with printing code for abi-export.
+#[proc_macro_derive(SolidityError)]
+pub fn derive_solidity_error(input: TokenStream) -> TokenStream {
+    methods::error::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/methods/error.rs

@@ -0,0 +1,57 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/stylus/licenses/COPYRIGHT.md
+
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, Fields, ItemEnum};
+
+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!();
+    let mut errors = vec![];
+    for variant in input.variants {
+        let variant_name = variant.ident;
+        let error = match variant.fields {
+            Fields::Unnamed(e) if variant.fields.len() == 1 => e.unnamed.first().unwrap().clone(),
+            _ => error!(variant.fields, "Variant not a 1-tuple"),
+        };
+        match_arms.extend(quote! {
+            #name::#variant_name(e) => stylus_sdk::alloy_sol_types::SolError::encode(&e),
+        });
+        errors.push(error);
+    }
+    let mut output = quote! {
+        impl From<#name> for alloc::vec::Vec<u8> {
+            fn from(err: #name) -> alloc::vec::Vec<u8> {
+                match err {
+                    #match_arms
+                }
+            }
+        }
+    };
+
+    if cfg!(feature = "export-abi") {
+        output.extend(quote! {
+            impl stylus_sdk::abi::export::internal::InnerTypes for #name {
+                fn inner_types() -> alloc::vec::Vec<stylus_sdk::abi::export::internal::InnerType> {
+                    use alloc::{format, vec};
+                    use core::any::TypeId;
+                    use stylus_sdk::abi::export::internal::InnerType;
+                    use stylus_sdk::alloy_sol_types::SolError;
+
+                    vec![
+                        #(
+                            InnerType {
+                                name: format!("error {};", <#errors as SolError>::SIGNATURE.replace(',', ", ")),
+                                id: TypeId::of::<#errors>(),
+                            }
+                        ),*
+                    ]
+                }
+            }
+        });
+    }
+
+    output.into()
+}

stylus-proc/src/methods/external.rs

@@ -20,6 +20,7 @@ pub fn external(_attr: TokenStream, input: TokenStream) -> TokenStream {
     let mut selectors = quote!();
     let mut match_selectors = quote!();
     let mut abi = quote!();
+    let mut types = vec![];
 
     for item in input.items.iter_mut() {
         let ImplItem::Method(method) = item else {
@@ -278,6 +279,24 @@ pub fn external(_attr: TokenStream, input: TokenStream) -> TokenStream {
         return router.into();
     }
 
+    for item in input.items.iter_mut() {
+        let ImplItem::Method(method) = item else {
+            continue;
+        };
+        if let ReturnType::Type(_, ty) = &method.sig.output {
+            types.push(ty);
+        }
+    }
+
+    let type_decls = quote! {
+        let mut seen = HashSet::new();
+        for item in [].iter() #(.chain(&<#types as InnerTypes>::inner_types()))* {
+            if seen.insert(item.id) {
+                writeln!(f, "\n    {}", item.name)?;
+            }
+        }
+    };
+
     let name = match *self_ty.clone() {
         Type::Path(path) => path.path.segments.last().unwrap().ident.clone().to_string(),
         _ => error!(self_ty, "Can't generate ABI for unnamed type"),
@@ -309,12 +328,14 @@ pub fn external(_attr: TokenStream, input: TokenStream) -> TokenStream {
             fn fmt_abi(f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                 use stylus_sdk::abi::{AbiType, GenerateAbi};
                 use stylus_sdk::abi::internal::write_solidity_returns;
-                use stylus_sdk::abi::export::{underscore_if_sol};
+                use stylus_sdk::abi::export::{underscore_if_sol, internal::InnerTypes};
+                use std::collections::HashSet;
                 #(#inherited_abis)*
                 write!(f, "interface I{}", #name)?;
                 #is_clause
                 write!(f, " {{")?;
                 #abi
+                #type_decls
                 writeln!(f, "}}")?;
                 Ok(())
             }

stylus-proc/src/methods/mod.rs

@@ -2,4 +2,5 @@
 // For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/stylus/licenses/COPYRIGHT.md
 
 pub mod entrypoint;
+pub mod error;
 pub mod external;

stylus-proc/src/storage/mod.rs

@@ -1,4 +1,4 @@
-// Copyright 2023, Offchain Labs, Inc.
+// Copyright 2023-2024, Offchain Labs, Inc.
 // For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/stylus/licenses/COPYRIGHT.md
 
 use crate::storage::proc::{SolidityField, SolidityFields, SolidityStruct, SolidityStructs};
@@ -214,12 +214,12 @@ pub fn derive_erase(input: TokenStream) -> TokenStream {
             self.#ident.erase();
         });
     }
-    let output = quote! {
+    quote! {
         impl #impl_generics stylus_sdk::storage::Erase for #name #ty_generics #where_clause {
             fn erase(&mut self) {
                 #erase_fields
             }
         }
-    };
-    output.into()
+    }
+    .into()
 }