@openzeppelin/confidential-contracts 0.4.0 → 0.5.0-rc.0

package/token/ERC7984/utils/ERC7984HookModule.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Confidential Contracts (last updated v0.5.0-rc.0) (token/ERC7984/utils/ERC7984HookModule.sol)
+
+pragma solidity ^0.8.27;
+
+import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
+import {ERC165, IERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC7984HookModule} from "./../../../interfaces/IERC7984HookModule.sol";
+import {HandleAccessManager} from "./../../../utils/HandleAccessManager.sol";
+
+/**
+ * @dev An abstract base contract for building ERC-7984 hook modules. Compatible with {ERC7984Hooked}.
+ */
+abstract contract ERC7984HookModule is IERC7984HookModule, ERC165 {
+    /// @dev The caller `account` is not authorized to perform the operation.
+    error ERC7984HookModuleUnauthorizedAccount(address account);
+
+    /// @dev The caller `user` does not have access to the encrypted amount `amount`.
+    error ERC7984HookModuleUnauthorizedUseOfEncryptedAmount(euint64 amount, address user);
+
+    /// @dev The module is already installed for the given token.
+    error ERC7984HookModuleAlreadyInstalled(address token);
+
+    /// @dev The module is not installed for the given token.
+    error ERC7984HookModuleNotInstalled(address token);
+
+    mapping(address token => bool) private _installed;
+
+    /// @inheritdoc IERC7984HookModule
+    function preTransfer(address from, address to, euint64 encryptedAmount) public virtual returns (ebool) {
+        require(
+            FHE.isAllowed(encryptedAmount, msg.sender),
+            ERC7984HookModuleUnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
+        );
+        ebool compliant = _preTransfer(msg.sender, from, to, encryptedAmount);
+        FHE.allowTransient(compliant, msg.sender);
+        return compliant;
+    }
+
+    /// @inheritdoc IERC7984HookModule
+    function postTransfer(address from, address to, euint64 encryptedAmount) public virtual {
+        require(
+            FHE.isAllowed(encryptedAmount, msg.sender),
+            ERC7984HookModuleUnauthorizedUseOfEncryptedAmount(encryptedAmount, msg.sender)
+        );
+        _postTransfer(msg.sender, from, to, encryptedAmount);
+    }
+
+    /// @inheritdoc IERC7984HookModule
+    function onInstall(bytes calldata initData) public virtual {
+        require(!_isModuleInstalled(msg.sender), ERC7984HookModuleAlreadyInstalled(msg.sender));
+
+        _onInstall(msg.sender, initData);
+    }
+
+    /// @inheritdoc IERC7984HookModule
+    function onUninstall(bytes calldata deinitData) public virtual {
+        require(_isModuleInstalled(msg.sender), ERC7984HookModuleNotInstalled(msg.sender));
+
+        _onUninstall(msg.sender, deinitData);
+    }
+
+    /// @inheritdoc ERC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
+        return interfaceId == type(IERC7984HookModule).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    /**
+     * @dev Internal function which may be overridden by the derived contract to perform actions
+     * when the module is installed.
+     */
+    function _onInstall(address token, bytes calldata /* initData */) internal virtual {
+        _installed[token] = true;
+    }
+
+    /**
+     * @dev Internal function which may be overridden by the derived contract to perform actions
+     * when the module is uninstalled.
+     */
+    function _onUninstall(address token, bytes calldata /* deinitData */) internal virtual {
+        delete _installed[token];
+    }
+
+    /**
+     * @dev Internal function which runs before a transfer. Transient access is already granted to the module
+     * for `encryptedAmount`. If additional handle access is needed from the token, call {_getTokenHandleAllowance}.
+     *
+     * NOTE: ACL allowance on `encryptedAmount` is already checked for `msg.sender` in {preTransfer}.
+     */
+    function _preTransfer(
+        address /* token */,
+        address /* from */,
+        address /* to */,
+        euint64 /* encryptedAmount */
+    ) internal virtual returns (ebool) {
+        return FHE.asEbool(true);
+    }
+
+    /**
+     * @dev Internal function which performs operations after transfers. Transient access is already granted to the module
+     * for `encryptedAmount`. If additional handle access is needed from the token, call {_getTokenHandleAllowance}.
+     *
+     * NOTE: ACL allowance on `encryptedAmount` is already checked for `msg.sender` in {postTransfer}.
+     */
+    function _postTransfer(
+        address /*token*/,
+        address /*from*/,
+        address /*to*/,
+        euint64 /*encryptedAmount*/
+    ) internal virtual {
+        // default to no-op
+    }
+
+    /**
+     * @dev Check if the module is installed for the given token. The default implementation reads from
+     * an internal storage flag maintained by {onInstall} and {onUninstall}. Derived contracts may override
+     * to extend the check, but should typically rely on the default behavior.
+     *
+     * NOTE: This function should use internal storage to check if the module is installed for the given token.
+     * Do not use external storage like {ERC7984Hooked-isModuleInstalled}.
+     */
+    function _isModuleInstalled(address token) internal view virtual returns (bool) {
+        return _installed[token];
+    }
+
+    /// @dev Allow modules to get access to token handles during transaction.
+    function _getTokenHandleAllowance(address token, euint64 handle) internal virtual {
+        _getTokenHandleAllowance(token, handle, false);
+    }
+
+    /// @dev Allow modules to get access to token handles.
+    function _getTokenHandleAllowance(address token, euint64 handle, bool persistent) internal virtual {
+        if (FHE.isInitialized(handle)) {
+            HandleAccessManager(token).getHandleAllowance(euint64.unwrap(handle), address(this), persistent);
+        }
+    }
+
+    /**
+     * @dev Optionally emit the result of the pre-transfer hook.
+     *
+     * Grants persistent ACL on `compliant` to both this contract and `from`.
+     */
+    function _emitPreTransferResults(
+        address token,
+        address from,
+        address to,
+        euint64 encryptedAmount,
+        ebool compliant,
+        bytes32 context
+    ) internal virtual {
+        if (FHE.isInitialized(compliant)) {
+            if (from != address(0)) {
+                FHE.allowThis(compliant);
+                FHE.allow(compliant, from);
+            }
+        }
+        emit ERC7984HookModuleResult(token, from, to, encryptedAmount, compliant, context);
+    }
+
+    /**
+     * @dev Get transient ACL allowance for the given handle from a contract that inherits {HandleAccessManager}.
+     *
+     * Additionally verifies that the token is authorized to access the handle.
+     */
+    function _accessHandle(address token, euint64 handle) internal {
+        if (!FHE.isInitialized(handle)) return;
+        require(FHE.isAllowed(handle, token), ERC7984HookModuleUnauthorizedUseOfEncryptedAmount(handle, token));
+        _getTokenHandleAllowance(token, handle, false);
+    }
+}

