Migrate access control to cairo2

src/openzeppelin/access.cairo

@@ -1,2 +1,2 @@
-//mod accesscontrol;
+mod accesscontrol;
 mod ownable;

src/openzeppelin/access/accesscontrol/accesscontrol.cairo

@@ -1,211 +1,165 @@
-#[contract]
+#[starknet::contract]
 mod AccessControl {
-    use openzeppelin::access::accesscontrol::interface;
-    use openzeppelin::introspection::src5;
     use starknet::ContractAddress;
     use starknet::get_caller_address;
+    use openzeppelin::access::accesscontrol::interface;
+    use openzeppelin::introspection::interface::ISRC5;
+    use openzeppelin::introspection::interface::ISRC5Camel;
+    use openzeppelin::introspection::src5::SRC5;
 
+    #[storage]
     struct Storage {
         role_admin: LegacyMap<felt252, felt252>,
         role_members: LegacyMap<(felt252, ContractAddress), bool>,
     }
 
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        RoleGranted: RoleGranted,
+        RoleRevoked: RoleRevoked,
+        RoleAdminChanged: RoleAdminChanged,
+    }
+
     /// Emitted when `account` is granted `role`.
     ///
     /// `sender` is the account that originated the contract call, an admin role
     /// bearer (except if `_grant_role` is called during initialization from the constructor).
-    #[event]
-    fn RoleGranted(role: felt252, account: ContractAddress, sender: ContractAddress) {}
+    #[derive(Drop, starknet::Event)]
+    struct RoleGranted {
+        role: felt252,
+        account: ContractAddress,
+        sender: ContractAddress
+    }
 
     /// 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`).
-    #[event]
-    fn RoleRevoked(role: felt252, account: ContractAddress, sender: ContractAddress) {}
+    #[derive(Drop, starknet::Event)]
+    struct RoleRevoked {
+        role: felt252,
+        account: ContractAddress,
+        sender: ContractAddress
+    }
 
     /// 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.
