@iexec-nox/nox-protocol-contracts 0.2.2 → 0.2.3

package/contracts/interfaces/INoxCompute.sol

@@ -1,40 +1,49 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.27;
+pragma solidity ^0.8.35;
 
-import {TEEType} from "../shared/TypeUtils.sol";
+import {TEEType} from "../utils/TypeUtils.sol";
 
 /**
  * @title INoxCompute
  * @notice Interface for the Nox compute contract powered by TEE.
  */
 interface INoxCompute {
+    // ------------- General errors -------------
     /// Error thrown when account address is zero
     error InvalidZeroAddress();
     /// Error thrown when bytes parameter is empty
     error InvalidEmptyBytes();
+
+    // ------------- ACL errors -------------
     /// Error thrown when sender doesn't have access to the handle
     error UnauthorizedSender(address sender);
     /// Error thrown when an account is not allowed to use a handle
     error NotAllowed(bytes32 handle, address account);
-    error InvalidProof(bytes proof, string reason);
-    error UnsupportedType();
-    error IncompatibleTypes();
+    /// Error thrown when a handle is not publicly decryptable
     error NotPubliclyDecryptable(bytes32 handle);
     /// Error thrown when attempting an ACL mutation on a public handle
     error PublicHandleACLForbidden();
+
+    // ------------- Compute errors -------------
+    /// Error thrown when the input proof is invalid
+    error InvalidProof(bytes proof, string reason);
     /// Error thrown when an operand is bytes32(0), indicating an undefined handle
     error UndefinedHandle();
 
+    // ------------- ACL events -------------
     /// Emitted when admin role is granted
     event Allowed(address indexed sender, address indexed account, bytes32 indexed handle);
     /// Emitted when viewer role is granted
     event ViewerAdded(address indexed sender, address indexed viewer, bytes32 indexed handle);
     /// Emitted when a handle is marked as publicly decryptable
     event MarkedAsPubliclyDecryptable(address indexed sender, bytes32 indexed handle);
+
+    // ------------- Protocol config events -------------
     event KmsPublicKeyUpdated(bytes newKmsPublicKey);
     event GatewayUpdated(address indexed newGateway);
     event ProofExpirationDurationUpdated(uint256 newDuration);
 
+    // ------------- Compute events -------------
     event WrapAsPublicHandle(
         address indexed caller,
         bytes32 plaintext,
@@ -228,7 +237,7 @@ interface INoxCompute {
     function validateAllowedForAll(address account, bytes32[] calldata handles) external view;
 
     /**
-     * Add a viewer for a specific handle
+     * Adds a viewer for a specific handle
      * @dev Only an admin can add a viewer. The viewer address cannot be address(0).
      * @param handle The handle identifier
      * @param viewer The address to grant viewer role
@@ -561,6 +570,12 @@ interface INoxCompute {
         bytes32 totalSupply
     ) external returns (bytes32 success, bytes32 newBalanceFrom, bytes32 newTotalSupply);
 
+    // ------------- Config getters -------------
+
+    function kmsPublicKey() external view returns (bytes memory);
+    function gateway() external view returns (address);
+    function proofExpirationDuration() external view returns (uint256);
+
     // ------------- Admin functions -------------
 
     /**
@@ -580,8 +595,4 @@ interface INoxCompute {
      * @param newDuration The new expiration duration in seconds
      */
     function setProofExpirationDuration(uint256 newDuration) external;
-
-    function kmsPublicKey() external view returns (bytes memory);
-    function gateway() external view returns (address);
-    function proofExpirationDuration() external view returns (uint256);
 }

package/contracts/modules/ACL.sol

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.35;
+
+import {HandleUtils} from "../utils/HandleUtils.sol";
+import {INoxCompute} from "../interfaces/INoxCompute.sol";
+import {Common} from "./Common.sol";
+
+/**
+ * @title ACL
+ * @notice Access control for encrypted handles. Supports persistent and transient access,
+ * plus viewer and public-decryption roles.
+ */
+abstract contract ACL is Common {
+    modifier notZeroAddress(address account) {
+        require(account != address(0), InvalidZeroAddress());
+        _;
+    }
+
+    /**
+     * Ensures the sender is allowed to access the handle
+     * @param handle The handle to check access for
+     */
+    modifier onlyAllowed(bytes32 handle) {
+        require(_isAllowed(handle, msg.sender), UnauthorizedSender(msg.sender));
+        _;
+    }
+
+    /**
+     * Prevents ACL mutations on public handles.
+     * Applied before onlyAllowed to avoid unnecessary storage reads.
+     * @param handle The handle to check
+     */
+    modifier notPublicHandle(bytes32 handle) {
+        require(!HandleUtils.isPublicHandle(handle), PublicHandleACLForbidden());
+        _;
+    }
+
+    /// @inheritdoc INoxCompute
+    function isAllowed(bytes32 handle, address account) external view override returns (bool) {
+        return _isAllowed(handle, account);
+    }
+
+    /// @inheritdoc INoxCompute
+    function validateAllowedForAll(
+        address account,
+        bytes32[] calldata handles
+    ) external view override {
+        _validateAllowedForAll(account, handles);
+    }
+
+    /// @inheritdoc INoxCompute
+    function allow(
+        bytes32 handle,
+        address account
+    ) external override notZeroAddress(account) notPublicHandle(handle) onlyAllowed(handle) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        $.admins[handle][account] = true;
+        emit Allowed(msg.sender, account, handle);
+    }
+
+    /**
+     * @inheritdoc INoxCompute
+     * @dev To grant transient access, the caller must already have permission on `handle`.
+     *      Transient access only lasts for the current transaction. It is the responsibility
+     *      of the application contract to convert this into persistent access via `allow()`
+     *      if needed.
+     */
+    function allowTransient(
+        bytes32 handle,
+        address account
+    ) external override notZeroAddress(account) notPublicHandle(handle) onlyAllowed(handle) {
+        _allowTransient(handle, account);
+    }
+
+    /// @inheritdoc INoxCompute
+    function disallowTransient(
+        bytes32 handle,
+        address account
+    ) external override notZeroAddress(account) notPublicHandle(handle) onlyAllowed(handle) {
+        bytes32 key = keccak256(abi.encodePacked(handle, account));
+        assembly {
+            tstore(key, 0)
+        }
+    }
+
+    /// @inheritdoc INoxCompute
+    function addViewer(
+        bytes32 handle,
+        address viewer
+    ) external override notZeroAddress(viewer) notPublicHandle(handle) onlyAllowed(handle) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        $.viewers[handle][viewer] = true;
+        emit ViewerAdded(msg.sender, viewer, handle);
+    }
+
+    /// @inheritdoc INoxCompute
+    function isViewer(bytes32 handle, address viewer) external view override returns (bool) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        return
+            HandleUtils.isPublicHandle(handle) ||
+            $.isPubliclyDecryptable[handle] ||
+            $.viewers[handle][viewer] ||
+            $.admins[handle][viewer];
+    }
+
+    /// @inheritdoc INoxCompute
+    function allowPublicDecryption(
+        bytes32 handle
+    ) external override notPublicHandle(handle) onlyAllowed(handle) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        $.isPubliclyDecryptable[handle] = true;
+        emit MarkedAsPubliclyDecryptable(msg.sender, handle);
+    }
+
+    /// @inheritdoc INoxCompute
+    function isPubliclyDecryptable(bytes32 handle) external view override returns (bool) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        return HandleUtils.isPublicHandle(handle) || $.isPubliclyDecryptable[handle];
+    }
+
+    /**
+     * Grants transient access to a handle for an account. This function does not do any
+     * checks and should be used with caution.
+     * This function is used in two scenarios:
+     *   - For handles generated off-chain by the Handle Gateway, once the proof has been verified
+     *   - For handles resulting from on-chain operations, where the caller naturally inherits
+     *     rights on the output handle
+     * @param handle Handle identifier
+     * @param account Address of the account
+     */
+    function _allowTransient(bytes32 handle, address account) internal override {
+        // Public handles don't need ACL; skip silently to save gas.
+        if (HandleUtils.isPublicHandle(handle)) {
+            return;
+        }
+        bytes32 key = keccak256(abi.encodePacked(handle, account));
+        assembly {
+            tstore(key, 1)
+        }
+    }
+
+    /**
+     * Reverts if account lacks access to any handle in the array.
+     */
+    function _validateAllowedForAll(
+        address account,
+        bytes32[] memory handles
+    ) internal view override {
+        for (uint256 i = 0; i < handles.length; i++) {
+            if (!_isAllowed(handles[i], account)) {
+                revert NotAllowed(handles[i], account);
+            }
+        }
+    }
+
+    /**
+     * Checks if the handle is public, or if account has transient or persistent
+     * access to the handle.
+     */
+    function _isAllowed(bytes32 handle, address account) private view returns (bool) {
+        return
+            HandleUtils.isPublicHandle(handle) ||
+            _isAllowedTransient(handle, account) ||
+            _isAllowedPersistent(handle, account);
+    }
+
+    /**
+     * Check if an address has transient access to handle.
+     * @param handle Handle.
+     * @param account Address of the account.
+     * @return Returns `true` if the address has transient access to a handle and `false` otherwise.
+     */
+    function _isAllowedTransient(bytes32 handle, address account) private view returns (bool) {
+        bool isAllowedTransient_;
+        bytes32 key = keccak256(abi.encodePacked(handle, account));
+        assembly {
+            isAllowedTransient_ := tload(key)
+        }
+        return isAllowedTransient_;
+    }
+
+    /**
+     * Check if an address has persistent access to handle.
+     * @param handle Handle.
+     * @param account Address of the account.
+     * @return Returns `true` if the address has persistent access to a handle and `false` otherwise.
+     */
+    function _isAllowedPersistent(bytes32 handle, address account) private view returns (bool) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        return $.admins[handle][account];
+    }
+}

