Migrate Ownable to component

docs/modules/ROOT/pages/access.adoc

@@ -19,26 +19,42 @@ OpenZeppelin Contracts for Cairo provides {ownable-cairo} for implementing owner
 
 === Usage
 
-Integrating this module into a contract first requires assigning an owner.
+Integrating this component into a contract first requires assigning an owner.
 The implementing contract's constructor should set the initial owner by passing the owner's address to Ownable's
 xref:/api/access.adoc#AccessControl-initializer[`initializer`] like this:
 
 [,javascript]
 ----
-use openzeppelin::access::ownable::Ownable;
-
 #[starknet::contract]
 mod MyContract {
+    use openzeppelin::access::ownable::Ownable as ownable_component;
     use starknet::ContractAddress;
-    use super::Ownable;
+
+    component!(path: ownable_component, storage: ownable, event: OwnableEvent);
+
+    #[abi(embed_v0)]
+    impl OwnableImpl = ownable_component::OwnableImpl<ContractState>;
+    #[abi(embed_v0)]
+    impl OwnableCamelOnlyImpl =
+        ownable_component::OwnableCamelOnlyImpl<ContractState>;
+    impl InternalImpl = ownable_component::InternalImpl<ContractState>;
 
     #[storage]
-    struct Storage {}
+    struct Storage {
+        #[substorage(v0)]
+        ownable: ownable_component::Storage
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        OwnableEvent: ownable_component::Event
+    }
 
     #[constructor]
-    fn constructor(self: @ContractState, owner: ContractAddress) {
-        let mut unsafe_state = Ownable::unsafe_new_contract_state();
-        Ownable::InternalImpl::initializer(ref unsafe_state, owner);
+    fn constructor(ref self: ContractState, owner: ContractAddress) {
+        // Set the initial owner of the contract
+        self.ownable.initializer(owner);
     }
 
     (...)
@@ -51,15 +67,12 @@ To restrict a function's access to the owner only, add in the `assert_only_owner
 ----
 #[starknet::contract]
 mod MyContract {
-    use openzeppelin::access::ownable::Ownable;
-
     (...)
 
     #[external(v0)]
-    fn foo(ref self: ContractState) {
+    fn only_owner_allowed(ref self: ContractState) {
         // This function can only be called by the owner
-        let unsafe_state = Ownable::unsafe_new_contract_state();
-        Ownable::InternalImpl::assert_only_owner(@unsafe_state);
+        self.ownable.assert_only_owner();
 
         (...)
     }

docs/modules/ROOT/pages/api/access.adoc

@@ -27,10 +27,10 @@ use openzeppelin::access::ownable::Ownable;
 `Ownable` provides a basic access control mechanism where an account
  (an owner) can be granted exclusive access to specific functions.
 
-This module includes the `assert_only_owner` internal to restrict a function to be used only by the owner.
+This module includes the internal `assert_only_owner` to restrict a function to be used only by the owner.
 
 [.contract-index]
-.External Functions
+.Embeddable Functions
 --
 .OwnableImpl
 
@@ -39,6 +39,15 @@ This module includes the `assert_only_owner` internal to restrict a function to
 * xref:Ownable-renounce_ownership[`++renounce_ownership(self)++`]
 --
 
+[.contract-index]
+.camelCase Support
+--
+.OwnableCamelOnlyImpl
+
+* xref:Ownable-transferOwnership[`++transferOwnership(self, newOwner)++`]
+* xref:Ownable-renounceOwnership[`++renounceOwnership(self)++`]
+--
+
 [.contract-index]
 .Internal Functions
 --
@@ -55,8 +64,8 @@ This module includes the `assert_only_owner` internal to restrict a function to
 * xref:Ownable-OwnershipTransferred[`++OwnershipTransferred(previous_owner, new_owner)++`]
 --
 
-[#Ownable-External-Functions]
-==== External Functions
+[#Ownable-Embeddable-Functions]
+==== Embeddable Functions
 
 [.contract-item]
 [[Ownable-owner]]
@@ -83,6 +92,21 @@ Leaves the contract without owner. It will not be possible to call
 NOTE: Renouncing ownership will leave the contract without an owner,
 thereby removing any functionality that is only available to the owner.
 
+[#Ownable-camelCase-Support]
+==== camelCase Support
+
+[.contract-item]
+[[Ownable-transferOwnership]]
+==== `[.contract-item-name]#++transferOwnership++#++(ref self: ContractState, newOwner: ContractAddress)++` [.item-kind]#external#
+
+See xref:Ownable-transfer_ownership[transfer_ownership].
+
+[.contract-item]
+[[Ownable-renounceOwnership]]
+==== `[.contract-item-name]#++renounceOwnership++#++(ref self: ContractState)++` [.item-kind]#external#
+
+See xref:Ownable-renounce_ownership[renounce_ownership].
+
 [#Ownable-Internal-Functions]
 ==== Internal Functions
 

src/access/ownable/dual_ownable.cairo

@@ -1,13 +1,11 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts for Cairo v0.7.0 (access/ownable/dual_ownable.cairo)
 
-use openzeppelin::utils::Felt252TryIntoBool;
 use openzeppelin::utils::UnwrapAndCast;
 use openzeppelin::utils::selectors;
 use openzeppelin::utils::serde::SerializedAppend;
 use openzeppelin::utils::try_selector_with_fallback;
 use starknet::ContractAddress;
-use starknet::Felt252TryIntoContractAddress;
 use starknet::SyscallResultTrait;
 use starknet::call_contract_syscall;
 
@@ -24,14 +22,14 @@ trait DualCaseOwnableTrait {
 
 impl DualCaseOwnableImpl of DualCaseOwnableTrait {
     fn owner(self: @DualCaseOwnable) -> ContractAddress {
-        let args = ArrayTrait::new();
+        let args = array![];
 
         call_contract_syscall(*self.contract_address, selectors::owner, args.span())
             .unwrap_and_cast()
     }
 
     fn transfer_ownership(self: @DualCaseOwnable, new_owner: ContractAddress) {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
         args.append_serde(new_owner);
 
         try_selector_with_fallback(
@@ -44,7 +42,7 @@ impl DualCaseOwnableImpl of DualCaseOwnableTrait {
     }
 
     fn renounce_ownership(self: @DualCaseOwnable) {
-        let mut args = ArrayTrait::new();
+        let mut args = array![];
 
         try_selector_with_fallback(
             *self.contract_address,

src/access/ownable/ownable.cairo

@@ -1,7 +1,15 @@
 // SPDX-License-Identifier: MIT
 // OpenZeppelin Contracts for Cairo v0.7.0 (access/ownable/ownable.cairo)
 
-#[starknet::contract]
+/// # Ownable Component
+///
+/// The Ownable component provides a basic access control mechanism, where
+/// there is an account (an owner) that can be granted exclusive access to
+/// specific functions.
+///
+/// The initial owner can be set by using the `initializer` function in
+/// construction time. This can later be changed with `transfer_ownership`.
+#[starknet::component]
 mod Ownable {
     use openzeppelin::access::ownable::interface;
     use starknet::ContractAddress;
@@ -30,20 +38,72 @@ mod Ownable {
         const ZERO_ADDRESS_OWNER: felt252 = 'New owner is the zero address';
     }
 
+    #[embeddable_as(OwnableImpl)]
+    impl Ownable<
+        TContractState, +HasComponent<TContractState>
+    > of interface::IOwnable<ComponentState<TContractState>> {
+        /// Returns the address of the current owner.
+        fn owner(self: @ComponentState<TContractState>) -> ContractAddress {
+            self.Ownable_owner.read()
+        }
+
+        /// Transfers ownership of the contract to a new address.
+        fn transfer_ownership(
+            ref self: ComponentState<TContractState>, new_owner: ContractAddress
+        ) {
+            assert(!new_owner.is_zero(), Errors::ZERO_ADDRESS_OWNER);
+            self.assert_only_owner();
+            self._transfer_ownership(new_owner);
+        }
+
+        /// Leaves the contract without owner. It will not be possible to call `assert_only_owner`
+        /// functions anymore. Can only be called by the current owner.
+        fn renounce_ownership(ref self: ComponentState<TContractState>) {
+            self.assert_only_owner();
+            self._transfer_ownership(Zeroable::zero());
+        }
+    }
+
+    /// Adds camelCase support for `IOwnable`.
+    #[embeddable_as(OwnableCamelOnlyImpl)]
+    impl OwnableCamelOnly<
+        TContractState, +HasComponent<TContractState>
+    > of interface::IOwnableCamelOnly<ComponentState<TContractState>> {
+        fn transferOwnership(ref self: ComponentState<TContractState>, newOwner: ContractAddress) {
+            self.transfer_ownership(newOwner);
+        }
+
+        fn renounceOwnership(ref self: ComponentState<TContractState>) {
+            self.renounce_ownership();
+        }
+    }
+
     #[generate_trait]
-    impl InternalImpl of InternalTrait {
-        fn initializer(ref self: ContractState, owner: ContractAddress) {
+    impl InternalImpl<
+        TContractState, +HasComponent<TContractState>
+    > of InternalTrait<TContractState> {
+        /// Sets the contract's initial owner.
+        ///
+        /// This function should be called at construction time.
+        fn initializer(ref self: ComponentState<TContractState>, owner: ContractAddress) {
             self._transfer_ownership(owner);
         }
 
-        fn assert_only_owner(self: @ContractState) {
+        /// Panics if called by any account other than the owner. Use this
+        /// to restrict access to certain functions to the owner.
+        fn assert_only_owner(self: @ComponentState<TContractState>) {
             let owner: ContractAddress = self.Ownable_owner.read();
             let caller: ContractAddress = get_caller_address();
             assert(!caller.is_zero(), Errors::ZERO_ADDRESS_CALLER);
             assert(caller == owner, Errors::NOT_OWNER);
         }
 
-        fn _transfer_ownership(ref self: ContractState, new_owner: ContractAddress) {
+        /// Transfers ownership of the contract to a new address.
+        ///
+        /// Internal function without access restriction.
+        fn _transfer_ownership(
+            ref self: ComponentState<TContractState>, new_owner: ContractAddress
+        ) {
             let previous_owner: ContractAddress = self.Ownable_owner.read();
             self.Ownable_owner.write(new_owner);
             self
@@ -52,33 +112,4 @@ mod Ownable {
                 );
         }
     }
-
-    #[external(v0)]
-    impl OwnableImpl of interface::IOwnable<ContractState> {
-        fn owner(self: @ContractState) -> ContractAddress {
-            self.Ownable_owner.read()
-        }
-
-        fn transfer_ownership(ref self: ContractState, new_owner: ContractAddress) {
-            assert(!new_owner.is_zero(), Errors::ZERO_ADDRESS_OWNER);
-            self.assert_only_owner();
-            self._transfer_ownership(new_owner);
-        }
-
-        fn renounce_ownership(ref self: ContractState) {
-            self.assert_only_owner();
-            self._transfer_ownership(Zeroable::zero());
-        }
-    }
-
-    #[external(v0)]
-    impl OwnableCamelOnlyImpl of interface::IOwnableCamelOnly<ContractState> {
-        fn transferOwnership(ref self: ContractState, newOwner: ContractAddress) {
-            OwnableImpl::transfer_ownership(ref self, newOwner);
-        }
-
-        fn renounceOwnership(ref self: ContractState) {
-            OwnableImpl::renounce_ownership(ref self);
-        }
-    }
 }

src/tests/access/test_dual_ownable.cairo

@@ -1,33 +1,31 @@
 use openzeppelin::access::ownable::dual_ownable::DualCaseOwnable;
 use openzeppelin::access::ownable::dual_ownable::DualCaseOwnableTrait;
 use openzeppelin::access::ownable::interface::IOwnableCamelOnlyDispatcher;
-use openzeppelin::access::ownable::interface::IOwnableCamelOnlyDispatcherTrait;
 use openzeppelin::access::ownable::interface::IOwnableDispatcher;
 use openzeppelin::access::ownable::interface::IOwnableDispatcherTrait;
-use openzeppelin::tests::mocks::dual_ownable_mocks::CamelOwnableMock;
-use openzeppelin::tests::mocks::dual_ownable_mocks::CamelOwnablePanicMock;
-use openzeppelin::tests::mocks::dual_ownable_mocks::SnakeOwnableMock;
-use openzeppelin::tests::mocks::dual_ownable_mocks::SnakeOwnablePanicMock;
 use openzeppelin::tests::mocks::non_implementing_mock::NonImplementingMock;
+use openzeppelin::tests::mocks::ownable_mocks::CamelOwnableMock;
+use openzeppelin::tests::mocks::ownable_mocks::CamelOwnablePanicMock;
+use openzeppelin::tests::mocks::ownable_mocks::SnakeOwnableMock;
+use openzeppelin::tests::mocks::ownable_mocks::SnakeOwnablePanicMock;
 use openzeppelin::tests::utils::constants::{OWNER, NEW_OWNER};
 use openzeppelin::tests::utils;
 use openzeppelin::utils::serde::SerializedAppend;
-use starknet::testing::set_caller_address;
 use starknet::testing::set_contract_address;
 
 //
 // Setup
 //
 
 fn setup_snake() -> (DualCaseOwnable, IOwnableDispatcher) {
-    let mut calldata = ArrayTrait::new();
+    let mut calldata = array![];
     calldata.append_serde(OWNER());
     let target = utils::deploy(SnakeOwnableMock::TEST_CLASS_HASH, calldata);
     (DualCaseOwnable { contract_address: target }, IOwnableDispatcher { contract_address: target })
 }
 
 fn setup_camel() -> (DualCaseOwnable, IOwnableCamelOnlyDispatcher) {
-    let mut calldata = ArrayTrait::new();
+    let mut calldata = array![];
     calldata.append_serde(OWNER());
     let target = utils::deploy(CamelOwnableMock::TEST_CLASS_HASH, calldata);
     (
@@ -37,14 +35,14 @@ fn setup_camel() -> (DualCaseOwnable, IOwnableCamelOnlyDispatcher) {
 }
 
 fn setup_non_ownable() -> DualCaseOwnable {
-    let calldata = ArrayTrait::new();
+    let calldata = array![];
     let target = utils::deploy(NonImplementingMock::TEST_CLASS_HASH, calldata);
     DualCaseOwnable { contract_address: target }
 }
 
 fn setup_ownable_panic() -> (DualCaseOwnable, DualCaseOwnable) {
-    let snake_target = utils::deploy(SnakeOwnablePanicMock::TEST_CLASS_HASH, ArrayTrait::new());
-    let camel_target = utils::deploy(CamelOwnablePanicMock::TEST_CLASS_HASH, ArrayTrait::new());
+    let snake_target = utils::deploy(SnakeOwnablePanicMock::TEST_CLASS_HASH, array![]);
+    let camel_target = utils::deploy(CamelOwnablePanicMock::TEST_CLASS_HASH, array![]);
     (
         DualCaseOwnable { contract_address: snake_target },
         DualCaseOwnable { contract_address: camel_target }
@@ -118,7 +116,6 @@ fn test_dual_renounce_ownership() {
     assert(target.owner().is_zero(), 'Should be zero');
 }
 
-
 #[test]
 #[available_gas(2000000)]
 #[should_panic(expected: ('ENTRYPOINT_NOT_FOUND',))]