feat: savings donation-attack guard + parallelizer pause refactor

contracts/interfaces/ISavings.sol

@@ -62,15 +62,19 @@ interface ISavings is IEIP3009 {
   // solhint-disable-next-line func-name-mixedcase
   function DOMAIN_SEPARATOR() external view returns (bytes32);
 
-  function estimatedAPR() external view returns (uint256 apr);
+  function estimatedAPY() external view returns (uint256 apy);
 
   function computeUpdatedAssets(uint256 totalAssets, uint256 exp) external view returns (uint256);
 
-  function togglePause() external;
+  function pause() external;
+
+  function unpause() external;
 
   function toggleTrusted(address trustedAddress) external;
 
   function setRate(uint208 newRate) external;
 
   function setMaxRate(uint256 newMaxRate) external;
+
+  function recoverSurplus(address to) external returns (uint256 surplus);
 }

contracts/interfaces/ISetters.sol

@@ -78,8 +78,13 @@ interface ISettersGovernor {
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
 interface ISettersGuardian {
-  /// @notice Changes the pause status for mint or burn transactions for `collateral`
-  function togglePause(address collateral, ActionType action) external;
+  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when
+  /// `action == Redeem`). Reverts if the action is already paused.
+  function pause(address collateral, ActionType action) external;
+
+  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when
+  /// `action == Redeem`). Reverts if the action is not paused.
+  function unpause(address collateral, ActionType action) external;
 
   /// @notice Sets the mint or burn fees for `collateral`
   function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;

contracts/parallelizer/configs/DiamondInitializer.sol

@@ -30,15 +30,15 @@ contract DiamondInitializer {
       LibSetters.setFees(collateral.token, collateral.xMintFee, collateral.yMintFee, true);
       // Burn fees
       LibSetters.setFees(collateral.token, collateral.xBurnFee, collateral.yBurnFee, false);
-      LibSetters.togglePause(collateral.token, ActionType.Mint);
-      LibSetters.togglePause(collateral.token, ActionType.Burn);
+      LibSetters.unpause(collateral.token, ActionType.Mint);
+      LibSetters.unpause(collateral.token, ActionType.Burn);
       LibSetters.setStablecoinCap(collateral.token, 100_000_000 ether);
       if (collateral.targetMax) LibOracle.updateOracle(collateral.token);
     }
 
     // setRedemptionCurveParams
     if (_redemptionSetup.xRedeemFee.length > 0) {
-      LibSetters.togglePause(address(0), ActionType.Redeem);
+      LibSetters.unpause(address(0), ActionType.Redeem);
       LibSetters.setRedemptionCurveParams(_redemptionSetup.xRedeemFee, _redemptionSetup.yRedeemFee);
     }
   }

contracts/parallelizer/configs/Test.sol

@@ -69,7 +69,7 @@ contract Test {
     yMintFee[3] = int64(uint64(BASE_12 - 1));
 
     LibSetters.setFees(eurA.collateral, xMintFee, yMintFee, true);
-    LibSetters.togglePause(eurA.collateral, ActionType.Mint);
+    LibSetters.unpause(eurA.collateral, ActionType.Mint);
 
     uint64[] memory xBurnFee = new uint64[](4);
     xBurnFee[0] = uint64(BASE_9);
@@ -85,7 +85,7 @@ contract Test {
     yBurnFee[3] = int64(uint64(MAX_BURN_FEE - 1));
 
     LibSetters.setFees(eurA.collateral, xBurnFee, yBurnFee, false);
-    LibSetters.togglePause(eurA.collateral, ActionType.Burn);
+    LibSetters.unpause(eurA.collateral, ActionType.Burn);
 
     // Setup second collateral
     LibSetters.addCollateral(eurB.collateral);
@@ -121,7 +121,7 @@ contract Test {
     yMintFee[3] = int64(uint64(BASE_12 - 1));
 
     LibSetters.setFees(eurB.collateral, xMintFee, yMintFee, true);
-    LibSetters.togglePause(eurB.collateral, ActionType.Mint);
+    LibSetters.unpause(eurB.collateral, ActionType.Mint);
 
     xBurnFee = new uint64[](4);
     xBurnFee[0] = uint64(BASE_9);
@@ -137,7 +137,7 @@ contract Test {
     yBurnFee[3] = int64(uint64(MAX_BURN_FEE - 1));
 
     LibSetters.setFees(eurB.collateral, xBurnFee, yBurnFee, false);
-    LibSetters.togglePause(eurB.collateral, ActionType.Burn);
+    LibSetters.unpause(eurB.collateral, ActionType.Burn);
 
     // Setup third collateral
     LibSetters.addCollateral(eurY.collateral);
@@ -173,7 +173,7 @@ contract Test {
     yMintFee[3] = int64(uint64(BASE_12 - 1));
 
     LibSetters.setFees(eurY.collateral, xMintFee, yMintFee, true);
-    LibSetters.togglePause(eurY.collateral, ActionType.Mint);
+    LibSetters.unpause(eurY.collateral, ActionType.Mint);
 
     xBurnFee = new uint64[](4);
     xBurnFee[0] = uint64(BASE_9);
@@ -189,14 +189,14 @@ contract Test {
     yBurnFee[3] = int64(uint64(MAX_BURN_FEE - 1));
 
     LibSetters.setFees(eurY.collateral, xBurnFee, yBurnFee, false);
-    LibSetters.togglePause(eurY.collateral, ActionType.Burn);
+    LibSetters.unpause(eurY.collateral, ActionType.Burn);
 
     // Set no hard limits on stablecoin minting per collateral
     LibSetters.setStablecoinCap(eurA.collateral, type(uint256).max);
     LibSetters.setStablecoinCap(eurB.collateral, type(uint256).max);
     LibSetters.setStablecoinCap(eurY.collateral, type(uint256).max);
 
     // Redeem
-    LibSetters.togglePause(eurA.collateral, ActionType.Redeem);
+    LibSetters.unpause(eurA.collateral, ActionType.Redeem);
   }
 }

contracts/parallelizer/facets/SettersGuardian.sol

@@ -15,8 +15,13 @@ import "../Storage.sol";
 /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGuardian.sol
 contract SettersGuardian is AccessManagedModifiers, ISettersGuardian {
   /// @inheritdoc ISettersGuardian
-  function togglePause(address collateral, ActionType pausedType) external restricted {
-    LibSetters.togglePause(collateral, pausedType);
+  function pause(address collateral, ActionType action) external restricted {
+    LibSetters.pause(collateral, action);
+  }
+
+  /// @inheritdoc ISettersGuardian
+  function unpause(address collateral, ActionType action) external restricted {
+    LibSetters.unpause(collateral, action);
   }
 
   /// @inheritdoc ISettersGuardian

contracts/parallelizer/libraries/LibSetters.sol

@@ -183,25 +183,45 @@ library LibSetters {
     ONLY GUARDIAN ACTIONS
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
-  /// @notice Internal version of `togglePause`
-  function togglePause(address collateral, ActionType action) internal {
-    uint8 isLive;
+  /// @notice Internal version of `pause` — sets the action's live flag to `0`
+  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance
+  /// call cannot pass silently
+  function pause(address collateral, ActionType action) internal {
+    _setPauseState(collateral, action, 0);
+  }
+
+  /// @notice Internal version of `unpause` — sets the action's live flag to `1`
+  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance
+  /// call cannot pass silently
+  function unpause(address collateral, ActionType action) internal {
+    _setPauseState(collateral, action, 1);
+  }
+
+  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`
+  /// to unpause. Reverts on no-op transitions.
+  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {
     if (action == ActionType.Mint || action == ActionType.Burn) {
       Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];
       if (collatInfo.decimals == 0) revert NotCollateral();
+      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;
+      if (currentIsLive == targetIsLive) {
+        if (targetIsLive == 0) revert AlreadyPaused();
+        revert NotPaused();
+      }
       if (action == ActionType.Mint) {
-        isLive = 1 - collatInfo.isMintLive;
-        collatInfo.isMintLive = isLive;
+        collatInfo.isMintLive = targetIsLive;
       } else {
-        isLive = 1 - collatInfo.isBurnLive;
-        collatInfo.isBurnLive = isLive;
+        collatInfo.isBurnLive = targetIsLive;
       }
     } else {
       ParallelizerStorage storage ts = s.transmuterStorage();
-      isLive = 1 - ts.isRedemptionLive;
-      ts.isRedemptionLive = isLive;
+      if (ts.isRedemptionLive == targetIsLive) {
+        if (targetIsLive == 0) revert AlreadyPaused();
+        revert NotPaused();
+      }
+      ts.isRedemptionLive = targetIsLive;
     }
-    emit PauseToggled(collateral, uint256(action), isLive == 0);
+    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);
   }
 
   /// @notice Internal version of `setFees`