package/utils/FHESafeMath.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.4.0) (utils/FHESafeMath.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.5.0-rc.0) (utils/FHESafeMath.sol)
 pragma solidity ^0.8.24;
 
 import {FHE, ebool, euint64} from "@fhevm/solidity/lib/FHE.sol";
@@ -72,4 +72,29 @@ library FHESafeMath {
         success = FHE.le(difference, a);
         res = FHE.select(success, difference, FHE.asEuint64(0));
     }
+
+    /**
+     * @dev Add `a` and `b` saturating at `type(uint64).max` on overflow. The returned value is the sum
+     * of `a` and `b` if it does not overflow, otherwise `type(uint64).max`.
+     */
+    function saturatingAdd(euint64 a, euint64 b) internal returns (euint64) {
+        if (!FHE.isInitialized(a)) {
+            return b;
+        }
+        if (!FHE.isInitialized(b)) {
+            return a;
+        }
+
+        euint64 sum = FHE.add(a, b);
+        return FHE.select(FHE.ge(sum, a), sum, FHE.asEuint64(type(uint64).max));
+    }
+
+    /**
+     * @dev Subtract `b` from `a` saturating at zero on underflow. The returned value is `a - b` if
+     * `a >= b`, otherwise 0.
+     */
+    function saturatingSub(euint64 a, euint64 b) internal returns (euint64) {
+        euint64 minB = FHE.min(a, b);
+        return FHE.sub(a, minB);
+    }
 }

package/utils/HandleAccessManager.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.4.0) (utils/HandleAccessManager.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.5.0-rc.0) (utils/HandleAccessManager.sol)
 pragma solidity ^0.8.26;
 
 import {Impl} from "@fhevm/solidity/lib/Impl.sol";
@@ -23,8 +23,10 @@ abstract contract HandleAccessManager {
     }
 
     /**
-     * @dev Unimplemented function that must return true if the message sender is allowed to call
+     * @dev Validation function that must return true if the message sender is allowed to call
      * {getHandleAllowance} for the given handle.
      */
-    function _validateHandleAllowance(bytes32 handle) internal view virtual returns (bool);
+    function _validateHandleAllowance(bytes32) internal view virtual returns (bool) {
+        return false;
+    }
 }

package/utils/structs/CheckpointsConfidential.sol

@@ -1,11 +1,10 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Confidential Contracts (last updated v0.4.0) (utils/structs/CheckpointsConfidential.sol)
+// OpenZeppelin Confidential Contracts (last updated v0.5.0-rc.0) (utils/structs/CheckpointsConfidential.sol)
 // This file was procedurally generated from scripts/generate/templates/CheckpointsConfidential.js.
 
 pragma solidity ^0.8.24;
 
 import {euint32, euint64} from "@fhevm/solidity/lib/FHE.sol";
-import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 import {Checkpoints} from "@openzeppelin/contracts/utils/structs/Checkpoints.sol";
 
 /**