stylus_proc/

lib.rs

// Copyright 2022-2026, Offchain Labs, Inc.
// For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/main/licenses/COPYRIGHT.md

//! Procedural macros for [The Stylus SDK][sdk].
//!
//! You can import these via
//!
//! ```
//! use stylus_sdk::prelude::*;
//! ```
//!
//! For a guided exploration of the features, please see the comprehensive [Feature
//! Overview][overview].
//!
//! [overview]: https://docs.arbitrum.io/stylus/reference/rust-sdk-guide#calls
//! [sdk]: https://docs.rs/stylus-sdk/latest/stylus_sdk/index.html

#![warn(missing_docs)]

use proc_macro::TokenStream;
use proc_macro_error::proc_macro_error;

/// Generates a pretty error message.
/// Note that this macro is declared before all modules so that they can use it.
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 consts;
mod impls;
mod imports;
mod macros;
mod types;
mod utils;

/// Allows a Rust `struct` to be used in persistent storage.
///
/// ```
/// extern crate alloc;
/// # use stylus_sdk::storage::{StorageAddress, StorageBool};
/// # use stylus_proc::storage;
/// # use stylus_sdk::prelude::*;
/// #[storage]
/// pub struct Contract {
///     owner: StorageAddress,
///     active: StorageBool,
///     sub_struct: SubStruct,
/// }
///
/// #[storage]
/// pub struct SubStruct {
///     number: StorageBool,
/// }
/// ```
///
/// Each field must implement [`StorageType`]. This includes other structs, which will
/// implement the `trait` automatically when [`#[storage]`][storage] is applied.
///
/// One may even implement [`StorageType`] to define custom storage entries, though this is rarely
/// necessary since the [Stylus SDK][sdk] intends to include all standard Solidity types
/// out-of-the-box.
///
/// Please refer to the [SDK Feature Overview][overview] for more information on defining storage.
///
/// [storage]: macro@storage
/// [`StorageType`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/trait.StorageType.html
/// [overview]: https://docs.arbitrum.io/stylus/reference/rust-sdk-guide#storage
/// [sdk]: https://docs.rs/stylus-sdk/latest/stylus_sdk/index.html
#[proc_macro_attribute]
#[proc_macro_error]
pub fn storage(attr: TokenStream, input: TokenStream) -> TokenStream {
    macros::storage(attr, input)
}

/// The types in [`#[storage]`][storage] are laid out in the EVM state trie exactly
/// as they are in [Solidity][solidity]. This means that the fields of a `struct` definition will
/// map to the same storage slots as they would in EVM programming languages. Hence, it is often
/// nice to define types using Solidity syntax, which makes this guarantee easier to see.
///
/// ```
/// extern crate alloc;
/// # use stylus_sdk::prelude::*;
/// # use stylus_proc::sol_storage;
/// sol_storage! {
///     pub struct Contract {
///         address owner;                      // becomes a StorageAddress
///         bool active;                        // becomes a StorageBool
///         SubStruct sub_struct;
///     }
///
///     pub struct SubStruct {
///         // other solidity fields, such as
///         mapping(address => uint) balances;  // becomes a StorageMap
///         Delegate[] delegates;               // becomes a StorageVec
///     }
///     pub struct Delegate {
///     }
/// }
/// ```
///
/// The above will expand to equivalent definitions in Rust, with each structure implementing the
/// [`StorageType`] `trait`. Many contracts, like [the ERC 20 example][erc20], do exactly this.
///
/// Because the layout is identical to [Solidity's][solidity], existing Solidity smart contracts can
/// upgrade to Rust without fear of storage slots not lining up. You simply copy-paste your type
/// definitions.
///
/// Consequently, the order of fields will affect the JSON ABIs produced that explorers and tooling
/// might use. Most developers don't need to worry about this though and can freely order their
/// types when working on a Rust contract from scratch.
///
///
/// Please refer to the [SDK Feature Overview][overview] for more information on defining storage.
///
/// [storage]: macro@storage
/// [`StorageType`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/trait.StorageType.html
/// [solidity]: https://docs.soliditylang.org/en/latest/internals/layout_in_storage.html
/// [overview]: https://docs.arbitrum.io/stylus/reference/rust-sdk-guide#erase-and-deriveerase
/// [erc20]: https://github.com/OffchainLabs/stylus-sdk-rs/blob/main/examples/erc20/src/main.rs
#[proc_macro]
#[proc_macro_error]
pub fn sol_storage(input: TokenStream) -> TokenStream {
    macros::sol_storage(input)
}