-    #[event]
-    fn RoleAdminChanged(role: felt252, previous_admin_role: felt252, new_admin_role: felt252) {}
-
-    impl ISRC5Impl of src5::ISRC5 {
-        fn supports_interface(interface_id: felt252) -> bool {
-            src5::SRC5::supports_interface(interface_id)
+    #[derive(Drop, starknet::Event)]
+    struct RoleAdminChanged {
+        role: felt252,
+        previous_admin_role: felt252,
+        new_admin_role: felt252
+    }
+
+    #[external(v0)]
+    impl SRC5Impl of ISRC5<ContractState> {
+        fn supports_interface(self: @ContractState, interface_id: felt252) -> bool {
+            let unsafe_state = SRC5::unsafe_new_contract_state();
+            SRC5::SRC5Impl::supports_interface(@unsafe_state, interface_id)
         }
     }
 
-    impl ISRC5CamelImpl of src5::ISRC5Camel {
-        fn supportsInterface(interfaceId: felt252) -> bool {
-            src5::SRC5::supportsInterface(interfaceId)
+    #[external(v0)]
+    impl SRC5CamelImpl of ISRC5Camel<ContractState> {
+        fn supportsInterface(self: @ContractState, interfaceId: felt252) -> bool {
+            let unsafe_state = SRC5::unsafe_new_contract_state();
+            SRC5::SRC5CamelImpl::supportsInterface(@unsafe_state, interfaceId)
         }
     }
 
-    impl AccessControlImpl of interface::IAccessControl {
-        fn has_role(role: felt252, account: ContractAddress) -> bool {
-            role_members::read((role, account))
+    #[external(v0)]
+    impl AccessControlImpl of interface::IAccessControl<ContractState> {
+        fn has_role(self: @ContractState, role: felt252, account: ContractAddress) -> bool {
+            self.role_members.read((role, account))
         }
 
-        fn get_role_admin(role: felt252) -> felt252 {
-            role_admin::read(role)
+        fn get_role_admin(self: @ContractState, role: felt252) -> felt252 {
+            self.role_admin.read(role)
         }
 
-        fn grant_role(role: felt252, account: ContractAddress) {
-            let admin = get_role_admin(role);
-            assert_only_role(admin);
-            _grant_role(role, account);
+        fn grant_role(ref self: ContractState, role: felt252, account: ContractAddress) {
+            let admin = AccessControlImpl::get_role_admin(@self, role);
+            self.assert_only_role(admin);
+            self._grant_role(role, account);
         }
 
-        fn revoke_role(role: felt252, account: ContractAddress) {
-            let admin: felt252 = get_role_admin(role);
-            assert_only_role(admin);
-            _revoke_role(role, account);
+        fn revoke_role(ref self: ContractState, role: felt252, account: ContractAddress) {
+            let admin = AccessControlImpl::get_role_admin(@self, role);
+            self.assert_only_role(admin);
+            self._revoke_role(role, account);
         }
 
-        fn renounce_role(role: felt252, account: ContractAddress) {
+        fn renounce_role(ref self: ContractState, role: felt252, account: ContractAddress) {
             let caller: ContractAddress = get_caller_address();
             assert(caller == account, 'Can only renounce role for self');
-            _revoke_role(role, account);
+            self._revoke_role(role, account);
         }
     }
 
-    impl AccessControlCamelImpl of interface::IAccessControlCamel {
-        fn hasRole(role: felt252, account: ContractAddress) -> bool {
-            AccessControlImpl::has_role(role, account)
+    #[external(v0)]
+    impl AccessControlCamelImpl of interface::IAccessControlCamel<ContractState> {
+        fn hasRole(self: @ContractState, role: felt252, account: ContractAddress) -> bool {
+            AccessControlImpl::has_role(self, role, account)
         }
 
-        fn getRoleAdmin(role: felt252) -> felt252 {
-            AccessControlImpl::get_role_admin(role)
+        fn getRoleAdmin(self: @ContractState, role: felt252) -> felt252 {
+            AccessControlImpl::get_role_admin(self, role)
         }
 
-        fn grantRole(role: felt252, account: ContractAddress) {
-            AccessControlImpl::grant_role(role, account);
+        fn grantRole(ref self: ContractState, role: felt252, account: ContractAddress) {
+            AccessControlImpl::grant_role(ref self, role, account);
         }
 
-        fn revokeRole(role: felt252, account: ContractAddress) {
-            AccessControlImpl::revoke_role(role, account);
+        fn revokeRole(ref self: ContractState, role: felt252, account: ContractAddress) {
+            AccessControlImpl::revoke_role(ref self, role, account);
         }
 
-        fn renounceRole(role: felt252, account: ContractAddress) {
-            AccessControlImpl::renounce_role(role, account);
+        fn renounceRole(ref self: ContractState, role: felt252, account: ContractAddress) {
+            AccessControlImpl::renounce_role(ref self, role, account);
         }
     }
 
     //
-    // View
-    //
-
-    #[view]
-    fn supports_interface(interface_id: felt252) -> bool {
-        ISRC5Impl::supports_interface(interface_id)
-    }
-
-    #[view]
-    fn supportsInterface(interfaceId: felt252) -> bool {
-        ISRC5CamelImpl::supportsInterface(interfaceId)
-    }
-
-    #[view]
-    fn has_role(role: felt252, account: ContractAddress) -> bool {
-        AccessControlImpl::has_role(role, account)
-    }
-
-    #[view]
-    fn hasRole(role: felt252, account: ContractAddress) -> bool {
-        AccessControlCamelImpl::hasRole(role, account)
-    }
-
-    #[view]
-    fn get_role_admin(role: felt252) -> felt252 {
-        AccessControlImpl::get_role_admin(role)
-    }
-
-    #[view]
-    fn getRoleAdmin(role: felt252) -> felt252 {
-        AccessControlCamelImpl::getRoleAdmin(role)
-    }
-
-    //
-    // External
-    //
-
-    #[external]
-    fn grant_role(role: felt252, account: ContractAddress) {
-        AccessControlImpl::grant_role(role, account);
-    }
-
-    #[external]
-    fn grantRole(role: felt252, account: ContractAddress) {
-        AccessControlCamelImpl::grantRole(role, account);
-    }
-
-    #[external]
-    fn revoke_role(role: felt252, account: ContractAddress) {
-        AccessControlImpl::revoke_role(role, account);
-    }
-
-    #[external]
-    fn revokeRole(role: felt252, account: ContractAddress) {
-        AccessControlCamelImpl::revokeRole(role, account);
-    }
-
-    #[external]
-    fn renounce_role(role: felt252, account: ContractAddress) {
-        AccessControlImpl::renounce_role(role, account);
-    }
-
-    #[external]
-    fn renounceRole(role: felt252, account: ContractAddress) {
-        AccessControlCamelImpl::renounceRole(role, account);
-    }
-
-    //
-    // Internals
+    // Internal
     //
 
-    #[internal]
-    fn initializer() {
-        src5::SRC5::register_interface(interface::IACCESSCONTROL_ID);
-    }
-
-    #[internal]
-    fn assert_only_role(role: felt252) {
-        let caller: ContractAddress = get_caller_address();
-        let authorized: bool = has_role(role, caller);
-        assert(authorized, 'Caller is missing role');
-    }
-
-    //
-    // WARNING
-    // The following internal methods are unprotected and should not be used
-    // outside of a contract's constructor.
-    //
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        fn initializer(ref self: ContractState) {
+            let mut unsafe_state = SRC5::unsafe_new_contract_state();
+            SRC5::InternalImpl::register_interface(ref unsafe_state, interface::IACCESSCONTROL_ID);
+        }
 
-    #[internal]
-    fn _grant_role(role: felt252, account: ContractAddress) {
-        if !has_role(role, account) {
+        fn assert_only_role(self: @ContractState, role: felt252) {
             let caller: ContractAddress = get_caller_address();
-            role_members::write((role, account), true);
-            RoleGranted(role, account, caller);
+            let authorized: bool = AccessControlImpl::has_role(self, role, caller);
+            assert(authorized, 'Caller is missing role');
         }
-    }
 
-    #[internal]
-    fn _revoke_role(role: felt252, account: ContractAddress) {
-        if has_role(role, account) {
-            let caller: ContractAddress = get_caller_address();
-            role_members::write((role, account), false);
-            RoleRevoked(role, account, caller);
+        fn _grant_role(ref self: ContractState, role: felt252, account: ContractAddress) {
+            if !AccessControlImpl::has_role(@self, role, account) {
+                let caller: ContractAddress = get_caller_address();
+                self.role_members.write((role, account), true);
+                self.emit(RoleGranted { role, account, sender: caller });
+            }
         }
-    }
 
-    #[internal]
-    fn _set_role_admin(role: felt252, admin_role: felt252) {
-        let previous_admin_role: felt252 = get_role_admin(role);
-        role_admin::write(role, admin_role);
-        RoleAdminChanged(role, previous_admin_role, admin_role);
+        fn _revoke_role(ref self: ContractState, role: felt252, account: ContractAddress) {
+            if AccessControlImpl::has_role(@self, role, account) {
+                let caller: ContractAddress = get_caller_address();
+                self.role_members.write((role, account), false);
+                self.emit(RoleRevoked { role, account, sender: caller });
+            }
+        }
+
+        fn _set_role_admin(ref self: ContractState, role: felt252, admin_role: felt252) {
+            let previous_admin_role: felt252 = AccessControlImpl::get_role_admin(@self, role);
+            self.role_admin.write(role, admin_role);
+            self.emit(RoleAdminChanged { role, previous_admin_role, new_admin_role: admin_role });
+        }
     }
 }

src/openzeppelin/access/accesscontrol/dual_accesscontrol.cairo

@@ -24,7 +24,7 @@ trait DualCaseAccessControlTrait {
 
 impl DualCaseAccessControlImpl of DualCaseAccessControlTrait {
     fn has_role(self: @DualCaseAccessControl, role: felt252, account: ContractAddress) -> bool {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
         args.append_serde(role);
         args.append_serde(account);
 
@@ -35,7 +35,7 @@ impl DualCaseAccessControlImpl of DualCaseAccessControlTrait {
     }
 
     fn get_role_admin(self: @DualCaseAccessControl, role: felt252) -> felt252 {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
         args.append_serde(role);
 
         try_selector_with_fallback(
@@ -45,7 +45,7 @@ impl DualCaseAccessControlImpl of DualCaseAccessControlTrait {
     }
 
     fn grant_role(self: @DualCaseAccessControl, role: felt252, account: ContractAddress) {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
         args.append_serde(role);
         args.append_serde(account);
 
@@ -56,7 +56,7 @@ impl DualCaseAccessControlImpl of DualCaseAccessControlTrait {
     }
 
     fn revoke_role(self: @DualCaseAccessControl, role: felt252, account: ContractAddress) {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
         args.append_serde(role);
         args.append_serde(account);
 
@@ -67,7 +67,7 @@ impl DualCaseAccessControlImpl of DualCaseAccessControlTrait {
     }
 
     fn renounce_role(self: @DualCaseAccessControl, role: felt252, account: ContractAddress) {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
         args.append_serde(role);
         args.append_serde(account);
 
@@ -78,7 +78,7 @@ impl DualCaseAccessControlImpl of DualCaseAccessControlTrait {
     }
 
     fn supports_interface(self: @DualCaseAccessControl, interface_id: felt252) -> bool {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
         args.append_serde(interface_id);
 
         try_selector_with_fallback(