Support compliance modules for confidential RWAs

.changeset/wet-results-doubt.md

@@ -0,0 +1,5 @@
+---
+'openzeppelin-confidential-contracts': minor
+---
+
+`ERC7984RwaModularCompliance`: Support compliance modules for confidential RWAs.

contracts/interfaces/IERC7984Rwa.sol

@@ -1,14 +1,20 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
-import {externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ebool, externalEuint64, euint64} from "@fhevm/solidity/lib/FHE.sol";
 import {IERC165} from "@openzeppelin/contracts/interfaces/IERC165.sol";
 import {IERC7984} from "./IERC7984.sol";
 
 /// @dev Interface for confidential RWA contracts.
 interface IERC7984Rwa is IERC7984, IERC165 {
     /// @dev Returns true if the contract is paused, false otherwise.
     function paused() external view returns (bool);
+    /// @dev Returns true if has admin role, false otherwise.
+    function isAdmin(address account) external view returns (bool);
+    /// @dev Returns true if agent, false otherwise.
+    function isAgent(address account) external view returns (bool);
+    /// @dev Returns true if admin or agent, false otherwise.
+    function isAdminOrAgent(address account) external view returns (bool);
     /// @dev Returns whether an account is allowed to interact with the token.
     function isUserAllowed(address account) external view returns (bool);
     /// @dev Returns the confidential frozen balance of an account.
@@ -61,3 +67,28 @@ interface IERC7984Rwa is IERC7984, IERC165 {
         euint64 encryptedAmount
     ) external returns (euint64);
 }
+
+/// @dev Interface for confidential RWA with modular compliance.
+interface IERC7984RwaModularCompliance {
+    enum ComplianceModuleType {
+        AlwaysOn,
+        TransferOnly
+    }
+
+    /// @dev Checks if a compliance module is installed.
+    function isModuleInstalled(ComplianceModuleType moduleType, address module) external view returns (bool);
+    /// @dev Installs a transfer compliance module.
+    function installModule(ComplianceModuleType moduleType, address module) external;
+    /// @dev Uninstalls a transfer compliance module.
+    function uninstallModule(ComplianceModuleType moduleType, address module) external;
+}
+
+/// @dev Interface for confidential RWA transfer compliance module.
+interface IERC7984RwaComplianceModule {
+    /// @dev Returns magic number if it is a module.
+    function isModule() external returns (bytes4);
+    /// @dev Checks if a transfer is compliant. Should be non-mutating.
+    function isCompliantTransfer(address from, address to, euint64 encryptedAmount) external returns (ebool);
+    /// @dev Performs operation after transfer.
+    function postTransfer(address from, address to, euint64 encryptedAmount) external;
+}

