refactor: added pause protocol

Author: geolffreym

contracts/assets/AssetOwnership.sol

@@ -125,6 +125,7 @@ contract AssetOwnership is
     /// @dev Requires approval before an asset can be registered.
     /// @param to The address that will own the minted NFT.
     /// @param assetId The unique identifier for the asset, serving as the NFT ID.
+    // TODO pause
     function register(address to, uint256 assetId) external onlyApprovedAsset(to, assetId) {
         _mint(to, assetId);
         _enableAsset(assetId);

contracts/core/interfaces/economics/ITreasury.sol

@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: BUSL-1.1
 // NatSpec format convention - https://docs.soliditylang.org/en/v0.5.10/natspec-format.html
 pragma solidity 0.8.26;
+import { IBalanceOperator } from "@synaps3/core/interfaces/base/IBalanceOperator.sol";
 
 /// @title ITreasury Interface
 /// @notice Defines the standard functions for a Treasury contract.
-interface ITreasury {
+interface ITreasury is IBalanceOperator {
     /// @notice Collects accrued fees for a specified currency from an authorized fee collector.
     /// @param collector The address of an authorized fee collector.
     /// @param currency The address of the currency for which fees are being collected.

contracts/core/interfaces/financial/ILedgerVault.sol

@@ -4,28 +4,11 @@ pragma solidity 0.8.26;
 
 import { IBalanceOperator } from "@synaps3/core/interfaces/base/IBalanceOperator.sol";
 import { IAllowanceOperator } from "@synaps3/core/interfaces/base/IAllowanceOperator.sol";
+import { ILockOperator } from "@synaps3/core/interfaces/base/ILockOperator.sol";
 
 /// @title ILedgerVault
 /// @notice Interface for managing locked funds and their operations.
 /// @dev Extends IBalanceOperator for managing user balances in a vault-like system.
-interface ILedgerVault is IBalanceOperator, IAllowanceOperator {
-    /// @notice Locks a specific amount of funds for a given account.
-    /// @dev The funds are immobilized and cannot be withdrawn or transferred until released or claimed.
-    /// @param account The address of the account for which the funds will be locked.
-    /// @param amount The amount of funds to lock.
-    /// @param currency The currency to associate fees with. Use address(0) for the native coin.
-    function lock(address account, uint256 amount, address currency) external returns (uint256);
+interface ILedgerVault is IBalanceOperator, IAllowanceOperator, ILockOperator {
 
-    /// @notice Claims a specific amount of locked funds on behalf of a claimer.
-    /// @dev The claimer is authorized to withdraw or process the funds from the account.
-    /// @param account The address of the account whose funds are being claimed.
-    /// @param amount The amount of funds to claim.
-    /// @param currency The currency to associate fees with. Use address(0) for the native coin.
-    function claim(address account, uint256 amount, address currency) external returns (uint256);
-
-    /// @notice Release a specific amount of funds from locked pool.
-    /// @param account The address of the account for which the funds will be released.
-    /// @param amount The amount of funds to release.
-    /// @param currency The currency to associate release with. Use address(0) for the native coin.
-    function release(address account, uint256 amount, address currency) external returns (uint256);
 }

contracts/core/primitives/upgradeable/AccessControlledUpgradeable.sol

@@ -3,6 +3,7 @@
 pragma solidity 0.8.26;
 
 import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
 // solhint-disable-next-line max-line-length
 import { AccessManagedUpgradeable } from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import { IAccessManager } from "@synaps3/core/interfaces/access/IAccessManager.sol";
@@ -11,7 +12,7 @@ import { C } from "@synaps3/core/primitives/Constants.sol";
 /// @title AccessControlledUpgradeable
 /// @dev Abstract contract that provides role-based access control functionality to upgradeable contracts.
 /// This contract requires an AccessManager to manage roles.
-abstract contract AccessControlledUpgradeable is Initializable, AccessManagedUpgradeable {
+abstract contract AccessControlledUpgradeable is Initializable, AccessManagedUpgradeable, PausableUpgradeable {
     /// @custom:storage-location erc7201:accesscontrolledupgradeable
     struct AccessControlStorage {
         address _accessManager;
@@ -36,7 +37,21 @@ abstract contract AccessControlledUpgradeable is Initializable, AccessManagedUpg
         _;
     }
 
-    // @dev Initializes the contract and ensures it is upgradeable.
+    /// @notice Pauses the contract, disabling state-changing operations.
+    /// @dev Can only be called by an account with the operator/admin role (`restricted`).
+    ///      Once paused, functions guarded by `whenNotPaused` will revert until `unpause` is called.
+    function pause() external restricted {
+        _pause();
+    }
+
+    /// @notice Unpauses the contract, re-enabling state-changing operations.
+    /// @dev Can only be called by an account with the operator/admin role (`restricted`).
+    ///      Once unpaused, functions guarded by `whenNotPaused` will operate normally again.
+    function unpause() external restricted {
+        _unpause();
+    }
+
+    /// @dev Initializes the contract and ensures it is upgradeable.
     /// Even if the initialization is harmless, this ensures the contract follows upgradeable contract patterns.
     /// This is the method to initialize this contract and any other extended contracts.
     /// @param accessManager The address of the AccessManager contract.

contracts/core/primitives/upgradeable/AllowanceOperatorUpgradeable.sol

@@ -23,7 +23,7 @@ abstract contract AllowanceOperatorUpgradeable is Initializable, LedgerUpgradeab
     /// @dev Storage slot for AllowanceOperatorUpgradeable, calculated using a unique namespace to avoid conflicts.
     /// The `ALLOWANCE_OPERATOR_SLOT` constant is used to point to the location of the storage.
     bytes32 private constant ALLOWANCE_OPERATOR_SLOT =
-        0xa8707513830ffbd3c47e0c83d1f5f0270db240ae37bb1f9a13f077f85b949c00;
+        0x60503404921b66adfd164bd2cecacde1d9102b9421dba47f75ca95001753aa00;
 
     /// @dev Initializes the contract and ensures it is upgradeable.
     /// Even if the initialization is harmless, this ensures the contract follows upgradeable contract patterns.
@@ -53,11 +53,11 @@ abstract contract AllowanceOperatorUpgradeable is Initializable, LedgerUpgradeab
     /// @param to The address of the recipient for whom the funds are being approved.
     /// @param amount The amount of funds to approve.
     /// @param currency The address of the ERC20 token to approve. Use `address(0)` for native tokens.
-    function approve(
+    function _approve(
         address to,
         uint256 amount,
         address currency
-    ) public virtual onlyValidOperation(to, amount) returns (uint256) {
+    ) internal onlyValidOperation(to, amount) returns (uint256) {
         if (msg.sender == to) revert InvalidOperationParameters();
         _sumApprovedAmount(msg.sender, to, amount, currency);
         emit FundsApproved(msg.sender, to, amount, currency);
@@ -68,11 +68,11 @@ abstract contract AllowanceOperatorUpgradeable is Initializable, LedgerUpgradeab
     /// @param to The address of the recipient whose approval is being revoked.
     /// @param currency The address of the ERC20 token associated with the approval. Use `address(0)` for native tokens.
     /// @return The amount of funds that were revoked from the approval.
-    function revoke(
+    function _revoke(
         address to,
         uint256 amount,
         address currency
-    ) public virtual onlyValidOperation(to, amount) returns (uint256) {
+    ) internal onlyValidOperation(to, amount) returns (uint256) {
         if (getApprovedAmount(msg.sender, to, currency) < amount) revert NoFundsToRevoke();
         _subApprovedAmount(msg.sender, to, amount, currency);
         emit FundsRevoked(msg.sender, to, amount, currency);
@@ -83,11 +83,11 @@ abstract contract AllowanceOperatorUpgradeable is Initializable, LedgerUpgradeab
     /// @param from The address of the account from which the approved funds are being collected.
     /// @param amount The amount of funds to collect.
     /// @param currency The address of the ERC20 token to collect. Use `address(0)` for native tokens.
-    function collect(
+    function _collect(
         address from,
         uint256 amount,
         address currency
-    ) public virtual onlyValidOperation(from, amount) returns (uint256) {
+    ) internal onlyValidOperation(from, amount) returns (uint256) {
         if (getApprovedAmount(from, msg.sender, currency) < amount) revert NoFundsToCollect(); //
         if (getLedgerBalance(from, currency) < amount) revert NoFundsToCollect(); // no balance
 

contracts/core/primitives/upgradeable/BalanceOperatorUpgradeable.sol

@@ -4,7 +4,6 @@ pragma solidity 0.8.26;
 
 import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 // solhint-disable-next-line max-line-length
-import { ReentrancyGuardTransientUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardTransientUpgradeable.sol";
 import { LedgerUpgradeable } from "@synaps3/core/primitives/upgradeable/LedgerUpgradeable.sol";
 import { IBalanceOperator } from "@synaps3/core/interfaces/base/IBalanceOperator.sol";
 import { FinancialOps } from "@synaps3/core/libraries/FinancialOps.sol";
@@ -13,12 +12,7 @@ import { FinancialOps } from "@synaps3/core/libraries/FinancialOps.sol";
 /// @dev Abstract contract for managing deposits and withdrawals with ledger tracking capabilities.
 ///      Provides core functionalities to handle funds in an upgradeable system.
 ///      This contract integrates with the ledger system to record balances and transactions.
-abstract contract BalanceOperatorUpgradeable is
-    Initializable,
-    LedgerUpgradeable,
-    ReentrancyGuardTransientUpgradeable,
-    IBalanceOperator
-{
+abstract contract BalanceOperatorUpgradeable is Initializable, LedgerUpgradeable, IBalanceOperator {
     using FinancialOps for address;
 
     /// @custom:storage-location erc7201:balanceoperatorupgradeable
@@ -36,7 +30,6 @@ abstract contract BalanceOperatorUpgradeable is
     /// This is the method to initialize this contract and any other extended contracts.
     function __BalanceOperator_init() internal onlyInitializing {
         __Ledger_init();
-        __ReentrancyGuardTransient_init();
     }
 
     /// @dev Function to initialize the contract without chaining, typically used in child contracts.
@@ -54,11 +47,11 @@ abstract contract BalanceOperatorUpgradeable is
     /// @param recipient The address of the account to credit with the deposit.
     /// @param amount The amount of currency to deposit.
     /// @param currency The address of the ERC20 token to deposit.
-    function deposit(
+    function _deposit(
         address recipient,
         uint256 amount,
         address currency
-    ) public virtual onlyValidOperation(recipient, amount) returns (uint256) {
+    ) internal onlyValidOperation(recipient, amount) returns (uint256) {
         uint256 confirmed = msg.sender.safeDeposit(amount, currency);
         _sumLedgerEntry(recipient, confirmed, currency);
         emit FundsDeposited(recipient, msg.sender, confirmed, currency);
@@ -69,11 +62,11 @@ abstract contract BalanceOperatorUpgradeable is
     /// @param recipient The address that will receive the withdrawn tokens.
     /// @param amount The amount of tokens to withdraw.
     /// @param currency The currency to associate fees with. Use address(0) for the native coin.
-    function withdraw(
+    function _withdraw(
         address recipient,
         uint256 amount,
         address currency
-    ) public virtual onlyValidOperation(recipient, amount) nonReentrant returns (uint256) {
+    ) internal onlyValidOperation(recipient, amount) returns (uint256) {
         if (getLedgerBalance(msg.sender, currency) < amount) revert NoFundsToWithdraw();
         _subLedgerEntry(msg.sender, amount, currency);
         recipient.transfer(amount, currency); // transfer fund to recipient
@@ -85,11 +78,11 @@ abstract contract BalanceOperatorUpgradeable is
     /// @param recipient The address of the account to credit with the transfer.
     /// @param amount The amount of tokens to transfer.
     /// @param currency The address of the currency to transfer. Use `address(0)` for the native coin.
-    function transfer(
+    function _transfer(
         address recipient,
         uint256 amount,
         address currency
-    ) public virtual onlyValidOperation(recipient, amount) returns (uint256) {
+    ) internal onlyValidOperation(recipient, amount) returns (uint256) {
         if (msg.sender == recipient) revert InvalidOperationParameters();
         if (getLedgerBalance(msg.sender, currency) < amount) revert NoFundsToTransfer();
 

contracts/custody/CustodianReferendum.sol

@@ -79,7 +79,6 @@ contract CustodianReferendum is
         // in that way the custodian is omitted during load balancing.
         // in this line we can check if the custodian contract is active custodian.isActive()
         // this is important feature if the custodians want to avoid harm reputation
-
         return _status(uint160(custodian)) == T.Status.Active;
     }
 
@@ -99,7 +98,7 @@ contract CustodianReferendum is
 
     /// @notice Registers a custodian to be approved by council.
     /// @param custodian The address of the custodian to register.
-    function register(address custodian) external onlyValidCustodian(custodian) {
+    function register(address custodian) external whenNotPaused onlyValidCustodian(custodian) {
         // register custodian as pending approval
         _register(uint160(custodian));
         // set the custodian active enrollment period..

contracts/economics/Treasury.sol

@@ -5,6 +5,7 @@ pragma solidity 0.8.26;
 import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import { AccessControlledUpgradeable } from "@synaps3/core/primitives/upgradeable/AccessControlledUpgradeable.sol";
+import { ReentrancyGuardTransientUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardTransientUpgradeable.sol";
 import { BalanceOperatorUpgradeable } from "@synaps3/core/primitives/upgradeable/BalanceOperatorUpgradeable.sol";
 
 import { ITreasury } from "@synaps3/core/interfaces/economics/ITreasury.sol";
@@ -19,6 +20,7 @@ contract Treasury is
     Initializable,
     UUPSUpgradeable,
     AccessControlledUpgradeable,
+    ReentrancyGuardTransientUpgradeable,
     BalanceOperatorUpgradeable,
     ITreasury
 {
@@ -41,6 +43,7 @@ contract Treasury is
     function initialize(address accessManager) public initializer {
         __UUPSUpgradeable_init();
         __BalanceOperator_init();
+        __ReentrancyGuardTransient_init();
         __AccessControlled_init(accessManager);
     }
 
@@ -52,18 +55,49 @@ contract Treasury is
     // function allocate(address pool, uint256 amount) restricted;
     // eg: proposal: deposit N fees to staking pool, deposit N fees to development pool, rewards, etc
 
-    /// @notice Deposits a specified amount of currency into the treasury for a given recipient.
-    /// @param pool The address of the pool to credit with the deposit.
+    /// @notice Deposits a specified amount of currency into the treasury for a given recipient (pool).
+    /// @dev Only whitelisted accounts (via `restricted`) can interact with this method.
+    ///      This prevents arbitrary accounts from injecting funds into the treasury.
+    /// @param pool The address of the pool credited with the deposit.
     /// @param amount The amount of currency to deposit.
-    /// @param currency The address of the ERC20 token to deposit.
+    /// @param currency The address of the ERC20 token to deposit (use `address(0)` for native).
+    /// @return The confirmed deposited amount.
     function deposit(
         address pool,
         uint256 amount,
         address currency
-    ) public override(BalanceOperatorUpgradeable) restricted returns (uint256) {
-        // restricted deposit to avoid invalid operations
-        // only allowed accounts can interact with this method
-        return super.deposit(pool, amount, currency);
+    ) external whenNotPaused restricted returns (uint256) {
+        return _deposit(pool, amount, currency);
+    }
+
+    /// @notice Withdraws tokens from the treasury to a specified recipient.
+    /// @dev Restricted to authorized accounts (via `restricted`).
+    ///      Ensures treasury funds are only withdrawn under governance-approved flows.
+    /// @param recipient The address receiving the withdrawn tokens.
+    /// @param amount The amount of tokens to withdraw.
+    /// @param currency The token address for the withdrawal (use `address(0)` for native).
+    /// @return The confirmed withdrawn amount.
+    function withdraw(
+        address recipient,
+        uint256 amount,
+        address currency
+    ) external whenNotPaused restricted returns (uint256) {
+        return _withdraw(recipient, amount, currency);
+    }
+
+    /// @notice Transfers tokens internally in the treasury ledger from the caller to a recipient.
+    /// @dev Restricted to authorized accounts (via `restricted`).
+    ///      Unlike `withdraw`, this does not move funds externally but shifts balances inside the ledger.
+    /// @param recipient The address credited with the transfer.
+    /// @param amount The amount to transfer.
+    /// @param currency The token being transferred (use `address(0)` for native).
+    /// @return The confirmed transferred amount.
+    function transfer(
+        address recipient,
+        uint256 amount,
+        address currency
+    ) external whenNotPaused restricted returns (uint256) {
+        return _transfer(recipient, amount, currency);
     }
 
     /// @notice Collects accrued fees for a specified currency from an authorized fee collector. (visitable)
@@ -72,7 +106,7 @@ contract Treasury is
     ///      Only the governor can execute this function, ensuring controlled fee collection.
     /// @param collector The address of an authorized fee collector.
     /// @param currency The address of the ERC20 token for which fees are being collected.
-    function collectFees(address collector, address currency) external restricted nonReentrant {
+    function collectFees(address collector, address currency) external restricted whenNotPaused nonReentrant {
         // TODO update adding amount param on disburse call
         // IFeesCollector feesCollector = IFeesCollector(collector);
         // uint256 collected = feesCollector.disburse(currency);