feat: erc165 support interface

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
  "contracts",
+ "contracts-proc",
  "lib/crypto",
  "lib/motsu",
  "lib/motsu-proc",
@@ -21,6 +22,7 @@ members = [
 ]
 default-members = [
  "contracts",
+ "contracts-proc",
  "lib/crypto",
  "lib/motsu",
  "lib/motsu-proc",

contracts-proc/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "openzeppelin-stylus-proc"
+description = "Procedural macros for OpenZeppelin Stylus contracts"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+keywords.workspace = true
+repository.workspace = true
+
+
+[dependencies]
+proc-macro2.workspace = true
+quote.workspace = true
+syn.workspace = true
+convert_case = "0.6.0"
+
+[lints]
+workspace = true
+
+[lib]
+proc-macro = true

contracts-proc/src/interface.rs

@@ -0,0 +1,118 @@
+use std::mem;
+
+use convert_case::{Case, Casing};
+use proc_macro::TokenStream;
+use proc_macro2::Ident;
+use quote::quote;
+use syn::{
+ parse::{Parse, ParseStream},
+ parse_macro_input, FnArg, ItemTrait, LitStr, Result, Token, TraitItem,
+};
+
+/// Computes interface id as an associated constant for the trait.
+pub(crate) fn interface(_attr: TokenStream, input: TokenStream) -> TokenStream {
+ let mut input = parse_macro_input!(input as ItemTrait);
+ let mut output = quote! {};
+
+ let mut selectors = Vec::new();
+ for item in &mut input.items {
+ let TraitItem::Fn(func) = item else {
+ continue;
+ };
+
+ let mut override_name = None;
+ for attr in mem::take(&mut func.attrs) {
+ let Some(ident) = attr.path().get_ident() else {
+ func.attrs.push(attr);
+ continue;
+ };
+ if *ident == "selector" {
+ if override_name.is_some() {
+ error!(attr.path(), "more than one selector attribute");
+ }
+ let args: SelectorArgs = match attr.parse_args() {
+ Ok(args) => args,
+ Err(error) => error!(ident, "{}", error),
+ };
+ override_name = Some(args.name);
+ continue;
+ }
+ func.attrs.push(attr);
+ }
+
+ let sol_name = override_name.unwrap_or_else(|| {
+ func.sig.ident.clone().to_string().to_case(Case::Camel)
+ });
+
+ let args = func.sig.inputs.iter();
+ let arg_types: Vec<_> = args
+ .filter_map(|arg| match arg {
+ FnArg::Typed(t) => Some(t.ty.clone()),
+ _ => None,
+ })
+ .collect();
+
+ let selector = quote! { u32::from_be_bytes(stylus_sdk::function_selector!(#sol_name #(, #arg_types )*)) };
+ selectors.push(selector);
+ }
+
+ let name = input.ident.clone();
+ let vis = input.vis.clone();
+ let attrs = input.attrs.clone();
+ let trait_items = input.items.clone();
+ let (_impl_generics, ty_generics, where_clause) =
+ input.generics.split_for_impl();
+
+ output.extend(quote! {
+ #(#attrs)*
+ #vis trait #name #ty_generics #where_clause {
+ #(#trait_items)*
+
+ /// Solidity interface id associated with current trait.
+ const INTERFACE_ID: u32 = {
+ #(#selectors)^*
+ };
+ }
+ });
+
+ output.into()
+}
+
+struct SelectorArgs {
+ name: String,
+}
+
+impl Parse for SelectorArgs {
+ fn parse(input: ParseStream) -> Result<Self> {
+ let mut name = None;
+
+ if input.is_empty() {
+ error!(@input.span(), "missing id or text argument");
+ }
+
+ while !input.is_empty() {
+ let ident: Ident = input.parse()?;
+ let _: Token![=] = input.parse()?;
+
+ match ident.to_string().as_str() {
+ "name" => {
+ let lit: LitStr = input.parse()?;
+ if name.is_some() {
+ error!(@lit, r#"only one "name" is allowed"#);
+ }
+ name = Some(lit.value());
+ }
+ _ => error!(@ident, "Unknown selector attribute"),
+ }
+
+ // allow a comma
+ let _: Result<Token![,]> = input.parse();
+ }
+
+ if let Some(name) = name {
+ Ok(Self { name })
+ } else {
+ error!(@input.span(), r#""name" is required"#);
+ }
+ }
+}

contracts-proc/src/lib.rs

@@ -0,0 +1,23 @@
+// TODO#q: add crate documentation.
+
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+/// Shorthand to print nice errors.
+macro_rules! error {
+ ($tokens:expr, $($msg:expr),+ $(,)?) => {{
+ let error = syn::Error::new(syn::spanned::Spanned::span(&$tokens), format!($($msg),+));
+ return error.to_compile_error().into();
+ }};
+ (@ $tokens:expr, $($msg:expr),+ $(,)?) => {{
+ return Err(syn::Error::new(syn::spanned::Spanned::span(&$tokens), format!($($msg),+)))
+ }};
+}
+
+mod interface;
+
+/// Computes interface id as an associated constant for the trait.
+#[proc_macro_attribute]
+pub fn interface(attr: TokenStream, input: TokenStream) -> TokenStream {
+ interface::interface(attr, input)
+}

contracts/Cargo.toml

@@ -15,6 +15,7 @@ stylus-sdk.workspace = true
 stylus-proc.workspace = true
 mini-alloc.workspace = true
 keccak-const.workspace = true
+openzeppelin-stylus-proc = { path = "../contracts-proc"}
 
 [dev-dependencies]
 alloy-primitives = { workspace = true, features = ["arbitrary"] }

contracts/src/token/erc20/mod.rs

@@ -6,6 +6,7 @@
 //! [`Erc20`] applications.
 use alloy_primitives::{Address, U256};
 use alloy_sol_types::sol;
+use openzeppelin_stylus_proc::interface;
 use stylus_proc::SolidityError;
 use stylus_sdk::{
  call::MethodError,
@@ -111,6 +112,7 @@ sol_storage! {
 }
 
 /// Required interface of an [`Erc20`] compliant contract.
+#[interface]
 pub trait IErc20 {
  /// The error type associated to this ERC-20 trait implementation.
  type Error: Into<alloc::vec::Vec<u8>>;
@@ -550,6 +552,7 @@ mod tests {
  use stylus_sdk::msg;
 
  use super::{Erc20, Error, IErc20};
+ use crate::token::erc721::{Erc721, IErc721};
 
  #[motsu::test]
  fn reads_balance(contract: Erc20) {
@@ -882,4 +885,11 @@ mod tests {
  let result = contract.approve(Address::ZERO, one);
  assert!(matches!(result, Err(Error::InvalidSpender(_))));
  }
+
+ #[motsu::test]
+ fn interface_id() {
+ let actual = <Erc20 as IErc20>::INTERFACE_ID;
+ let expected = 0x_36372b07;
+ assert_eq!(actual, expected);
+ }
 }

contracts/src/token/erc721/mod.rs

@@ -2,6 +2,7 @@
 use alloc::vec;
 
 use alloy_primitives::{fixed_bytes, uint, Address, FixedBytes, U128, U256};
+use openzeppelin_stylus_proc::interface;
 use stylus_sdk::{
  abi::Bytes,
  alloy_sol_types::sol,
@@ -198,6 +199,7 @@ sol_storage! {
 unsafe impl TopLevelStorage for Erc721 {}
 
 /// Required interface of an [`Erc721`] compliant contract.
+#[interface]
 pub trait IErc721 {
  /// The error type associated to this ERC-721 trait implementation.
  type Error: Into<alloc::vec::Vec<u8>>;
@@ -317,6 +319,7 @@ pub trait IErc721 {
  /// # Events
  ///
  /// Emits a [`Transfer`] event.
+ #[selector(name = "safeTransferFrom")]
  fn safe_transfer_from_with_data(
  &mut self,
  from: Address,
@@ -2487,4 +2490,11 @@ mod tests {
  }) if token_id == t_id
  ));
  }
+
+ #[motsu::test]
+ fn interface_id() {
+ let actual = <Erc721 as IErc721>::INTERFACE_ID;
+ let expected = 0x_80ac58cd;
+ assert_eq!(actual, expected);
+ }
 }

examples/erc20/src/lib.rs

@@ -3,7 +3,7 @@ extern crate alloc;
 
 use alloc::vec::Vec;
 
-use alloy_primitives::{Address, U256};
+use alloy_primitives::{Address, FixedBytes, U256};
 use openzeppelin_stylus::{
  token::erc20::{
  extensions::{capped, Capped, Erc20Metadata, IErc20Burnable},
@@ -105,4 +105,12 @@ impl Erc20Example {
  self.pausable.when_not_paused()?;
  self.erc20.transfer_from(from, to, value).map_err(|e| e.into())
  }
+
+ fn supports_interface(
+ interface_id: FixedBytes<4>,
+ ) -> Result<bool, Vec<u8>> {
+ let interface_id = u32::from_be_bytes(*interface_id);
+ let supported = interface_id == <Erc20 as IErc20>::INTERFACE_ID;
+ Ok(supported)
+ }
 }

examples/erc20/tests/abi/mod.rs

@@ -29,6 +29,8 @@ sol!(
  #[derive(Debug)]
  function whenNotPaused() external view;
 
+ function supportsInterface(bytes4 interface_id) external view returns (bool supportsInterface);
+
  error EnforcedPause();
  error ExpectedPause();
 

examples/erc20/tests/erc20.rs

@@ -1340,3 +1340,29 @@ async fn error_when_transfer_from(alice: Account, bob: Account) -> Result<()> {
 
  Ok(())
 }
+
+#[e2e::test]
+async fn support_interface(alice: Account) -> Result<()> {
+ let contract_addr = alice
+ .as_deployer()
+ .with_default_constructor::<constructorCall>()
+ .deploy()
+ .await?
+ .address()?;
+ let contract = Erc20::new(contract_addr, &alice.wallet);
+ let invalid_interface_id: u32 = 0x_ffffffff;
+ let Erc20::supportsInterfaceReturn {
+ supportsInterface: supports_interface,
+ } = contract.supportsInterface(invalid_interface_id.into()).call().await?;
+
+ assert_eq!(supports_interface, false);
+
+ let valid_interface_id: u32 = 0x_36372b07;
+ let Erc20::supportsInterfaceReturn {
+ supportsInterface: supports_interface,
+ } = contract.supportsInterface(valid_interface_id.into()).call().await?;
+
+ assert_eq!(supports_interface, true);
+
+ Ok(())
+}

examples/erc721/src/lib.rs

@@ -3,7 +3,7 @@ extern crate alloc;
 
 use alloc::vec::Vec;
 
-use alloy_primitives::{Address, U256};
+use alloy_primitives::{Address, FixedBytes, U256};
 use openzeppelin_stylus::{
  token::erc721::{
  extensions::{Erc721Enumerable as Enumerable, IErc721Burnable},
@@ -151,4 +151,12 @@ impl Erc721Example {
 
  Ok(())
  }
+
+ fn supports_interface(
+ interface_id: FixedBytes<4>,
+ ) -> Result<bool, Vec<u8>> {
+ let interface_id = u32::from_be_bytes(*interface_id);
+ let supported = interface_id == <Erc721 as IErc721>::INTERFACE_ID;
+ Ok(supported)
+ }
 }

examples/erc721/tests/abi/mod.rs

@@ -18,20 +18,25 @@ sol!(
  function setApprovalForAll(address operator, bool approved) external;
  function totalSupply() external view returns (uint256 totalSupply);
  function transferFrom(address from, address to, uint256 tokenId) external;
+
  function mint(address to, uint256 tokenId) external;
  function burn(uint256 tokenId) external;
+
  function paused() external view returns (bool paused);
  function pause() external;
  function unpause() external;
  #[derive(Debug)]
  function whenPaused() external view;
  #[derive(Debug)]
  function whenNotPaused() external view;
+
  #[derive(Debug)]
  function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
  #[derive(Debug)]
  function tokenByIndex(uint256 index) external view returns (uint256 tokenId);
 
+ function supportsInterface(bytes4 interface_id) external view returns (bool supportsInterface);
+
  error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
  error ERC721InsufficientApproval(address operator, uint256 tokenId);
  error ERC721InvalidApprover(address approver);