/// Facilitates calls to other contracts.
///
/// This macro defines a `struct` for each of the Solidity interfaces provided.
///
/// ```
/// # use stylus_proc::sol_interface;
/// sol_interface! {
///     interface IService {
///         function makePayment(address user) external payable returns (string);
///         function getConstant() external pure returns (bytes32);
///     }
///
///     interface ITree {
///         // other interface methods
///     }
/// }
/// ```
///
/// The above will define `IService` and `ITree` for calling the methods of the two contracts.
///
/// For example, `IService` will have a `make_payment` method that accepts an [`Address`] and
/// returns a [`B256`].
///
/// Currently only functions are supported, and any other items in the interface will cause an
/// error. Additionally, each function must be marked `external`. Inheritance is not supported.
///
/// ```
/// use alloy_primitives::Address;
/// use stylus_sdk::{
///     prelude::*,
///     stylus_core::{calls::errors::*, host::*},
/// };
/// # use stylus_proc::sol_interface;
///
/// # sol_interface! {
/// #     interface IService {
/// #         function makePayment(address user) external payable returns (string);
/// #     }
/// # }
/// # mod evm { pub fn gas_left() -> u64 { 100 } }
/// # mod msg { pub fn value() -> alloy_primitives::U256 { 100.try_into().unwrap() } }
/// pub fn do_call(host: &impl Host, account: IService, user: Address) -> Result<String, Error> {
///     let config = Call::new()
///         .gas(host.evm_gas_left() / 2) // limit to half the gas left
///         .value(host.msg_value()); // set the callvalue
///
///     account.make_payment(host, config, user) // note the snake case
/// }
/// ```
///
/// Observe the casing change. [`sol_interface!`] computes the selector based on the exact name
/// passed in, which should almost always be `camelCase`. For aesthetics, the rust functions will
/// instead use `snake_case`.
///
/// Note that structs may be used, as return types for example. Trying to reference structs using
/// the Solidity path separator (`module.MyStruct`) is supported and paths will be converted to
/// Rust syntax (`module::MyStruct`).
///
/// # Reentrant calls
///
/// Cross-contract calls automatically [`flush`] or [`clear`] the [`StorageCache`] to safeguard
/// state. This happens via the type system -- no special feature flags are required.
///
/// ```
/// # extern crate alloc;
/// # use stylus_sdk::prelude::*;
/// # use stylus_proc::{entrypoint, public, sol_interface, storage};
/// sol_interface! {
///     interface IMethods {
///         function pureFoo() external pure;
///         function viewFoo() external view;
///         function writeFoo() external;
///     }
/// }
///
/// #[entrypoint]
/// #[storage]
/// struct Contract {}
/// #[public]
/// impl Contract {
///     pub fn call_pure(&self, methods: IMethods) -> Result<(), Vec<u8>> {
///         let cfg = Call::new();
///         Ok(methods.pure_foo(self.vm(), cfg)?) // `pure` methods might lie about not being `view`
///     }
///
///     pub fn call_view(&self, methods: IMethods) -> Result<(), Vec<u8>> {
///         let cfg = Call::new();
///         Ok(methods.view_foo(self.vm(), cfg)?)
///     }
///
///     pub fn call_write(&mut self, methods: IMethods) -> Result<(), Vec<u8>> {
///         let cfg = Call::new_mutating(self);
///         Ok(methods.write_foo(self.vm(), cfg)?)
///     }
/// }
/// ```
///
/// Another example of making a mutable, payable call to a contract using the [`sol_interface!`]
/// macro.
///
/// ```
/// use alloy_primitives::Address;
/// use stylus_sdk::{
///     prelude::*,
///     stylus_core::{calls::errors::*, host::*},
/// };
/// # use stylus_proc::sol_interface;
///
/// # sol_interface! {
/// #     interface IService {
/// #         function makePayment(address user) external payable returns (string);
/// #     }
/// # }
/// # mod evm { pub fn gas_left() -> u64 { 100 } }
/// # mod msg { pub fn value() -> alloy_primitives::U256 { 100.try_into().unwrap() } }
/// pub fn do_call(
///     host: &impl Host,
///     account: IService, // serializes as an Address
///     user: Address,
/// ) -> Result<String, Error> {
///     let config = Call::new()
///         .gas(evm::gas_left() / 2) // limit to half the gas left
///         .value(msg::value()); // set the callvalue
///
///     account.make_payment(host, config, user) // note the snake case
/// }
/// ```
///
/// Note that in the context of a [`#[public]`][public] call, the `&mut impl` argument will
/// correctly distinguish the method as being `write` or `payable`.
///
/// [sol_interface]: macro@sol_interface
/// [public]: macro@public
/// [`TopLevelStorage`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/trait.TopLevelStorage.html
/// [`StorageCache`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/struct.StorageCache.html
/// [`flush`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/struct.StorageCache.html#method.flush
/// [`clear`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/struct.StorageCache.html#method.clear
/// [`Address`]: https://docs.rs/alloy-primitives/latest/alloy_primitives/struct.Address.html
/// [`B256`]: https://docs.rs/alloy-primitives/latest/alloy_primitives/aliases/type.B256.html
/// [`Call`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/call/struct.Call.html
#[proc_macro]
#[proc_macro_error]
pub fn sol_interface(input: TokenStream) -> TokenStream {
    macros::sol_interface(input)
}

