chore: deduplicate Pausable docs and examples

README.md

@@ -96,120 +96,11 @@ 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 _AccessControllable_ in order to manage permissions. Roles allowing accounts to call certain methods can be granted and revoked via the _AccessControllable_ plugin.
+Using the `Pausable` plugin requires the contract to be _AccessControllable_ in order to manage permissions. Roles allowing accounts to call certain methods can be granted and revoked via the _AccessControllable_ plugin.
 
-```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(Pausable)]
-#[pausable(manager_roles(Role::PauseManager))]
-struct Counter {
-    counter: u64,
-}
-
-#[near_bindgen]
-impl Counter {
-    /// Initialize access control in the constructor.
-    #[init]
-    fn new() -> Self {
-        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
-    /// 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.
-    ///
-    /// 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 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.
-    #[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!(
-                !self.pa_is_paused("INCREASE_BIG".to_string()),
-                "Method paused for large values of counter"
-            );
-        }
-
-        self.counter += 1;
-    }
-}
-```
+[This contract](/near-plugins/tests/contracts/pausable/src/lib.rs) provides an example of using `Pausable`. It is compiled, deployed on chain and interacted with in [integration tests](/near-plugins/tests/pausable.rs).
 
-Documentation of all methods provided by the derived implementation of `Pausable` is available in the [definition of the trait](/near-plugins/src/pausable.rs). More examples and guidelines for interacting with a `Pausable` contract can be found [here](/examples/pausable-examples/README.md).
+Documentation of all methods provided by `Pausable` is available in the [definition of the trait](/near-plugins/src/pausable.rs).
 
 ### [Upgradable](/near-plugins/src/upgradable.rs)