package/contracts/modules/Admin.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.35;
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import {Common} from "./Common.sol";
+
+/**
+ * @title Admin
+ * @notice Role-based admin layer for NoxCompute.
+ * @dev Two roles drive privileged actions:
+ *      - DEFAULT_ADMIN_ROLE: grants/revokes other roles.
+ *      - UPGRADER_ROLE: authorizes UUPS upgrades AND updates infrastructure config
+ *        (KMS public key, gateway address, proof expiration duration).
+ */
+abstract contract Admin is Common, AccessControlUpgradeable, UUPSUpgradeable {
+    bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
+
+    /**
+     * Sets the KMS public key used for ECIES encryption.
+     * Only callable by an UPGRADER_ROLE holder.
+     * @param newKmsPublicKey Compressed SEC1 secp256k1 public key (33 bytes)
+     */
+    function setKmsPublicKey(
+        bytes calldata newKmsPublicKey
+    ) external override onlyRole(UPGRADER_ROLE) {
+        require(newKmsPublicKey.length != 0, InvalidEmptyBytes());
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        $.kmsPublicKey = newKmsPublicKey;
+        emit KmsPublicKeyUpdated(newKmsPublicKey);
+    }
+
+    /**
+     * Sets Gateway wallet address.
+     * Only callable by an UPGRADER_ROLE holder.
+     * @param gatewayAddress New Gateway wallet address
+     */
+    function setGateway(address gatewayAddress) external override onlyRole(UPGRADER_ROLE) {
+        require(gatewayAddress != address(0), InvalidZeroAddress());
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        $.gateway = gatewayAddress;
+        emit GatewayUpdated(gatewayAddress);
+    }
+
+    /**
+     * Sets the proof expiration duration.
+     * Only callable by an UPGRADER_ROLE holder.
+     * @param newDuration New expiration duration in seconds
+     */
+    function setProofExpirationDuration(
+        uint256 newDuration
+    ) external override onlyRole(UPGRADER_ROLE) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        $.proofExpirationDuration = newDuration;
+        emit ProofExpirationDurationUpdated(newDuration);
+    }
+
+    /**
+     * Returns the KMS public key used for ECIES encryption.
+     */
+    function kmsPublicKey() external view override returns (bytes memory) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        return $.kmsPublicKey;
+    }
+
+    /**
+     * Returns the Gateway wallet address.
+     */
+    function gateway() external view override returns (address) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        return $.gateway;
+    }
+
+    /**
+     * Returns the proof expiration duration in seconds.
+     */
+    function proofExpirationDuration() external view override returns (uint256) {
+        NoxComputeStorage storage $ = _getNoxComputeStorage();
+        return $.proofExpirationDuration;
+    }
+
+    /**
+     * Authorizes contract upgrades only by an UPGRADER_ROLE holder.
+     */
+    function _authorizeUpgrade(
+        address /*newImplementation*/
+    ) internal override onlyRole(UPGRADER_ROLE) {}
+
+    /**
+     * @dev Initializes AccessControl and grants the defined roles.
+     */
+    function _initAccessControl(address admin, address upgrader) internal {
+        require(admin != address(0), InvalidZeroAddress());
+        require(upgrader != address(0), InvalidZeroAddress());
+        __AccessControl_init();
+        _grantRole(DEFAULT_ADMIN_ROLE, admin);
+        _grantRole(UPGRADER_ROLE, upgrader);
+    }
+}