/// Some [`StorageType`] values implement [`Erase`], which provides an [`erase()`] method for
/// clearing state. [The Stylus SDK][sdk] implements [`Erase`] for all primitives, and for vectors
/// of primitives, but not for maps. This is because a Solidity mapping does not provide iteration,
/// and so it's generally impossible to know which slots to clear.
///
/// Structs may also be [`Erase`] if all of the fields are. `#[derive(Erase)]`
/// lets you do this automatically.
///
/// ```
/// extern crate alloc;
/// # use stylus_proc::{Erase, sol_storage};
/// # use stylus_sdk::prelude::*;
/// sol_storage! {
///    #[derive(Erase)]
///    pub struct Contract {
///        address owner;              // can erase primitive
///        uint256[] hashes;           // can erase vector of primitive
///    }
///
///    pub struct NotErase {
///        mapping(address => uint) balances; // can't erase a map
///        mapping(uint => uint)[] roots;     // can't erase vector of maps
///    }
/// }
/// ```
///
/// You can also implement [`Erase`] manually if desired. Note that the reason we care about
/// [`Erase`] at all is that you get storage refunds when clearing state, lowering fees. There's
/// also minor implications for storage patterns using `unsafe` Rust.
///
/// Please refer to the [SDK Feature Overview][overview] for more information on defining storage.
///
/// [`StorageType`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/trait.StorageType.html
/// [`Erase`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/trait.Erase.html
/// [`erase()`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/trait.Erase.html#tymethod.erase
/// [overview]: https://docs.arbitrum.io/stylus/reference/rust-sdk-guide#storage
/// [sdk]: https://docs.rs/stylus-sdk/latest/stylus_sdk/index.html
#[proc_macro_derive(Erase)]
#[proc_macro_error]
pub fn derive_erase(input: TokenStream) -> TokenStream {
    macros::derive_erase(input)
}

