feat: improve code coverage

.github/workflows/nostd.yml

@@ -6,7 +6,7 @@ permissions:
   contents: read
 on:
   push:
-    branches: [ main, release/*  ]
+    branches: [ main, release/* ]
   pull_request:
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}

.github/workflows/test.yml

@@ -11,7 +11,7 @@ permissions:
   contents: read
 on:
   push:
-    branches: [main, release/*]
+    branches: [ main, release/* ]
     paths-ignore:
       - "**.md"
       - "**.adoc"
@@ -32,7 +32,7 @@ jobs:
       matrix:
         # Run on stable and beta to ensure that tests won't break on the next
         # version of the rust toolchain.
-        toolchain: [stable, beta]
+        toolchain: [ stable, beta ]
     steps:
       - uses: actions/checkout@v4
         with:
@@ -69,7 +69,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest]
+        os: [ macos-latest ]
         # Windows fails because of `stylus-proc`.
         # os: [macos-latest, windows-latest]
     steps:
@@ -117,16 +117,19 @@ jobs:
     #
     # for lots of more discussion.
     runs-on: ubuntu-latest
-    name: ubuntu / stable / coverage
+    name: ubuntu / nightly / coverage
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: true
 
       - name: Install rust
+        # We run in nightly to make use of the `#[coverage(off)]` attribute (see _contracts/src/lib.rs_)
+        # We'll return to stable release after the tracking issue is merged (and the feature is stable)
+        # See: https://github.com/rust-lang/rust/issues/84605
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: stable
+          toolchain: nightly
           components: llvm-tools-preview
           rustflags: ""
 

Cargo.toml

@@ -67,6 +67,7 @@ version = "0.2.0-alpha.1"
 missing_docs = "warn"
 unreachable_pub = "warn"
 rust_2021_compatibility = { level = "warn", priority = -1 }
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage_nightly)'] }
 
 [workspace.lints.clippy]
 pedantic = "warn"

contracts/src/access/control.rs

@@ -41,52 +41,59 @@
 //! accounts that have been granted it. We recommend using
 //! `AccessControlDefaultAdminRules` to enforce additional security measures for
 //! this role.
-use alloy_primitives::{Address, B256};
-use alloy_sol_types::sol;
+use alloy_primitives::{Address, FixedBytes, B256};
+pub use sol::*;
 use stylus_sdk::{
     evm, msg,
-    stylus_proc::{public, sol_storage, SolidityError},
+    prelude::storage,
+    storage::{StorageBool, StorageFixedBytes, StorageMap},
+    stylus_proc::{public, SolidityError},
 };
 
-sol! {
-    /// Emitted when `new_admin_role` is set as `role`'s admin role, replacing
-    /// `previous_admin_role`.
-    ///
-    /// `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
-    /// `RoleAdminChanged` not being emitted signaling this.
-    #[allow(missing_docs)]
-    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previous_admin_role, bytes32 indexed new_admin_role);
-    /// Emitted when `account` is granted `role`.
-    ///
-    /// `sender` is the account that originated the contract call. This account
-    /// bears the admin role (for the granted role).
-    /// Expected in cases where the role was granted using the internal
-    /// [`AccessControl::grant_role`].
-    #[allow(missing_docs)]
-    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
-    /// Emitted when `account` is revoked `role`.
-    ///
-    /// `sender` is the account that originated the contract call:
-    ///   - if using `revoke_role`, it is the admin role bearer.
-    ///   - if using `renounce_role`, it is the role bearer (i.e. `account`).
-    #[allow(missing_docs)]
-    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
-}
-
-sol! {
-    /// The `account` is missing a role.
-    ///
-    /// * `account` - Account that was found to not be authorized.
-    /// * `needed_role` - The missing role.
-    #[derive(Debug)]
-    #[allow(missing_docs)]
-    error AccessControlUnauthorizedAccount(address account, bytes32 needed_role);
-    /// The caller of a function is not the expected one.
-    ///
-    /// NOTE: Don't confuse with [`AccessControlUnauthorizedAccount`].
-    #[derive(Debug)]
-    #[allow(missing_docs)]
-    error AccessControlBadConfirmation();
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod sol {
+    use alloy_sol_macro::sol;
+
+    sol! {
+        /// Emitted when `new_admin_role` is set as `role`'s admin role, replacing
+        /// `previous_admin_role`.
+        ///
+        /// `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
+        /// `RoleAdminChanged` not being emitted signaling this.
+        #[allow(missing_docs)]
+        event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previous_admin_role, bytes32 indexed new_admin_role);
+        /// Emitted when `account` is granted `role`.
+        ///
+        /// `sender` is the account that originated the contract call. This account
+        /// bears the admin role (for the granted role).
+        /// Expected in cases where the role was granted using the internal
+        /// [`AccessControl::grant_role`].
+        #[allow(missing_docs)]
+        event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
+        /// Emitted when `account` is revoked `role`.
+        ///
+        /// `sender` is the account that originated the contract call:
+        ///   - if using `revoke_role`, it is the admin role bearer.
+        ///   - if using `renounce_role`, it is the role bearer (i.e. `account`).
+        #[allow(missing_docs)]
+        event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
+    }
+
+    sol! {
+        /// The `account` is missing a role.
+        ///
+        /// * `account` - Account that was found to not be authorized.
+        /// * `needed_role` - The missing role.
+        #[derive(Debug)]
+        #[allow(missing_docs)]
+        error AccessControlUnauthorizedAccount(address account, bytes32 needed_role);
+        /// The caller of a function is not the expected one.
+        ///
+        /// NOTE: Don't confuse with [`AccessControlUnauthorizedAccount`].
+        #[derive(Debug)]
+        #[allow(missing_docs)]
+        error AccessControlBadConfirmation();
+    }
 }
 
 /// An error that occurred in the implementation of an [`AccessControl`]
@@ -99,23 +106,23 @@
     BadConfirmation(AccessControlBadConfirmation),
 }
 
-sol_storage! {
-    /// Information about a specific role.
-    pub struct RoleData {
-        /// Whether an account is member of a certain role.
-        mapping(address => bool) has_role;
-        /// The admin role for this role.
-        bytes32 admin_role;
-    }
+/// Information about a specific role.
+#[storage]
+pub struct RoleData {
+    /// Whether an account is member of a certain role.
+    pub has_role: StorageMap<Address, StorageBool>,
+    /// The admin role for this role.
+    pub admin_role: StorageFixedBytes<32>,
+}
 
-    /// State of an `AccessControl` contract.
-    pub struct AccessControl {
-        /// Role identifier -> Role information.
-        mapping(bytes32 => RoleData) _roles;
-    }
+/// State of an `AccessControl` contract.
+#[storage]
+pub struct AccessControl {
+    /// Role identifier -> Role information.
+    pub _roles: StorageMap<FixedBytes<32>, RoleData>,
 }
 
 #[public]
 impl AccessControl {
     /// The default admin role. `[0; 32]` by default.
     pub const DEFAULT_ADMIN_ROLE: [u8; 32] = [0; 32];

contracts/src/access/ownable.rs

@@ -9,36 +9,43 @@
 //! [`Ownable::only_owner`] function, which can be called to restrict operations
 //! to the owner.
 use alloy_primitives::Address;
-use alloy_sol_types::sol;
 use openzeppelin_stylus_proc::interface_id;
+pub use sol::*;
 use stylus_sdk::{
     call::MethodError,
     evm, msg,
-    stylus_proc::{public, sol_storage, SolidityError},
+    prelude::storage,
+    storage::StorageAddress,
+    stylus_proc::{public, SolidityError},
 };
 
-sol! {
-    /// Emitted when ownership gets transferred between accounts.
-    ///
-    /// * `previous_owner` - Address of the previous owner.
-    /// * `new_owner` - Address of the new owner.
-    #[allow(missing_docs)]
-    event OwnershipTransferred(address indexed previous_owner, address indexed new_owner);
-}
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod sol {
+    use alloy_sol_macro::sol;
+
+    sol! {
+        /// Emitted when ownership gets transferred between accounts.
+        ///
+        /// * `previous_owner` - Address of the previous owner.
+        /// * `new_owner` - Address of the new owner.
+        #[allow(missing_docs)]
+        event OwnershipTransferred(address indexed previous_owner, address indexed new_owner);
+    }
 
-sol! {
-    /// The caller account is not authorized to perform an operation.
-    ///
-    /// * `account` - Account that was found to not be authorized.
-    #[derive(Debug)]
-    #[allow(missing_docs)]
-    error OwnableUnauthorizedAccount(address account);
-    /// The owner is not a valid owner account. (eg. `Address::ZERO`)
-    ///
-    /// * `owner` - Account that's not allowed to become the owner.
-    #[derive(Debug)]
-    #[allow(missing_docs)]
-    error OwnableInvalidOwner(address owner);
+    sol! {
+        /// The caller account is not authorized to perform an operation.
+        ///
+        /// * `account` - Account that was found to not be authorized.
+        #[derive(Debug)]
+        #[allow(missing_docs)]
+        error OwnableUnauthorizedAccount(address account);
+        /// The owner is not a valid owner account. (eg. `Address::ZERO`)
+        ///
+        /// * `owner` - Account that's not allowed to become the owner.
+        #[derive(Debug)]
+        #[allow(missing_docs)]
+        error OwnableInvalidOwner(address owner);
+    }
 }
 
 /// An error that occurred in the implementation of an [`Ownable`] contract.
@@ -56,12 +63,11 @@
     }
 }
 
-sol_storage! {
-    /// State of an `Ownable` contract.
-    pub struct Ownable {
-        /// The current owner of this contract.
-        address _owner;
-    }
+/// State of an `Ownable` contract.
+#[storage]
+pub struct Ownable {
+    /// The current owner of this contract.
+    pub _owner: StorageAddress,
 }
 
 /// Interface for an [`Ownable`] contract.
@@ -120,7 +126,7 @@
     fn renounce_ownership(&mut self) -> Result<(), Self::Error>;
 }
 
 #[public]
 impl IOwnable for Ownable {
     type Error = Error;
 

contracts/src/access/ownable_two_step.rs

@@ -17,27 +17,34 @@
 //! available.
 
 use alloy_primitives::Address;
-use alloy_sol_types::sol;
+pub use sol::*;
 use stylus_sdk::{
     evm, msg,
-    stylus_proc::{public, sol_storage, SolidityError},
+    prelude::storage,
+    storage::StorageAddress,
+    stylus_proc::{public, SolidityError},
 };
 
 use crate::access::ownable::{
     Error as OwnableError, IOwnable, Ownable, OwnableUnauthorizedAccount,
 };
 
-sol! {
-    /// Emitted when ownership transfer starts.
-    ///
-    /// * `previous_owner` - Address of the previous owner.
-    /// * `new_owner` - Address of the new owner, to which the ownership
-    ///   will be transferred.
-    event OwnershipTransferStarted(
-        address indexed previous_owner,
-        address indexed new_owner
-    );
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod sol {
+    use alloy_sol_macro::sol;
+
+    sol! {
+        /// Emitted when ownership transfer starts.
+        ///
+        /// * `previous_owner` - Address of the previous owner.
+        /// * `new_owner` - Address of the new owner, to which the ownership
+        ///   will be transferred.
+        event OwnershipTransferStarted(
+            address indexed previous_owner,
+            address indexed new_owner
+        );
 
+    }
 }
 
 /// An error that occurred in the implementation of an [`Ownable2Step`]
@@ -48,14 +55,13 @@
     Ownable(OwnableError),
 }
 
-sol_storage! {
-    /// State of an `Ownable2Step` contract.
-    pub struct Ownable2Step {
-        /// [`Ownable`] contract.
-        Ownable _ownable;
-        /// Pending owner of the contract.
-        address _pending_owner;
-    }
+/// State of an `Ownable2Step` contract.
+#[storage]
+pub struct Ownable2Step {
+    /// [`Ownable`] contract.
+    pub _ownable: Ownable,
+    /// Pending owner of the contract.
+    pub _pending_owner: StorageAddress,
 }
 
 /// Interface for an [`Ownable2Step`] contract.
@@ -140,7 +146,7 @@
     fn renounce_ownership(&mut self) -> Result<(), Self::Error>;
 }
 
 #[public]
 impl IOwnable2Step for Ownable2Step {
     type Error = Error;