Merge pull request #108 from OffchainLabs/0.4.3

SDK 0.4.3

.github/PULL_REQUEST_TEMPLATE.md

@@ -8,5 +8,5 @@ Please provide a summary of the changes and any backward incompatibilities.
 - [ ] I have read the [DCO][DCO] and ensured that these changes comply.
 - [ ] I assign this work under its [open source licensing][terms].
 
-[DCO]: licenses/DCO.txt
-[terms]: licenses/COPYRIGHT.md
+[DCO]: https://github.com/OffchainLabs/stylus-sdk-rs/blob/stylus/licenses/DCO.txt
+[terms]: https://github.com/OffchainLabs/stylus-sdk-rs/blob/stylus/licenses/COPYRIGHT.md

Cargo.toml

@@ -3,7 +3,7 @@ members = ["stylus-sdk", "stylus-proc", "mini-alloc"]
 resolver = "2"
 
 [workspace.package]
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 authors = ["Offchain Labs"]
 license = "MIT OR Apache-2.0"

ci/smoke_test.sh

@@ -11,4 +11,4 @@ cargo stylus new counter
 cd counter
 echo "[workspace]" >> Cargo.toml
 
-cargo stylus deploy --private-key $PRIV_KEY
+cargo stylus deploy --private-key $PRIV_KEY -e https://stylus-testnet.arbitrum.io/rpc

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/entrypoint.rs

@@ -84,7 +84,7 @@ pub fn entrypoint(attr: TokenStream, input: TokenStream) -> TokenStream {
  output.extend(quote! {
  #[no_mangle]
  pub unsafe fn mark_used() {
- stylus_sdk::evm::memory_grow(0);
+ stylus_sdk::evm::pay_for_memory_grow(0);
  panic!();
  }
 

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

@@ -1,4 +1,4 @@
-// Copyright 2022-2023, Offchain Labs, Inc.
+// Copyright 2022-2024, Offchain Labs, Inc.
 // For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/stylus/licenses/COPYRIGHT.md
 
 use crate::types::{self, Purity};
@@ -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 {
@@ -155,10 +156,7 @@ pub fn external(_attr: TokenStream, input: TokenStream) -> TokenStream {
  }
  };
  let result = Self::#name(#storage #(#expand_args, )* );
- match result {
- Ok(result) => Some(Ok(internal::encode_return_type(result))),
- Err(err) => Some(Err(err.into())),
- }
+ Some(EncodableReturnType::encode(result))
  }
  });
 
@@ -258,7 +256,7 @@ pub fn external(_attr: TokenStream, input: TokenStream) -> TokenStream {
  #[inline(always)]
  fn route(storage: &mut S, selector: u32, input: &[u8]) -> Option<stylus_sdk::ArbResult> {
  use stylus_sdk::{function_selector, alloy_sol_types::SolType};
- use stylus_sdk::abi::{internal, AbiType, Router};
+ use stylus_sdk::abi::{internal, internal::EncodableReturnType, AbiType, Router};
  use alloc::vec;
 
  #[cfg(feature = "export-abi")]
@@ -281,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"),
@@ -312,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;