@openzeppelin/confidential-contracts 0.2.0 → 0.3.0-rc.0

package/token/ERC7984/extensions/ERC7984Rwa.sol

@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/extensions/ERC7984Rwa.sol)
+
+pragma solidity ^0.8.27;
+
+import {FHE, externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {Multicall} from "@openzeppelin/contracts/utils/Multicall.sol";
+import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol";
+import {IERC7984} from "./../../../interfaces/IERC7984.sol";
+import {IERC7984Rwa} from "./../../../interfaces/IERC7984Rwa.sol";
+import {FHESafeMath} from "./../../../utils/FHESafeMath.sol";
+import {ERC7984} from "./../ERC7984.sol";
+import {ERC7984Freezable} from "./ERC7984Freezable.sol";
+import {ERC7984Restricted} from "./ERC7984Restricted.sol";
+
+/**
+ * @dev Extension of {ERC7984} that supports confidential Real World Assets (RWAs).
+ * This interface provides compliance checks, transfer controls and enforcement actions.
+ */
+abstract contract ERC7984Rwa is
+    IERC7984Rwa,
+    ERC7984Freezable,
+    ERC7984Restricted,
+    Pausable,
+    Multicall,
+    ERC165,
+    AccessControl
+{
+    bytes32 public constant AGENT_ROLE = keccak256("AGENT_ROLE");
+
+    /// @dev Checks if the sender is an admin.
+    modifier onlyAdmin() {
+        _checkRole(DEFAULT_ADMIN_ROLE);
+        _;
+    }
+
+    /// @dev Checks if the sender is an agent.
+    modifier onlyAgent() {
+        _checkRole(AGENT_ROLE);
+        _;
+    }
+
+    constructor(address admin) {
+        _grantRole(DEFAULT_ADMIN_ROLE, admin);
+    }
+
+    /// @inheritdoc ERC165
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(IERC165, ERC165, AccessControl) returns (bool) {
+        return
+            interfaceId == type(IERC7984Rwa).interfaceId ||
+            interfaceId == type(IERC7984).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /// @dev Returns true if has admin role, false otherwise.
+    function isAdmin(address account) public view virtual returns (bool) {
+        return hasRole(DEFAULT_ADMIN_ROLE, account);
+    }
+
+    /// @dev Returns true if agent, false otherwise.
+    function isAgent(address account) public view virtual returns (bool) {
+        return hasRole(AGENT_ROLE, account);
+    }
+
+    /// @dev Adds agent.
+    function addAgent(address account) public virtual onlyAdmin {
+        _grantRole(AGENT_ROLE, account);
+    }
+
+    /// @dev Removes agent.
+    function removeAgent(address account) public virtual onlyAdmin {
+        _revokeRole(AGENT_ROLE, account);
+    }
+
+    /// @dev Pauses contract.
+    function pause() public virtual onlyAgent {
+        _pause();
+    }
+
+    /// @dev Unpauses contract.
+    function unpause() public virtual onlyAgent {
+        _unpause();
+    }
+
+    /// @dev Blocks a user account.
+    function blockUser(address account) public virtual onlyAgent {
+        _blockUser(account);
+    }
+
+    /// @dev Unblocks a user account.
+    function unblockUser(address account) public virtual onlyAgent {
+        _allowUser(account);
+    }
+
+    /// @dev Sets confidential frozen for an account.
+    function setConfidentialFrozen(
+        address account,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) public virtual onlyAgent {
+        _setConfidentialFrozen(account, FHE.fromExternal(encryptedAmount, inputProof));
+    }
+
+    /// @dev Sets confidential frozen for an account with proof.
+    function setConfidentialFrozen(address account, euint64 encryptedAmount) public virtual onlyAgent {
+        require(
+            FHE.isAllowed(encryptedAmount, msg.sender),
+            ERC7984UnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
+        );
+        _setConfidentialFrozen(account, encryptedAmount);
+    }
+
+    /// @dev Mints confidential amount of tokens to account with proof.
+    function confidentialMint(
+        address to,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) public virtual onlyAgent returns (euint64) {
+        return _mint(to, FHE.fromExternal(encryptedAmount, inputProof));
+    }
+
+    /// @dev Mints confidential amount of tokens to account.
+    function confidentialMint(address to, euint64 encryptedAmount) public virtual onlyAgent returns (euint64) {
+        require(
+            FHE.isAllowed(encryptedAmount, msg.sender),
+            ERC7984UnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
+        );
+        return _mint(to, encryptedAmount);
+    }
+
+    /// @dev Burns confidential amount of tokens from account with proof.
+    function confidentialBurn(
+        address account,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) public virtual onlyAgent returns (euint64) {
+        return _burn(account, FHE.fromExternal(encryptedAmount, inputProof));
+    }
+
+    /// @dev Burns confidential amount of tokens from account.
+    function confidentialBurn(address account, euint64 encryptedAmount) public virtual onlyAgent returns (euint64) {
+        require(
+            FHE.isAllowed(encryptedAmount, msg.sender),
+            ERC7984UnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
+        );
+        return _burn(account, encryptedAmount);
+    }
+
+    /// @dev Forces transfer of confidential amount of tokens from account to account with proof by skipping compliance checks.
+    function forceConfidentialTransferFrom(
+        address from,
+        address to,
+        externalEuint64 encryptedAmount,
+        bytes calldata inputProof
+    ) public virtual onlyAgent returns (euint64) {
+        return _forceUpdate(from, to, FHE.fromExternal(encryptedAmount, inputProof));
+    }
+
+    /// @dev Forces transfer of confidential amount of tokens from account to account by skipping compliance checks.
+    function forceConfidentialTransferFrom(
+        address from,
+        address to,
+        euint64 encryptedAmount
+    ) public virtual onlyAgent returns (euint64 transferred) {
+        require(
+            FHE.isAllowed(encryptedAmount, msg.sender),
+            ERC7984UnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
+        );
+        return _forceUpdate(from, to, encryptedAmount);
+    }
+
+    /// @inheritdoc ERC7984Freezable
+    function confidentialAvailable(
+        address account
+    ) public virtual override(IERC7984Rwa, ERC7984Freezable) returns (euint64) {
+        return super.confidentialAvailable(account);
+    }
+
+    /// @inheritdoc ERC7984Freezable
+    function confidentialFrozen(
+        address account
+    ) public view virtual override(IERC7984Rwa, ERC7984Freezable) returns (euint64) {
+        return super.confidentialFrozen(account);
+    }
+
+    /// @inheritdoc Pausable
+    function paused() public view virtual override(IERC7984Rwa, Pausable) returns (bool) {
+        return super.paused();
+    }
+
+    /// @inheritdoc ERC7984Restricted
+    function isUserAllowed(
+        address account
+    ) public view virtual override(IERC7984Rwa, ERC7984Restricted) returns (bool) {
+        return super.isUserAllowed(account);
+    }
+
+    /// @dev Internal function which updates confidential balances while performing frozen and restriction compliance checks.
+    function _update(
+        address from,
+        address to,
+        euint64 encryptedAmount
+    ) internal virtual override(ERC7984Freezable, ERC7984Restricted) whenNotPaused returns (euint64) {
+        // frozen and restriction checks performed through inheritance
+        return super._update(from, to, encryptedAmount);
+    }
+
+    /// @dev Internal function which forces transfer of confidential amount of tokens from account to account by skipping compliance checks.
+    function _forceUpdate(address from, address to, euint64 encryptedAmount) internal virtual returns (euint64) {
+        // bypassing `from` restriction check with {_checkSenderRestriction}. Still performing `to` restriction check.
+        // bypassing paused state by directly calling `super._update`
+        return super._update(from, to, encryptedAmount);
+    }
+
+    /**
+     * @dev Bypasses the `from` restriction check when performing a {forceConfidentialTransferFrom}.
+     */
+    function _checkSenderRestriction(address account) internal view override {
+        if (_isForceTransfer()) {
+            return;
+        }
+        super._checkSenderRestriction(account);
+    }
+
+    /// @dev Private function which checks if the called function is a {forceConfidentialTransferFrom}.
+    function _isForceTransfer() private pure returns (bool) {
+        return
+            msg.sig == 0x6c9c3c85 || // bytes4(keccak256("forceConfidentialTransferFrom(address,address,bytes32)"))
+            msg.sig == 0x44fd6e40; // bytes4(keccak256("forceConfidentialTransferFrom(address,address,bytes32,bytes)"))
+    }
+}

package/token/{extensions/ConfidentialFungibleTokenVotes.sol → ERC7984/extensions/ERC7984Votes.sol}

@@ -1,27 +1,21 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (token/extensions/ConfidentialFungibleTokenVotes.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/extensions/ERC7984Votes.sol)
 pragma solidity ^0.8.27;
 
 import {euint64} from "@fhevm/solidity/lib/FHE.sol";
-import {VotesConfidential} from "./../../governance/utils/VotesConfidential.sol";
-import {ConfidentialFungibleToken} from "./../ConfidentialFungibleToken.sol";
+import {VotesConfidential} from "../../../governance/utils/VotesConfidential.sol";
+import {ERC7984} from "./../ERC7984.sol";
 
 /**
- * @dev Extension of {ConfidentialFungibleToken} supporting confidential votes tracking and delegation.
+ * @dev Extension of {ERC7984} supporting confidential votes tracking and delegation.
  *
- * The amount of confidential voting units an account has is equal to the confidential token balance of
+ * The amount of confidential voting units an account has is equal to the balance of
  * that account. Voing power is taken into account when an account delegates votes to itself or to another
  * account.
  */
-abstract contract ConfidentialFungibleTokenVotes is ConfidentialFungibleToken, VotesConfidential {
-    /// @inheritdoc ConfidentialFungibleToken
-    function confidentialTotalSupply()
-        public
-        view
-        virtual
-        override(VotesConfidential, ConfidentialFungibleToken)
-        returns (euint64)
-    {
+abstract contract ERC7984Votes is ERC7984, VotesConfidential {
+    /// @inheritdoc ERC7984
+    function confidentialTotalSupply() public view virtual override(VotesConfidential, ERC7984) returns (euint64) {
         return super.confidentialTotalSupply();
     }
 

package/token/{utils/ConfidentialFungibleTokenUtils.sol → ERC7984/utils/ERC7984Utils.sol}

@@ -1,21 +1,21 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (token/utils/ConfidentialFungibleTokenUtils.sol)
-pragma solidity ^0.8.24;
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (token/ERC7984/utils/ERC7984Utils.sol)
+pragma solidity ^0.8.27;
 
 import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
 
-import {IConfidentialFungibleTokenReceiver} from "../../interfaces/IConfidentialFungibleTokenReceiver.sol";
-import {ConfidentialFungibleToken} from "../ConfidentialFungibleToken.sol";
+import {IERC7984Receiver} from "../../../interfaces/IERC7984Receiver.sol";
+import {ERC7984} from "../ERC7984.sol";
 
-/// @dev Library that provides common {ConfidentialFungibleToken} utility functions.
-library ConfidentialFungibleTokenUtils {
+/// @dev Library that provides common {ERC7984} utility functions.
+library ERC7984Utils {
     /**
      * @dev Performs a transfer callback to the recipient of the transfer `to`. Should be invoked
-     * after all transfers "withCallback" on a {ConfidentialFungibleToken}.
+     * after all transfers "withCallback" on a {ERC7984}.
      *
      * The transfer callback is not invoked on the recipient if the recipient has no code (i.e. is an EOA). If the
      * recipient has non-zero code, it must implement
-     * {IConfidentialFungibleTokenReceiver-onConfidentialTransferReceived} and return an `ebool` indicating
+     * {IERC7984Receiver-onConfidentialTransferReceived} and return an `ebool` indicating
      * whether the transfer was accepted or not. If the `ebool` is `false`, the transfer will be reversed.
      */
     function checkOnTransferReceived(
@@ -26,13 +26,13 @@ library ConfidentialFungibleTokenUtils {
         bytes calldata data
     ) internal returns (ebool) {
         if (to.code.length > 0) {
-            try
-                IConfidentialFungibleTokenReceiver(to).onConfidentialTransferReceived(operator, from, amount, data)
-            returns (ebool retval) {
+            try IERC7984Receiver(to).onConfidentialTransferReceived(operator, from, amount, data) returns (
+                ebool retval
+            ) {
                 return retval;
             } catch (bytes memory reason) {
                 if (reason.length == 0) {
-                    revert ConfidentialFungibleToken.ConfidentialFungibleTokenInvalidReceiver(to);
+                    revert ERC7984.ERC7984InvalidReceiver(to);
                 } else {
                     assembly ("memory-safe") {
                         revert(add(32, reason), mload(reason))

package/utils/FHESafeMath.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (utils/FHESafeMath.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (utils/FHESafeMath.sol)
 pragma solidity ^0.8.24;
 
 import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
@@ -16,13 +16,11 @@ library FHESafeMath {
      */
     function tryIncrease(euint64 oldValue, euint64 delta) internal returns (ebool success, euint64 updated) {
         if (!FHE.isInitialized(oldValue)) {
-            success = FHE.asEbool(true);
-            updated = delta;
-        } else {
-            euint64 newValue = FHE.add(oldValue, delta);
-            success = FHE.ge(newValue, oldValue);
-            updated = FHE.select(success, newValue, oldValue);
+            return (FHE.asEbool(true), delta);
         }
+        euint64 newValue = FHE.add(oldValue, delta);
+        success = FHE.ge(newValue, oldValue);
+        updated = FHE.select(success, newValue, oldValue);
     }
 
     /**
@@ -31,7 +29,44 @@ library FHESafeMath {
      * and `updated` will be the original value.
      */
     function tryDecrease(euint64 oldValue, euint64 delta) internal returns (ebool success, euint64 updated) {
+        if (!FHE.isInitialized(oldValue)) {
+            if (!FHE.isInitialized(delta)) {
+                return (FHE.asEbool(true), oldValue);
+            }
+            return (FHE.eq(oldValue, delta), oldValue);
+        }
         success = FHE.ge(oldValue, delta);
         updated = FHE.select(success, FHE.sub(oldValue, delta), oldValue);
     }
+
+    /**
+     * @dev Try to add `a` and `b`. If the operation is successful, `success` will be true and `res`
+     * will be the sum of `a` and `b`. Otherwise, `success` will be false, and `res` will be 0.
+     */
+    function tryAdd(euint64 a, euint64 b) internal returns (ebool success, euint64 res) {
+        if (!FHE.isInitialized(a)) {
+            return (FHE.asEbool(true), b);
+        }
+        if (!FHE.isInitialized(b)) {
+            return (FHE.asEbool(true), a);
+        }
+
+        euint64 sum = FHE.add(a, b);
+        success = FHE.ge(sum, a);
+        res = FHE.select(success, sum, FHE.asEuint64(0));
+    }
+
+    /**
+     * @dev Try to subtract `b` from `a`. If the operation is successful, `success` will be true and `res`
+     * will be `a - b`. Otherwise, `success` will be false, and `res` will be 0.
+     */
+    function trySub(euint64 a, euint64 b) internal returns (ebool success, euint64 res) {
+        if (!FHE.isInitialized(b)) {
+            return (FHE.asEbool(true), a);
+        }
+
+        euint64 difference = FHE.sub(a, b);
+        success = FHE.le(difference, a);
+        res = FHE.select(success, difference, FHE.asEuint64(0));
+    }
 }

package/utils/structs/temporary-Checkpoints.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.2.0) (utils/structs/temporary-Checkpoints.sol)
-// OpenZeppelin Contracts (last updated v5.3.0) (utils/structs/Checkpoints.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.3.0-rc.0) (utils/structs/temporary-Checkpoints.sol)
+// OpenZeppelin Contracts (last updated v5.4.0) (utils/structs/Checkpoints.sol)
 // This file was procedurally generated from scripts/generate/templates/Checkpoints.js.
 // WARNING: This file is temporary and will be deleted once the latest version of the file is released in v5.5.0 of @openzeppelin/contracts.