Rename recoveryPause to partialPause

Author: davekay100

cli/commands/protocol/get.ts

@@ -49,7 +49,7 @@ export const gettersList = {
   'controller-governor': { contract: 'Controller', name: 'governor' },
   'controller-get-contract-proxy': { contract: 'Controller', name: 'getContractProxy' },
   'controller-get-paused': { contract: 'Controller', name: 'paused' },
-  'controller-get-recovery-paused': { contract: 'Controller', name: 'recoveryPaused' },
+  'controller-get-partial-paused': { contract: 'Controller', name: 'partialPaused' },
   'controller-get-pause-guardian': { contract: 'Controller', name: 'pauseGuardian' },
 }
 

cli/commands/protocol/set.ts

@@ -55,7 +55,7 @@ export const settersList = {
   'controller-accept-governor': { contract: 'Controller', name: 'acceptOwnership' },
   'controller-set-contract-proxy': { contract: 'Controller', name: 'setContractProxy' },
   'controller-set-paused': { contract: 'Controller', name: 'setPaused' },
-  'controller-set-recovery-paused': { contract: 'Controller', name: 'setRecoveryPaused' },
+  'controller-set-partial-paused': { contract: 'Controller', name: 'setPartialPaused' },
   'controller-set-pause-guardian': { contract: 'Controller', name: 'setPauseGuardian' },
 }
 

contracts/curation/Curation.sol