package/contracts/modules/Common.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.35;
+
+import {INoxCompute} from "../interfaces/INoxCompute.sol";
+
+/**
+ * @title Common
+ * @notice Shared base for all modules. Defines the ERC7201 storage layout,
+ * the storage accessor, and virtual declarations for cross-module functions.
+ */
+abstract contract Common is INoxCompute {
+    // TODO: remove `slither-disable-next-line` once Slither supports the `erc7201` builtin (added in solc 0.8.35).
+    // slither-disable-next-line uninitialized-state
+    bytes32 private constant NOX_COMPUTE_STORAGE_LOCATION = bytes32(
+        erc7201("nox.storage.NoxCompute")
+    );
+
+    /// @custom:storage-location erc7201:nox.storage.NoxCompute
+    struct NoxComputeStorage {
+        // An admin of a handle can:
+        //  - use it as a computation input
+        //  - decrypt its associated data off-chain
+        //  - make it publicly decryptable
+        //  - add other admins and viewers
+        mapping(bytes32 handleId => mapping(address => bool)) admins;
+        // A viewer of a handle can only decrypt its associated data off-chain.
+        //TODO: Make viewer expirable
+        mapping(bytes32 handleId => mapping(address => bool)) viewers;
+        // Handles that are publicly decryptable
+        mapping(bytes32 handle => bool) isPubliclyDecryptable;
+        bytes kmsPublicKey;
+        address gateway;
+        uint256 proofExpirationDuration;
+        // Counter used to guarantee handle uniqueness when all operands are public handles
+        uint256 uniqueSeedCounter;
+    }
+
+    function _getNoxComputeStorage() internal pure returns (NoxComputeStorage storage $) {
+        bytes32 slot = NOX_COMPUTE_STORAGE_LOCATION;
+        assembly {
+            $.slot := slot
+        }
+    }
+
+    // ----- Functions used cross-modules -----
+
+    // Implemented by ACL, called by Compute.
+    function _allowTransient(bytes32 handle, address account) internal virtual;
+
+    // Implemented by ACL, called by Compute.
+    function _validateAllowedForAll(
+        address account,
+        bytes32[] memory handles
+    ) internal view virtual;
+}