feat: Add Stylus Constructors

Cargo.toml

@@ -77,7 +77,7 @@ all = "warn"
 
 [workspace.dependencies]
 # Stylus SDK related
-stylus-sdk = { version = "0.7.0", default-features = false, features = [
+stylus-sdk = { git = "https://github.com/OffchainLabs/stylus-sdk-rs.git", branch = "gligneul/constructors", default-features = false, features = [
   "mini-alloc",
 ] }
 

contracts/src/access/control.rs

@@ -124,6 +124,12 @@
 
 #[public]
 impl AccessControl {
+    /// Constructor
+    #[constructor]
+    pub fn constructor(&mut self) {
+        self._grant_role(Self::DEFAULT_ADMIN_ROLE.into(), msg::sender());
+    }
+
     /// Returns `true` if `account` has been granted `role`.
     ///
     /// # Arguments
@@ -411,26 +417,26 @@
             .insert(msg::sender(), true);
     }
 
     #[motsu::test]
     fn default_role_is_default_admin(contract: AccessControl) {
         let role_admin = contract.get_role_admin(ROLE.into());
         assert_eq!(role_admin, AccessControl::DEFAULT_ADMIN_ROLE);
     }
 
     #[motsu::test]
     fn default_admin_roles_admin_is_itself(contract: AccessControl) {
         const DEFAULT_ADMIN_ROLE: [u8; 32] = AccessControl::DEFAULT_ADMIN_ROLE;
         let role_admin = contract.get_role_admin(DEFAULT_ADMIN_ROLE.into());
         assert_eq!(role_admin, DEFAULT_ADMIN_ROLE);
     }
 
     #[motsu::test]
     fn non_admin_cannot_grant_role_to_others(contract: AccessControl) {
         let err = contract.grant_role(ROLE.into(), ALICE).unwrap_err();
         assert!(matches!(err, Error::UnauthorizedAccount(_)));
     }
 
     #[motsu::test]
     fn accounts_can_be_granted_roles_multiple_times(contract: AccessControl) {
         _grant_role_to_msg_sender(contract, AccessControl::DEFAULT_ADMIN_ROLE);
 
@@ -440,7 +446,7 @@
         assert!(has_role);
     }
 
     #[motsu::test]
     fn not_granted_roles_can_be_revoked(contract: AccessControl) {
         _grant_role_to_msg_sender(contract, AccessControl::DEFAULT_ADMIN_ROLE);
 
@@ -451,7 +457,7 @@
         assert!(!has_role);
     }
 
     #[motsu::test]
     fn admin_can_revoke_role(contract: AccessControl) {
         _grant_role_to_msg_sender(contract, AccessControl::DEFAULT_ADMIN_ROLE);
         contract._roles.setter(ROLE.into()).has_role.insert(ALICE, true);
@@ -463,7 +469,7 @@
         assert!(!has_role);
     }
 
     #[motsu::test]
     fn non_admin_cannot_revoke_role(contract: AccessControl) {
         contract._roles.setter(ROLE.into()).has_role.insert(ALICE, true);
 
@@ -473,7 +479,7 @@
         assert!(matches!(err, Error::UnauthorizedAccount(_)));
     }
 
     #[motsu::test]
     fn roles_can_be_revoked_multiple_times(contract: AccessControl) {
         _grant_role_to_msg_sender(contract, AccessControl::DEFAULT_ADMIN_ROLE);
 
@@ -483,7 +489,7 @@
         assert!(!has_role);
     }
 
     #[motsu::test]
     fn bearer_can_renounce_role(contract: AccessControl) {
         _grant_role_to_msg_sender(contract, ROLE);
 
@@ -494,7 +500,7 @@
         assert!(!has_role);
     }
 
     #[motsu::test]
     fn only_sender_can_renounce(contract: AccessControl) {
         _grant_role_to_msg_sender(contract, ROLE);
         let err = contract.renounce_role(ROLE.into(), ALICE).unwrap_err();

contracts/src/access/ownable.rs

@@ -161,6 +161,25 @@ impl IOwnable for Ownable {
     }
 }
 
+// TODO: uncomment once multiple public attributes are supported
+// NOTE: cannot include constructor in the above #[public], as constructor is
+// not part of the `IOwnable2Step` trait
+// #[public]
+// impl Ownable {
+//     /// Constructor
+//     #[constructor]
+//     pub fn constructor(&mut self, initial_owner: Address) -> Result<(),
+// Error> {         if initial_owner.is_zero() {
+//             return Err(OwnableError::InvalidOwner(OwnableInvalidOwner {
+//                 owner: Address::ZERO,
+//             })
+//             .into());
+//         }
+//         self._transfer_ownership(initial_owner);
+//         Ok(())
+//     }
+// }
+
 impl Ownable {
     /// Checks if the [`msg::sender`] is set as the owner.
     ///

contracts/src/access/ownable_two_step.rs

@@ -197,6 +197,25 @@ impl IOwnable2Step for Ownable2Step {
     }
 }
 
+// TODO: uncomment once multiple public attributes are supported
+// NOTE: cannot include constructor in the above #[public], as constructor is
+// not part of the `IOwnable2Step` trait
+// #[public]
+// impl Ownable2Step {
+//     /// Constructor
+//     #[constructor]
+//     pub fn constructor(&mut self, initial_owner: Address) -> Result<(),
+// Error> {         if initial_owner.is_zero() {
+//             return Err(OwnableError::InvalidOwner(OwnableInvalidOwner {
+//                 owner: Address::ZERO,
+//             })
+//             .into());
+//         }
+//         self._transfer_ownership(initial_owner);
+//         Ok(())
+//     }
+// }
+
 impl Ownable2Step {
     /// Transfers ownership of the contract to a new account (`new_owner`) and
     /// sets [`Self::pending_owner`] to `Address::ZERO` to avoid situations

examples/access-control/src/lib.rs

@@ -25,6 +25,11 @@ pub const TRANSFER_ROLE: [u8; 32] =
 #[public]
 #[inherit(Erc20, AccessControl)]
 impl AccessControlExample {
+    #[constructor]
+    pub fn constructor(&mut self) {
+        self.access.constructor();
+    }
+
     pub fn make_admin(&mut self, account: Address) -> Result<(), Vec<u8>> {
         self.access.only_role(AccessControl::DEFAULT_ADMIN_ROLE.into())?;
         self.access.grant_role(TRANSFER_ROLE.into(), account)?;