@@ -175,7 +175,7 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration {
     function mint(bytes32 _subgraphDeploymentID, uint256 _tokens)
         external
         override
-        notRecoveryPaused
+        notPartialPaused
         returns (uint256)
     {
         address curator = msg.sender;
@@ -233,7 +233,7 @@ contract Curation is CurationV1Storage, GraphUpgradeable, ICuration {
     function burn(bytes32 _subgraphDeploymentID, uint256 _signal)
         external
         override
-        notRecoveryPaused
+        notPartialPaused
         returns (uint256, uint256)
     {
         address curator = msg.sender;

contracts/governance/Controller.sol

@@ -61,11 +61,11 @@ contract Controller is IController, Governed, Pausable {
     }
 
     /**
-     * @notice Change the recovery paused state of the contract
-     * Recovery pause is intented as a partial pause of the protocol
+     * @notice Change the partial paused state of the contract
+     * Partial pause is intented as a partial pause of the protocol
      */
-    function setRecoveryPaused(bool _recoveryPaused) external onlyGovernorOrGuardian {
-        _setRecoveryPaused(_recoveryPaused);
+    function setPartialPaused(bool _partialPaused) external onlyGovernorOrGuardian {
+        _setPartialPaused(_partialPaused);
     }
 
     /**
@@ -100,9 +100,9 @@ contract Controller is IController, Governed, Pausable {
     }
 
     /**
-     * @notice Getter to access recovery paused
+     * @notice Getter to access partial pause status
      */
-    function recoveryPaused() external override view returns (bool) {
-        return _recoveryPaused;
+    function partialPaused() external override view returns (bool) {
+        return _partialPaused;
     }
 }

contracts/governance/IController.sol

@@ -13,5 +13,5 @@ interface IController {
 
     function paused() external view returns (bool);
 
-    function recoveryPaused() external view returns (bool);
+    function partialPaused() external view returns (bool);
 }

contracts/governance/Managed.sol

@@ -21,17 +21,17 @@ contract Managed {
     event ParameterUpdated(string param);
     event SetController(address controller);
 
-    function _notRecoveryPaused() internal view {
+    function _notPartialPaused() internal view {
         require(!controller.paused(), "Paused");
-        require(!controller.recoveryPaused(), "Recovery-paused");
+        require(!controller.partialPaused(), "Partial-paused");
     }
 
     function _paused() internal view {
         require(!controller.paused(), "Paused");
     }
 
-    modifier notRecoveryPaused {
-        _notRecoveryPaused();
+    modifier notPartialPaused {
+        _notPartialPaused();
         _;
     }
 

contracts/governance/Pausable.sol

@@ -1,33 +1,35 @@
 pragma solidity ^0.6.12;
 
 contract Pausable {
-    // Two types of pausing in the protocol
-    bool internal _recoveryPaused;
+    // Partial paused paused exit and enter functions for GRT, but not internal
+    // functions, such as allocating
+    bool internal _partialPaused;
+    // Paused will pause all major protocol functions
     bool internal _paused;
 
     // Time last paused for both pauses
-    uint256 public lastPauseRecoveryTime;
+    uint256 public lastPausePartialTime;
     uint256 public lastPauseTime;
 
     // Pause guardian is a separate entity from the governor that can pause
     address public pauseGuardian;
 
-    event RecoveryPauseChanged(bool isPaused);
+    event PartialPauseChanged(bool isPaused);
     event PauseChanged(bool isPaused);
     event NewPauseGuardian(address oldPauseGuardian, address pauseGuardian);
 
     /**
-     * @notice Change the recovery paused state of the contract
+     * @notice Change the partial paused state of the contract
      */
-    function _setRecoveryPaused(bool _toPause) internal {
-        if (_toPause == _recoveryPaused) {
+    function _setPartialPaused(bool _toPause) internal {
+        if (_toPause == _partialPaused) {
             return;
         }
-        _recoveryPaused = _toPause;
-        if (_recoveryPaused) {
-            lastPauseRecoveryTime = now;
+        _partialPaused = _toPause;
+        if (_partialPaused) {
+            lastPausePartialTime = now;
         }
-        emit RecoveryPauseChanged(_recoveryPaused);
+        emit PartialPauseChanged(_partialPaused);
     }
 
     /**

contracts/staking/Staking.sol

@@ -512,7 +512,7 @@ contract Staking is StakingV1Storage, GraphUpgradeable, IStaking {
      * @param _indexer Adress of the indexer
      * @param _tokens Amount of tokens to stake
      */
-    function stakeTo(address _indexer, uint256 _tokens) public override notRecoveryPaused {
+    function stakeTo(address _indexer, uint256 _tokens) public override notPartialPaused {
         require(_tokens > 0, "Cannot stake zero tokens");
 
         // Transfer tokens to stake from caller to this contract
@@ -529,7 +529,7 @@ contract Staking is StakingV1Storage, GraphUpgradeable, IStaking {
      * @dev Unstake tokens from the indexer stake, lock them until thawing period expires.
      * @param _tokens Amount of tokens to unstake
      */
-    function unstake(uint256 _tokens) external override notRecoveryPaused {
+    function unstake(uint256 _tokens) external override notPartialPaused {
         address indexer = msg.sender;
         Stakes.Indexer storage indexerStake = stakes[indexer];
 
@@ -621,7 +621,7 @@ contract Staking is StakingV1Storage, GraphUpgradeable, IStaking {
      * @param _indexer Address of the indexer to delegate tokens to
      * @param _tokens Amount of tokens to delegate
      */
-    function delegate(address _indexer, uint256 _tokens) external override notRecoveryPaused {
+    function delegate(address _indexer, uint256 _tokens) external override notPartialPaused {
         address delegator = msg.sender;
 
         // Transfer tokens to delegate to this contract
@@ -639,7 +639,7 @@ contract Staking is StakingV1Storage, GraphUpgradeable, IStaking {
      * @param _indexer Address of the indexer where tokens had been delegated
      * @param _shares Amount of shares to return and undelegate tokens
      */
-    function undelegate(address _indexer, uint256 _shares) external override notRecoveryPaused {
+    function undelegate(address _indexer, uint256 _shares) external override notPartialPaused {
         _undelegate(msg.sender, _indexer, _shares);
     }
 

test/governance/pausing.test.ts

@@ -17,10 +17,10 @@ describe('Pausing', () => {
   let staking: Staking
   let controller: Controller
 
-  const setRecoveryPause = async (account: Account, setValue: boolean) => {
-    const tx = controller.connect(account.signer).setRecoveryPaused(setValue)
-    await expect(tx).emit(controller, 'RecoveryPauseChanged').withArgs(setValue)
-    expect(await controller.recoveryPaused()).eq(setValue)
+  const setPartialPause = async (account: Account, setValue: boolean) => {
+    const tx = controller.connect(account.signer).setPartialPaused(setValue)
+    await expect(tx).emit(controller, 'PartialPauseChanged').withArgs(setValue)
+    expect(await controller.partialPaused()).eq(setValue)
   }
   const setPause = async (account: Account, setValue: boolean) => {
     const tx = controller.connect(account.signer).setPaused(setValue)
@@ -51,29 +51,29 @@ describe('Pausing', () => {
     const tx = controller.connect(me.signer).setPauseGuardian(guardian.address)
     await expect(tx).revertedWith('Only Governor can call')
   })
-  it('should set recoveryPause and unset from governor and guardian', async function () {
-    expect(await controller.recoveryPaused()).eq(false)
+  it('should set partialPaused and unset from governor and guardian', async function () {
+    expect(await controller.partialPaused()).eq(false)
     // Governor set
-    await setRecoveryPause(governor, true)
+    await setPartialPause(governor, true)
     // Governor unset
-    await setRecoveryPause(governor, false)
+    await setPartialPause(governor, false)
 
     await controller.connect(governor.signer).setPauseGuardian(guardian.address)
     // Guardian set
-    await setRecoveryPause(guardian, true)
+    await setPartialPause(guardian, true)
     // Guardian unset
-    await setRecoveryPause(guardian, false)
+    await setPartialPause(guardian, false)
   })
-  it('should fail recovery pause if not guardian or governor', async function () {
+  it('should fail partial pause if not guardian or governor', async function () {
     const tx = controller.connect(me.signer).setPauseGuardian(guardian.address)
     await expect(tx).revertedWith('Only Governor can call')
   })
-  it('should check that a function fails when recoveryPause is set', async function () {
-    await setRecoveryPause(governor, true)
+  it('should check that a function fails when partialPause is set', async function () {
+    await setPartialPause(governor, true)
 
     const tokensToStake = toGRT('100')
     const tx = staking.connect(me.signer).stake(tokensToStake)
-    await expect(tx).revertedWith('Recovery-paused')
+    await expect(tx).revertedWith('Partial-paused')
   })
   it('should set pause and unset from governor and guardian', async function () {
     expect(await controller.paused()).eq(false)

test/lib/fixtures.ts

@@ -52,7 +52,7 @@ export class NetworkFixture {
 
     // Unpause the protocol
     await controller.connect(deployer).setPaused(false)
-    await controller.connect(deployer).setRecoveryPaused(false)
+    await controller.connect(deployer).setPartialPaused(false)
 
     return {
       controller,