/// Allows an error `enum` to be used in method signatures.
///
/// ```
/// # use alloy_sol_types::sol;
/// # use stylus_proc::{public, SolidityError};
/// # extern crate alloc;
/// 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),
/// }
///
/// # struct Contract {}
/// #[public]
/// impl Contract {
///     pub fn fallible_method() -> Result<(), Erc20Error> {
///         // code that might revert
/// #       Ok(())
///     }
/// }
/// ```
///
/// 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)]
#[proc_macro_error]
pub fn derive_solidity_error(input: TokenStream) -> TokenStream {
    macros::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`.
///
/// ```
/// # extern crate alloc;
/// # use stylus_proc::{entrypoint, public, sol_storage};
/// # use stylus_sdk::prelude::*;
/// sol_storage! {
///     #[entrypoint]
///     pub struct Contract {
///     }
///
///     // only one entrypoint is allowed
///     pub struct SubStruct {
///     }
/// }
/// # #[public] impl Contract {}
/// ```
///
/// The above will make the public methods of Contract the first to consider during invocation.
/// See [`#[public]`][public] for more information on method selection.
///
/// # Bytes-in, bytes-out programming
///
/// A less common usage of [`#[entrypoint]`][entrypoint] is for low-level, bytes-in bytes-out
/// programming. When applied to a free-standing function, a different way of writing smart
/// contracts becomes possible, wherein the Stylus SDK's macros and storage types are entirely
/// optional.
///
/// ```
/// extern crate alloc;
/// # use stylus_sdk::ArbResult;
/// # use stylus_proc::entrypoint;
/// # use stylus_sdk::prelude::*;
/// #[entrypoint]
/// fn entrypoint(
///     calldata: Vec<u8>,
///     _: alloc::boxed::Box<dyn stylus_sdk::stylus_core::Host>,
/// ) -> ArbResult {
///     // bytes-in, bytes-out programming
/// #   Ok(Vec::new())
/// }
/// ```
///
/// # Reentrancy
///
/// If a contract calls another that then calls the first, it is said to be reentrant.
/// Numerous exploits and hacks in Web3 are attributable to developers misusing or not fully
/// understanding reentrant patterns. Always follow the checks-effects-interactions pattern.
///
/// ## Storage cache flushing
///
/// The SDK's primary reentrancy safety mechanism is automatic storage cache management.
/// The high-level call functions in `stylus_sdk::call` (`call`, `delegate_call`, and
/// `static_call`) flush the storage cache before every external call, ensuring that
/// pending writes are persisted to storage before control is handed to another contract:
///
/// - `call` and `delegate_call` flush and clear (persist dirty values, then drop the in-memory
///   cache).
/// - `static_call` flushes without clearing (since static calls cannot modify storage, the cache
///   remains valid).
///
/// This happens unconditionally for all contracts. When using `RawCall` directly, the
/// cache is **not** flushed automatically -- if you have pending storage writes that
/// the callee might read, call `.flush_storage_cache()` to persist dirty values without
/// dropping the cache, or `.clear_storage_cache()` to persist and drop the cache
/// (matching what `call` and `delegate_call` do).
///
/// ## The `reentrant` feature flag (deprecated)
///
/// The `reentrant` feature flag is **deprecated** and will be removed in a future
/// release. Previously, contracts without this flag would automatically revert on
/// reentrant calls via a `msg_reentrant()` check at the entrypoint. This guard is
/// redundant — reentrancy safety is already provided by the cache flushing described
/// above — and it indiscriminately blocks all reentrant calls, preventing use cases
/// that require them.
///
/// # [`TopLevelStorage`]
///
/// The [`#[entrypoint]`][entrypoint] macro will automatically implement the [`TopLevelStorage`]
/// `trait` for the annotated `struct`. The single type implementing [`TopLevelStorage`] is special
/// in that mutable access to it represents mutable access to the entire program's state.
/// This has implications for calls via [`sol_interface`].
///
/// [`TopLevelStorage`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/storage/trait.TopLevelStorage.html
/// [`sol_interface`]: macro@sol_interface
/// [entrypoint]: macro@entrypoint
/// [public]: macro@public
/// [check]: https://github.com/OffchainLabs/cargo-stylus#developing-with-stylus
#[proc_macro_attribute]
#[proc_macro_error]
pub fn entrypoint(attr: TokenStream, input: TokenStream) -> TokenStream {
    macros::entrypoint(attr, input)
}

/// Just as with storage, Stylus SDK methods are Solidity ABI-equivalent. This means that contracts
/// written in different programming languages are fully interoperable. You can even automatically
/// export your Rust contract as a Solidity interface so that others can add it to their Solidity
/// projects.
///
/// This macro makes methods "public" so that other contracts can call them by implementing the
/// [`Router`] trait.
///
/// ```
/// # extern crate alloc;
/// # use stylus_sdk::storage::StorageAddress;
/// # use stylus_proc::public;
/// # use alloy_primitives::Address;
/// # struct Contract {
/// #     owner: StorageAddress,
/// # }
/// #[public]
/// impl Contract {
///     // our owner method is now callable by other contracts
///     pub fn owner(&self) -> Result<Address, Vec<u8>> {
///         Ok(self.owner.get())
///     }
/// }
///
/// impl Contract {
///     // our set_owner method is not
///     pub fn set_owner(&mut self, new_owner: Address) -> Result<(), Vec<u8>> {
///         // ...
/// #       Ok(())
///     }
/// }
/// ```
///
/// In is example, [`Vec<u8>`] becomes the program's revert data.
///
/// # [`#[payable]`][payable]
///
/// As in Solidity, methods may accept ETH as call value.
///
/// ```
/// # extern crate alloc;
/// # use alloy_primitives::Address;
/// # use stylus_proc::{entrypoint, public, storage};
/// # use stylus_sdk::prelude::*;
/// # #[entrypoint] #[storage] struct Contract { #[borrow] erc20: Erc20, }
/// # mod msg {
/// #     use alloy_primitives::Address;
/// #     pub fn sender() -> Address { Address::ZERO }
/// #     pub fn value() -> u32 { 0 }
/// # }
/// #[public]
/// impl Contract {
///     #[payable]
///     pub fn credit(&mut self) -> Result<(), Vec<u8>> {
///         self.erc20.add_balance(msg::sender(), msg::value())
///     }
/// }
/// # #[storage] struct Erc20;
/// # #[public]
/// # impl Erc20 {
/// #     pub fn add_balance(&self, sender: Address, value: u32) -> Result<(), Vec<u8>> {
/// #         Ok(())
/// #     }
/// # }
/// ```
///
/// In the above, [msg::value][value] is the amount of ETH passed to the contract in wei, which may
/// be used to pay for something depending on the contract's business logic. Note that you have to
/// annotate the method with [`#[payable]`][payable], or else calls to it will revert. This is
/// required as a safety measure to prevent users losing funds to methods that didn't intend to
/// accept ether.
///
/// # Constructor
///
/// Constructors provide a standard way to deploy, activate, and initialize a stylus contract
/// atomically. Without them, it isn’t possible to guarantee that the Stylus contract initialization
/// code will be executed before other methods. When using Stylus constructors, cargo-stylus sends a
/// transaction to a proxy-contract called StylusDeployer that performs all necessary steps.
///
/// The constructor function must be annotated with the `#[constructor]` attribute. It can have any
/// name, but it is advisable to call it `constructor`. There must be no constructor definition or a
/// single constructor for a contract. Like Solidity, function overloading for constructors is not
/// supported. Constructors may be annotated with the [`#[payable]`][payable] attribute if they are
/// supposed to receive Ether.
///
/// The constructor must receive the self parameter, and it can have any number of other parameters.
/// The values for these parameters will be passed to the constructor when deploying the contract.
/// The constructor should return no value or a result value with a unit type and a vector of bytes
/// (`Result<(), Vec<u8>>`). If the constructor returns an error, the deployment will revert.
///
/// The SDK will ensure the constructor is called only once. To do so, it will wrap the constructor
/// with a function that reads and writes to a specific slot in storage. When called, the
/// constructor wrapper will check the contents of the specific slot and revert if it is different
/// from zero. Then, after executing the constructor method, the wrapper will write a value to the
/// specific slot, ensuring the next call to the constructor will revert.
///
/// ```
/// # extern crate alloc;
/// # use stylus_sdk::storage::StorageAddress;
/// # use stylus_proc::public;
/// # use alloy_primitives::Address;
/// # struct Contract {
/// #     owner: StorageAddress,
/// # }
/// #[public]
/// impl Contract {
///     #[constructor]
///     pub fn constructor(&mut self, owner: Address) -> Result<(), Vec<u8>> {
///         self.owner.set(owner);
///         Ok(())
///     }
/// }
/// ```
///
/// In the example above, the constructor receives a single parameter: the address of the contract's
/// owner. Note that we shouldn't use `self.vm().msg_sender()` because that will return the address
/// of StylusDeployer. Instead, we explicitly pass the address of the contract's owner.
///
/// # [`pure`][pure] [`view`][view], and `write`
///
/// For non-payable methods the [`#[public]`][public] macro can figure state mutability out for you
/// based on the types of the arguments. Functions with `&self` will be considered `view`, those
/// with `&mut self` will be considered `write`, and those with neither will be considered `pure`.
/// Please note that `pure` and `view` functions may change the state of other contracts by calling
/// into them.
///
/// Please refer to the [SDK Feature Overview][overview] for more information on defining methods.
///
/// # Exporting a Solidity interface
///
/// Recall that Stylus contracts are fully interoperable across all languages, including Solidity.
/// The Stylus SDK provides tools for exporting a Solidity interface for your contract so that
/// others can call it. This is usually done with the cargo stylus [CLI tool][cli].
///
/// The SDK does this automatically via a feature flag called `export-abi` that causes the
/// [`#[public]`][public] and [`#[entrypoint]`][entrypoint] macros to generate a `main` function
/// that prints the Solidity ABI to the console.
///
/// ```sh
/// cargo run --features export-abi --target <triple>
/// ```
///
/// Note that because the above actually generates a `main` function that you need to run, the
/// target can't be `wasm32-unknown-unknown` like normal. Instead you'll need to pass in your target
/// triple, which cargo stylus figures out for you. This `main` function is also why the following
/// commonly appears in the `main.rs` file of Stylus contracts.
///
/// ```no_run
/// #![cfg_attr(not(feature = "export-abi"), no_main)]
/// ```
///
/// Here's an example output. Observe that the method names change from Rust's `snake_case` to
/// Solidity's `camelCase`. For compatibility reasons, onchain method selectors default to
/// `camelCase`. You can customize the ABI name used for selector computation with `#[selector(name
/// = "...")]`.
///
/// Note too that you can use argument names like "address"
/// without fear. The SDK will prepend an `_` when necessary.
///
/// ```solidity
/// interface Erc20 {
///     function name() external pure returns (string memory);
///
///     function balanceOf(address _address) external view returns (uint256);
/// }
///
/// interface Weth is Erc20 {
///     function mint() external payable;
///
///     function burn(uint256 amount) external;
/// }
/// ```
///
/// # Selector collision detection
///
/// The macro detects ABI selector collisions at compile time within a single `#[public]`
/// block, whether it annotates an impl block or a trait definition. If two methods produce
/// the same 4-byte selector (computed from the keccak256 hash of the Solidity function
/// signature string, e.g. `transfer(uint256,address)`), compilation will fail
/// with a descriptive error.
///
/// Collision checks are gated out when `contract-client-gen` is enabled, because that mode
/// generates call stubs for external contracts where selector routing is not emitted.
///
/// **Not detected:** cross-block collisions (across separate `#[public]` blocks) and
/// collisions with selectors inherited via `#[implements(...)]`. When using
/// `#[implements]`, manually verify that your function selectors do not collide with
/// those of the inherited trait's methods.
///
/// [storage]: macro@storage
/// [sol_storage]: macro@sol_storage
/// [entrypoint]: macro@entrypoint
/// [public]: macro@public
/// [overview]: https://docs.arbitrum.io/stylus/reference/rust-sdk-guide#methods
/// [`Router`]: https://docs.rs/stylus-sdk/latest/stylus_sdk/abi/trait.Router.html
/// [Borrow]: https://doc.rust-lang.org/std/borrow/trait.Borrow.html
/// [BorrowMut]: https://doc.rust-lang.org/std/borrow/trait.BorrowMut.html
/// [value]: https://docs.rs/stylus-sdk/latest/stylus_sdk/msg/fn.value.html
/// [payable]: https://docs.alchemy.com/docs/solidity-payable-functions
/// [view]: https://docs.soliditylang.org/en/develop/contracts.html#view-functions
/// [pure]: https://docs.soliditylang.org/en/develop/contracts.html#pure-functions
/// [cli]: https://github.com/OffchainLabs/cargo-stylus#exporting-solidity-abis
/// [dfs]: https://en.wikipedia.org/wiki/Depth-first_search
#[proc_macro_attribute]
#[proc_macro_error]
pub fn public(attr: TokenStream, input: TokenStream) -> TokenStream {
    macros::public(attr, input)
}

/// Implements the AbiType for arbitrary structs, allowing them to be used in external method
/// return types and parameters. This derive is intended to be used within the
/// [alloy_sol_types::sol] macro.
///
/// ```
/// # extern crate alloc;
/// # use alloy_sol_types::sol;
/// # use stylus_proc::AbiType;
/// sol! {
///     #[derive(AbiType)]
///     struct Foo {
///         uint256 bar;
///     }
/// }
/// ```
#[proc_macro_derive(AbiType)]
#[proc_macro_error]
pub fn derive_abi_type(input: TokenStream) -> TokenStream {
    macros::derive_abi_type(input)
}