Update Readme

Author: mooori

README.md

@@ -96,58 +96,106 @@ Documentation of all methods provided by the derived implementation of `FullAcce
 Allow contracts to implement an emergency stop mechanism that can be triggered by an authorized account. Pauses can be
 used granularly to only limit certain features.
 
-Contract example using _Pausable_ plugin. Note that it requires the contract to be Ownable.
+Contract example using _Pausable_ plugin. Note that it requires the contract to be _AccessControllable_.
 
 ```rust
 
+/// Define roles for access control of `Pausable` features. Accounts which are
+/// granted a role are authorized to execute the corresponding action.
+#[derive(AccessControlRole, Deserialize, Serialize, Copy, Clone)]
+#[serde(crate = "near_sdk::serde")]
+pub enum Role {
+    /// May pause and unpause features.
+    PauseManager,
+    /// May call `increase_4` even when it is paused.
+    Unrestricted4Increaser,
+    /// May call `decrease_4` even when `increase_4` is not paused.
+    Unrestricted4Decreaser,
+    /// May always call both `increase_4` and `decrease_4`.
+    Unrestricted4Modifier,
+}
+
+#[access_control(role_type(Role))]
 #[near_bindgen]
-#[derive(Ownable, Pausable)]
+#[derive(Pausable)]
+#[pausable(manager_roles(Role::PauseManager))]
 struct Counter {
     counter: u64,
 }
 
 #[near_bindgen]
 impl Counter {
-    /// Specify the owner of the contract in the constructor
+    /// Initialize access control in the constructor.
     #[init]
     fn new() -> Self {
-        let mut contract = Self { counter: 0 };
-        contract.owner_set(Some(near_sdk::env::predecessor_account_id()));
+        let mut contract = Self {
+            counter: 0,
+            __acl: Default::default(),
+        };
+
+        // Make the contract itself access control super admin. This enables
+        // granting roles below.
+        near_sdk::require!(
+            contract.acl_init_super_admin(near_sdk::env::predecessor_account_id()),
+            "Failed to initialize super admin",
+        );
+
+        // Grant access control roles.
+        let grants: Vec<(Role, near_sdk::AccountId)> = vec![
+            (Role::PauseManager, "anna.test".parse().unwrap()),
+            (Role::Unrestricted4Increaser, "brenda.test".parse().unwrap()),
+            (Role::Unrestricted4Decreaser, "chris.test".parse().unwrap()),
+            (Role::Unrestricted4Modifier, "daniel.test".parse().unwrap()),
+        ];
+        for (role, account_id) in grants {
+            let result = contract.acl_grant_role(role.into(), account_id);
+            near_sdk::require!(Some(true) == result, "Failed to grant role");
+        }
+
         contract
     }
 
     /// Function can be paused using feature name "increase_1" or "ALL" like:
     /// `contract.pa_pause_feature("increase_1")` or `contract.pa_pause_feature("ALL")`
     ///
-    /// If the function is paused, all calls to it will fail. Even calls started from owner or self.
+    /// If the function is paused, all calls to it will fail. Even calls
+    /// initiated by accounts which are access control super admin or role
+    /// grantee.
     #[pause]
     fn increase_1(&mut self) {
         self.counter += 1;
     }
 
-    /// Similar to `#[pause]` but use an explicit name for the feature. In this case the feature to be paused
-    /// is named "Increase by two". Note that trying to pause it using "increase_2" will not have any effect.
+    /// Similar to `#[pause]` but use an explicit name for the feature. In this
+    /// case the feature to be paused is named "Increase by two". Note that
+    /// trying to pause it using "increase_2" will not have any effect.
     ///
-    /// This can be used to pause a subset of the methods at once without requiring to use "ALL".
+    /// This can be used to pause a subset of the methods at once without
+    /// requiring to use "ALL".
     #[pause(name = "Increase by two")]
     fn increase_2(&mut self) {
         self.counter += 2;
     }
 
-    /// Similar to `#[pause]` but owner or self can still call this method. Any subset of {self, owner} can be specified.
-    #[pause(except(owner, self))]
+    /// Similar to `#[pause]` but roles passed as argument may still
+    /// successfully call this method.
+    #[pause(except(roles(Role::Unrestricted4Increaser, Role::Unrestricted4Modifier)))]
     fn increase_4(&mut self) {
         self.counter += 4;
     }
 
-    /// This method can only be called when "increase_1" is paused. Use this macro to create escape hatches when some
-    /// features are paused. Note that if "ALL" is specified the "increase_1" is considered to be paused.
+    /// This method can only be called when "increase_1" is paused. Use this
+    /// macro to create escape hatches when some features are paused. Note that
+    /// if "ALL" is specified the "increase_1" is considered to be paused.
     #[if_paused(name = "increase_1")]
     fn decrease_1(&mut self) {
         self.counter -= 1;
     }
 
     /// Custom use of pause features. Only allow increasing the counter using `careful_increase` if it is below 10.
+
+    /// Custom use of pause features. Only allow increasing the counter using
+    /// `careful_increase` if it is below 10.
     fn careful_increase(&mut self) {
         if self.counter >= 10 {
             assert!(

near-plugins/src/pausable.rs

@@ -516,5 +516,4 @@ mod tests {
         counter.decrease_1();
         assert_eq!(counter.counter, 0);
     }
-
 }