contracts/mocks/token/ERC7984RwaBalanceCapModuleMock.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {SepoliaConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {FHE, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ERC7984RwaBalanceCapModule} from "../../token/ERC7984/extensions/rwa/ERC7984RwaBalanceCapModule.sol";
+
+contract ERC7984RwaBalanceCapModuleMock is ERC7984RwaBalanceCapModule, SepoliaConfig {
+    event AmountEncrypted(euint64 amount);
+
+    constructor(address compliance) ERC7984RwaBalanceCapModule(compliance) {}
+
+    function createEncryptedAmount(uint64 amount) public returns (euint64 encryptedAmount) {
+        FHE.allowThis(encryptedAmount = FHE.asEuint64(amount));
+        FHE.allow(encryptedAmount, msg.sender);
+        emit AmountEncrypted(encryptedAmount);
+    }
+}

contracts/mocks/token/ERC7984RwaComplianceModuleMock.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {SepoliaConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ERC7984RwaComplianceModule} from "../../token/ERC7984/extensions/rwa/ERC7984RwaComplianceModule.sol";
+
+// solhint-disable func-name-mixedcase
+contract ERC7984RwaModularComplianceModuleMock is ERC7984RwaComplianceModule, SepoliaConfig {
+    bool private _compliant = false;
+
+    event PostTransfer();
+    event PreTransfer();
+
+    constructor(address compliance) ERC7984RwaComplianceModule(compliance) {}
+
+    function $_setCompliant() public {
+        _compliant = true;
+    }
+
+    function $_unsetCompliant() public {
+        _compliant = false;
+    }
+
+    function _isCompliantTransfer(
+        address /*from*/,
+        address /*to*/,
+        euint64 /*encryptedAmount*/
+    ) internal override returns (ebool) {
+        emit PreTransfer();
+        return FHE.asEbool(_compliant);
+    }
+
+    function _postTransfer(address /*from*/, address /*to*/, euint64 /*encryptedAmount*/) internal override {
+        emit PostTransfer();
+    }
+}

contracts/mocks/token/ERC7984RwaInvestorCapModuleMock.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {SepoliaConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {ERC7984RwaInvestorCapModule} from "../../token/ERC7984/extensions/rwa/ERC7984RwaInvestorCapModule.sol";
+
+contract ERC7984RwaInvestorCapModuleMock is ERC7984RwaInvestorCapModule, SepoliaConfig {
+    constructor(address token, uint64 maxInvestor) ERC7984RwaInvestorCapModule(token, maxInvestor) {}
+}

contracts/mocks/token/ERC7984RwaModularComplianceMock.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {SepoliaConfig} from "@fhevm/solidity/config/ZamaConfig.sol";
+import {ERC7984} from "../../token/ERC7984/ERC7984.sol";
+import {ERC7984Rwa} from "../../token/ERC7984/extensions/ERC7984Rwa.sol";
+import {ERC7984RwaModularCompliance} from "../../token/ERC7984/extensions/rwa/ERC7984RwaModularCompliance.sol";
+
+contract ERC7984RwaModularComplianceMock is ERC7984RwaModularCompliance, SepoliaConfig {
+    constructor(
+        string memory name,
+        string memory symbol,
+        string memory tokenUri,
+        address admin
+    ) ERC7984Rwa(admin) ERC7984(name, symbol, tokenUri) {}
+}

contracts/token/ERC7984/extensions/ERC7984Rwa.sol

@@ -66,6 +66,11 @@ abstract contract ERC7984Rwa is
         return hasRole(AGENT_ROLE, account);
     }
 
+    /// @dev Returns true if admin or agent, false otherwise.
+    function isAdminOrAgent(address account) public view virtual returns (bool) {
+        return isAdmin(account) || isAgent(account);
+    }
+
     /// @dev Adds agent.
     function addAgent(address account) public virtual onlyAdmin {
         _grantRole(AGENT_ROLE, account);

contracts/token/ERC7984/extensions/rwa/ERC7984RwaBalanceCapModule.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {FHE, ebool, euint64, externalEuint64} from "@fhevm/solidity/lib/FHE.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {IERC7984} from "../../../../interfaces/IERC7984.sol";
+import {FHESafeMath} from "../../../../utils/FHESafeMath.sol";
+import {ERC7984RwaComplianceModule} from "./ERC7984RwaComplianceModule.sol";
+
+/**
+ * @dev A transfer compliance module for confidential Real World Assets (RWAs) which limits the balance of an investor.
+ */
+abstract contract ERC7984RwaBalanceCapModule is ERC7984RwaComplianceModule {
+    using EnumerableSet for *;
+
+    euint64 private _maxBalance;
+
+    event MaxBalanceSet(euint64 newMaxBalance);
+
+    constructor(address token) ERC7984RwaComplianceModule(token) {
+        _token = token;
+    }
+
+    /// @dev Sets max balance of an investor with proof.
+    function setMaxBalance(externalEuint64 maxBalance, bytes calldata inputProof) public virtual onlyTokenAdmin {
+        euint64 maxBalance_ = FHE.fromExternal(maxBalance, inputProof);
+        FHE.allowThis(_maxBalance = maxBalance_);
+        emit MaxBalanceSet(maxBalance_);
+    }
+
+    /// @dev Sets max balance of an investor.
+    function setMaxBalance(euint64 maxBalance) public virtual onlyTokenAdmin {
+        FHE.allowThis(_maxBalance = maxBalance);
+        emit MaxBalanceSet(maxBalance);
+    }
+
+    /// @dev Gets max balance of an investor.
+    function getMaxBalance() public view virtual returns (euint64) {
+        return _maxBalance;
+    }
+
+    /// @dev Internal function which checks if a transfer is compliant.
+    function _isCompliantTransfer(
+        address /*from*/,
+        address to,
+        euint64 encryptedAmount
+    ) internal override returns (ebool compliant) {
+        if (to == address(0)) {
+            return FHE.asEbool(true); // if burning
+        }
+        euint64 balance = IERC7984(_token).confidentialBalanceOf(to);
+        _getTokenHandleAllowance(balance);
+        _getTokenHandleAllowance(encryptedAmount);
+        (ebool increased, euint64 futureBalance) = FHESafeMath.tryIncrease(balance, encryptedAmount);
+        compliant = FHE.and(increased, FHE.le(futureBalance, _maxBalance));
+    }
+}

contracts/token/ERC7984/extensions/rwa/ERC7984RwaComplianceModule.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {IERC7984Rwa, IERC7984RwaComplianceModule} from "../../../../interfaces/IERC7984Rwa.sol";
+import {HandleAccessManager} from "../../../../utils/HandleAccessManager.sol";
+
+/**
+ * @dev A contract which allows to build a transfer compliance module for confidential Real World Assets (RWAs).
+ */
+abstract contract ERC7984RwaComplianceModule is IERC7984RwaComplianceModule, HandleAccessManager {
+    address internal immutable _token;
+
+    /// @dev The sender is not the token.
+    error SenderNotToken(address account);
+    /// @dev The sender is not the token admin.
+    error SenderNotTokenAdmin(address account);
+    /// @dev The sender is not a token agent.
+    error SenderNotTokenAgent(address account);
+    /// @dev The sender is not the token admin or a token agent.
+    error SenderNotTokenAdminOrTokenAgent(address account);
+
+    /// @dev Throws if called by any account other than the token.
+    modifier onlyToken() {
+        require(msg.sender == _token, SenderNotToken(msg.sender));
+        _;
+    }
+
+    /// @dev Throws if called by any account other than the token admin.
+    modifier onlyTokenAdmin() {
+        require(IERC7984Rwa(_token).isAdmin(msg.sender), SenderNotTokenAdmin(msg.sender));
+        _;
+    }
+
+    /// @dev Throws if called by any account other than a token agent.
+    modifier onlyTokenAgent() {
+        require(IERC7984Rwa(_token).isAgent(msg.sender), SenderNotTokenAgent(msg.sender));
+        _;
+    }
+
+    /// @dev Throws if called by any account other than the token admin or a token agent.
+    modifier onlyTokenAdminOrTokenAgent() {
+        require(IERC7984Rwa(_token).isAdminOrAgent(msg.sender), SenderNotTokenAdminOrTokenAgent(msg.sender));
+        _;
+    }
+
+    constructor(address token) {
+        _token = token;
+    }
+
+    /// @inheritdoc IERC7984RwaComplianceModule
+    function isModule() public pure override returns (bytes4) {
+        return this.isModule.selector;
+    }
+
+    /// @inheritdoc IERC7984RwaComplianceModule
+    function isCompliantTransfer(
+        address from,
+        address to,
+        euint64 encryptedAmount
+    ) public virtual onlyToken returns (ebool compliant) {
+        FHE.allow(compliant = _isCompliantTransfer(from, to, encryptedAmount), msg.sender);
+    }
+
+    /// @inheritdoc IERC7984RwaComplianceModule
+    function postTransfer(address from, address to, euint64 encryptedAmount) public virtual onlyToken {
+        _postTransfer(from, to, encryptedAmount);
+    }
+
+    /// @dev Internal function which checks if a transfer is compliant.
+    function _isCompliantTransfer(
+        address /*from*/,
+        address /*to*/,
+        euint64 /*encryptedAmount*/
+    ) internal virtual returns (ebool);
+
+    /// @dev Internal function which performs operation after transfer.
+    function _postTransfer(address /*from*/, address /*to*/, euint64 /*encryptedAmount*/) internal virtual {
+        // default to no-op
+    }
+
+    /// @dev Allow modules to get access to token handles during transaction.
+    function _getTokenHandleAllowance(euint64 handle) internal virtual {
+        _getTokenHandleAllowance(handle, false);
+    }
+
+    /// @dev Allow modules to get access to token handles.
+    function _getTokenHandleAllowance(euint64 handle, bool persistent) internal virtual {
+        if (FHE.isInitialized(handle)) {
+            HandleAccessManager(_token).getHandleAllowance(euint64.unwrap(handle), address(this), persistent);
+        }
+    }
+
+    function _validateHandleAllowance(bytes32 handle) internal view override onlyTokenAdminOrTokenAgent {}
+}

contracts/token/ERC7984/extensions/rwa/ERC7984RwaInvestorCapModule.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.27;
+
+import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {IERC7984} from "../../../../interfaces/IERC7984.sol";
+import {ERC7984RwaComplianceModule} from "./ERC7984RwaComplianceModule.sol";
+
+/**
+ * @dev A transfer compliance module for confidential Real World Assets (RWAs) which limits the number of investors.
+ */
+abstract contract ERC7984RwaInvestorCapModule is ERC7984RwaComplianceModule {
+    uint64 private _maxInvestor;
+    euint64 private _investors;
+
+    event MaxInvestorSet(uint64 maxInvestor);
+
+    constructor(address token, uint64 maxInvestor) ERC7984RwaComplianceModule(token) {
+        _maxInvestor = maxInvestor;
+    }
+
+    /// @dev Sets max number of investors.
+    function setMaxInvestor(uint64 maxInvestor) public virtual onlyTokenAdmin {
+        _maxInvestor = maxInvestor;
+        emit MaxInvestorSet(maxInvestor);
+    }
+
+    /// @dev Gets max number of investors.
+    function getMaxInvestor() public view virtual returns (uint64) {
+        return _maxInvestor;
+    }
+
+    /// @dev Gets current number of investors.
+    function getCurrentInvestor() public view virtual returns (euint64) {
+        return _investors;
+    }
+
+    /// @dev Internal function which checks if a transfer is compliant.
+    function _isCompliantTransfer(
+        address /*from*/,
+        address to,
+        euint64 encryptedAmount
+    ) internal override returns (ebool compliant) {
+        euint64 balance = IERC7984(_token).confidentialBalanceOf(to);
+        _getTokenHandleAllowance(balance);
+        _getTokenHandleAllowance(encryptedAmount);
+        compliant = FHE.or(
+            FHE.or(
+                FHE.asEbool(to == address(0)), // return true if burning
+                FHE.eq(encryptedAmount, FHE.asEuint64(0)) // or zero amount
+            ),
+            FHE.or(
+                FHE.gt(balance, FHE.asEuint64(0)), // or already investor
+                FHE.lt(_investors, FHE.asEuint64(_maxInvestor)) // or not reached max investors limit
+            )
+        );
+    }
+
+    /// @dev Internal function which performs operation after transfer.
+    function _postTransfer(address /*from*/, address to, euint64 encryptedAmount) internal override {
+        euint64 balance = IERC7984(_token).confidentialBalanceOf(to);
+        _getTokenHandleAllowance(balance);
+        _getTokenHandleAllowance(encryptedAmount);
+        if (!FHE.isInitialized(_investors)) {
+            _investors = FHE.asEuint64(0);
+        }
+        _investors = FHE.select(FHE.eq(balance, encryptedAmount), FHE.add(_investors, FHE.asEuint64(1)), _investors);
+        _investors = FHE.select(FHE.eq(balance, FHE.asEuint64(0)), FHE.sub(_investors, FHE.asEuint64(1)), _investors);
+        FHE.allowThis(_investors);
+    }
+}