@cofhe/mock-contracts 0.8.0 → 1.0.0-alpha.0

package/contracts/MockTaskManager.sol

@@ -31,7 +31,6 @@ error OnlyAggregatorAllowed(address caller);
 
 // Operation-specific errors
 error RandomFunctionNotSupported();
-error NotImplemented();
 
 library TMCommon {
   uint256 private constant HASH_MASK_FOR_METADATA = type(uint256).max - type(uint16).max; // 2 bytes reserved for metadata
@@ -249,6 +248,9 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
   // Signer address for decrypt result verification (threshold network's signing key)
   address public decryptResultSigner;
 
+  // Counter mixed into generated random seeds, as in the real task manager
+  uint256 private randomCounter;
+
   // Storage contract for plaintext results of decrypt operations
   // PlaintextsStorage public plaintextsStorage;
 
@@ -481,6 +483,32 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
     validateFunctionInputTypes(funcId, functionName, encryptedHashes);
   }
 
+  /// @dev Same checks as the real task manager: the plaintext must fit the target type and the
+  ///      security zone must be in range. Without them `FHE.asEuint8(256)` would be stored masked
+  ///      to 0 here while the real task manager reverts.
+  function validateTrivialEncryptInputs(uint256[] memory extraInputs) internal view {
+    uint256 securityZone = extraInputs[2];
+    if (securityZone > uint256(int256(type(int32).max)) || !isValidSecurityZone(int32(int256(securityZone)))) {
+      revert InvalidSecurityZone(int32(int256(securityZone)), securityZoneMin, securityZoneMax);
+    }
+
+    uint256 value = extraInputs[0];
+    uint256 toType = extraInputs[1];
+    uint256 max;
+    if (toType == Utils.EUINT8_TFHE) max = type(uint8).max;
+    else if (toType == Utils.EUINT16_TFHE) max = type(uint16).max;
+    else if (toType == Utils.EUINT32_TFHE) max = type(uint32).max;
+    else if (toType == Utils.EUINT64_TFHE) max = type(uint64).max;
+    else if (toType == Utils.EUINT128_TFHE) max = type(uint128).max;
+    else if (toType == Utils.EADDRESS_TFHE) max = type(uint160).max;
+    else if (toType == Utils.EBOOL_TFHE) max = 1;
+    else return;
+
+    if (value > max) {
+      revert InvalidInputForFunction('trivialEncrypt', uint8(toType));
+    }
+  }
+
   function validateSelectInputs(uint256[] memory encryptedHashes) internal pure {
     if (encryptedHashes.length != 3) {
       revert InvalidInputsAmount('select', encryptedHashes.length, 3);
@@ -511,6 +539,9 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
     }
 
     validateInputs(encryptedHashes, funcId, operation);
+    if (funcId == FunctionId.trivialEncrypt) {
+      validateTrivialEncryptInputs(extraInputs);
+    }
     uint256[] memory inputs = TMCommon.combineInputs(encryptedHashes, extraInputs);
 
     int32 securityZone = getSecurityZone(funcId, encryptedHashes, extraInputs);
@@ -813,12 +844,46 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
   // Stub implementations for new ITaskManager interface methods (inc PR #48)
 
   function createRandomTask(uint8 returnType, uint256 seed, int32 securityZone) external returns (uint256) {
-    // Mock implementation: just return a pseudo-random hash based on seed
-    return uint256(keccak256(abi.encode(returnType, seed, securityZone, block.timestamp)));
+    if (!isValidSecurityZone(securityZone)) {
+      revert InvalidSecurityZone(securityZone, securityZoneMin, securityZoneMax);
+    }
+
+    if (seed == 0) {
+      seed = uint256(
+        keccak256(
+          abi.encodePacked(blockhash(block.number - 1), block.timestamp, randomCounter, block.chainid, securityZone)
+        )
+      );
+      unchecked {
+        randomCounter++;
+      }
+    }
+
+    // Same handle derivation as the real task manager: msg.sender is part of the preimage.
+    uint256[] memory inputs = new uint256[](2);
+    inputs[0] = seed;
+    inputs[1] = uint256(uint160(msg.sender));
+
+    uint256 ctHash = TMCommon.calcPlaceholderKey(returnType, securityZone, inputs, FunctionId.random);
+    acl.allowTransient(ctHash, msg.sender, address(this));
+    emit TaskCreated(
+      ctHash,
+      Utils.functionIdToString(FunctionId.random),
+      seed,
+      uint256(uint32(securityZone)),
+      inputs[1]
+    );
+
+    // NOTE: MOCK - the real task manager leaves the value to the coprocessor; store one here.
+    (MockGasMode mode, uint256 startGas) = _mockGasTrackStart();
+    _set(ctHash, uint256(keccak256(abi.encode(ctHash))));
+    _mockGasTrackEnd(mode, startGas);
+
+    return ctHash;
   }
 
   function isPubliclyAllowed(uint256 ctHash) external view returns (bool) {
-    revert NotImplemented();
+    return acl.globalAllowed(ctHash);
   }
 
   function verifyDecryptResultBatch(

package/contracts/MockThresholdNetwork.sol

@@ -9,7 +9,7 @@ pragma solidity >=0.8.19 <0.9.0;
 
 import { MockACL } from './MockACL.sol';
 import { MockTaskManager } from './MockTaskManager.sol';
-import { MockPermissioned, ACP } from './Permissioned.sol';
+import { ACP, PermissionedUpgradeable } from './Permissioned.sol';
 
 contract MockThresholdNetwork {
   MockTaskManager public mockTaskManager;
@@ -181,16 +181,16 @@ contract MockThresholdNetwork {
 
   function decodeLowLevelReversion(bytes memory data) public pure returns (string memory error) {
     bytes4 selector = bytes4(data);
-    if (selector == MockPermissioned.PermissionInvalid_Expired.selector) {
+    if (selector == PermissionedUpgradeable.PermissionInvalid_Expired.selector) {
       return 'PermissionInvalid_Expired';
     }
-    if (selector == MockPermissioned.PermissionInvalid_IssuerSignature.selector) {
+    if (selector == PermissionedUpgradeable.PermissionInvalid_IssuerSignature.selector) {
       return 'PermissionInvalid_IssuerSignature';
     }
-    if (selector == MockPermissioned.PermissionInvalid_RecipientSignature.selector) {
+    if (selector == PermissionedUpgradeable.PermissionInvalid_RecipientSignature.selector) {
       return 'PermissionInvalid_RecipientSignature';
     }
-    if (selector == MockPermissioned.PermissionInvalid_Disabled.selector) {
+    if (selector == PermissionedUpgradeable.PermissionInvalid_Disabled.selector) {
       return 'PermissionInvalid_Disabled';
     }
     // Handle other errors

package/contracts/Permissioned.sol

@@ -3,7 +3,8 @@
 pragma solidity >=0.8.19 <0.9.0;
 
 import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
-import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 /// @dev ACP scope discriminator (uint8 on the wire). Exactly one scope mode per ACP:
 ///   SCOPE_GLOBAL   — access to ALL of `issuer`s encrypted values; `contracts`/`handles` must be empty
@@ -15,160 +16,256 @@ uint8 constant SCOPE_CONTRACT = 1;
 uint8 constant SCOPE_HANDLES = 2;
 
 /**
- * @dev ACP (Access Control Permission) — the V3 permission struct.
+ * @dev ACP (Access Control Permission) — the permission body that must be passed to a
+ * contract to allow access to sensitive data.
  *
- * Signing flows are identical to V2 (self / two-step sharing) with the
- * `ACPIssuerSelf` / `ACPIssuerShared` / `ACPRecipient` EIP-712 types under
- * domain version "2".
+ * The minimum permission to access a user's own data requires the fields
+ * < issuer, expiration, scope, sealingKey, issuerSignature >
  *
- * Revocation: `revokerData` is an opaque uint256 interpreted by
- * `revokerContract` (creation timestamp in the default ACPTimestampRevoker).
- * `revokerData = 0` or `revokerContract = address(0)` disables the check
- * (permission not revocable).
+ *   ---
+ *
+ * If not sharing the permission, `issuer` signs a signature using the fields:
+ *     < issuer, expiration, recipient, revokerData, revokerContract, scope, contracts, handles, sealingKey >
+ * This signature can now be used by `issuer` to access their own encrypted data.
+ *
+ *   ---
+ *
+ * Sharing a permission is a two step process: `issuer` completes step 1, and `recipient` completes step 2.
+ *
+ * 1:
+ * `issuer` creates a permission with `recipient` populated with the address of the user to give access to.
+ * `issuer` does not include a `sealingKey` in the permission, it will be populated by the `recipient`.
+ * `issuer` signs a signature including the fields: (note: `sealingKey` is absent in this signature)
+ *     < issuer, expiration, recipient, revokerData, revokerContract, scope, contracts, handles >
+ * `issuer` packages the permission data and `issuerSignature` and shares it with `recipient`
+ *     ** None of this data is sensitive, and can be shared as cleartext **
+ *
+ * 2:
+ * `recipient` adds their `sealingKey` to the data received from `issuer`
+ * `recipient` signs a signature including the fields:
+ *     < sealingKey, issuerSignature >
+ * `recipient` can now use the completed permission to access `issuer`s encrypted data.
+ *
+ *   ---
+ *
+ * Scope: `scope` selects exactly one access mode (see SCOPE_* above). Scopes narrow the
+ * issuer's existing ACL access, they never widen it. Scope semantics are enforced by the
+ * ACL (`isAllowedWithPermission`); this contract checks structure only.
+ *
+ *   ---
+ *
+ * Revocation: `revokerData` and `revokerContract` are optional and can be used together to
+ * increase security and control by disabling a permission after it has been created.
+ * `revokerData` is an opaque uint256 interpreted by `revokerContract` (the creation
+ * timestamp in the default ACPTimestampRevoker). `revokerData = 0` or
+ * `revokerContract = address(0)` disables the check (permission not revocable).
  */
 struct ACP {
-    address issuer;
-    uint64 expiration;
-    address recipient;
-    uint256 revokerData;
-    address revokerContract;
-    uint8 scope;
-    address[] contracts;
-    bytes32[] handles;
-    bytes32 sealingKey;
-    bytes issuerSignature;
-    bytes recipientSignature;
+  // (base) User that initially created the permission, target of data fetching
+  address issuer;
+  // (base) Expiration timestamp
+  uint64 expiration;
+  // (sharing) The user that this permission will be shared with
+  // ** optional, use `address(0)` to disable **
+  address recipient;
+  // (issuer defined revocation) Opaque data passed to `revokerContract` to check this permission's validity
+  // ** optional, use `0` to disable **
+  uint256 revokerData;
+  // (issuer defined revocation) The contract to query to determine permission validity
+  // ** optional, use `address(0)` to disable **
+  address revokerContract;
+  // (scope) Which access mode this permission grants — one of SCOPE_GLOBAL / SCOPE_CONTRACT / SCOPE_HANDLES
+  uint8 scope;
+  // (scope) Contracts whose readable values this permission grants access to (SCOPE_CONTRACT only)
+  address[] contracts;
+  // (scope) Ciphertext handles this permission grants access to (SCOPE_HANDLES only)
+  bytes32[] handles;
+  // (base) The publicKey of a sealingPair used to re-encrypt `issuer`s confidential data
+  //   (non-sharing) Populated by `issuer`
+  //   (sharing)     Populated by `recipient`
+  bytes32 sealingKey;
+  // (base) `signTypedData` signature created by `issuer`.
+  // (base) Shared- and Self- permissions differ in signature format: (`sealingKey` absent in shared signature)
+  bytes issuerSignature;
+  // (sharing) `signTypedData` signature created by `recipient` with format:
+  // (sharing) < sealingKey, issuerSignature >
+  // ** required for shared permissions **
+  bytes recipientSignature;
 }
 
 /// @dev Minimum required interface to create a custom permission revoker.
-/// Revokers are optional and provide control to disable a permission after creation.
+/// Revokers are optional, and provide extra security and control when sharing permissions.
 interface IPermissionCustomIdValidator {
-    /// @dev Returning `true` disables the permission.
-    function disabled(address issuer, uint256 id) external view returns (bool);
+  /// @dev Checks whether a permission has been revoked, returning `true` disables the permission.
+  function disabled(address issuer, uint256 id) external view returns (bool);
 }
 
-contract MockPermissioned is EIP712 {
-    using ACPUtils for ACP;
-
-    /// @dev Same verifying-contract identity as V2 ("ACL"), domain version bumped for V3 types.
-    constructor() EIP712("ACL", "2") {}
-
-    error PermissionInvalid_Expired();
-    error PermissionInvalid_IssuerSignature();
-    error PermissionInvalid_RecipientSignature();
-    error PermissionInvalid_Disabled();
-
-    /// @dev Validates an ACP's structure: expiration, signatures, revocation.
-    /// Identical check order and semantics to V2 `withPermission`.
-    ///
-    /// NOTE: Functions protected by `withPermission` should return ONLY the sensitive data of `acp.issuer`.
-    /// !! Returning data of `msg.sender` will leak sensitive values - `msg.sender` cannot be trusted in view functions !!
-    modifier withPermission(ACP memory acp) {
-        // Expiration
-        if (acp.expiration < block.timestamp)
-            revert PermissionInvalid_Expired();
-
-        // Issuer signature
-        if (
-            !SignatureChecker.isValidSignatureNow(
-                acp.issuer,
-                _hashTypedDataV4(acp.issuerHash()),
-                acp.issuerSignature
-            )
-        ) revert PermissionInvalid_IssuerSignature();
-
-        // (if applicable) Recipient signature
-        if (
-            acp.recipient != address(0) &&
-            !SignatureChecker.isValidSignatureNow(
-                acp.recipient,
-                _hashTypedDataV4(acp.recipientHash()),
-                acp.recipientSignature
-            )
-        ) revert PermissionInvalid_RecipientSignature();
-
-        // (if applicable) Externally disabled (revoked)
-        if (
-            acp.revokerData != 0 &&
-            acp.revokerContract != address(0) &&
-            IPermissionCustomIdValidator(acp.revokerContract).disabled(
-                acp.issuer,
-                acp.revokerData
-            )
-        ) revert PermissionInvalid_Disabled();
-
-        _;
-    }
-
-    /// @dev Structure-validity probe (expiration / signatures / revocation).
-    function checkPermissionValidity(
-        ACP memory acp
-    ) public view withPermission(acp) returns (bool) {
-        return true;
-    }
-
-    function hashTypedDataV4(
-        bytes32 structHash
-    ) public view virtual returns (bytes32) {
-        return _hashTypedDataV4(structHash);
-    }
+contract PermissionedUpgradeable is Initializable, EIP712Upgradeable {
+  using ACPUtils for ACP;
+
+  /// @dev Same verifying-contract identity as V2 ("ACL"), domain version bumped for the ACP types.
+  function __PermissionedUpgradeable_init() internal onlyInitializing {
+    __EIP712_init_unchained("ACL", "2");
+  }
+
+  function __PermissionedUpgradeable_init_unchained()
+    internal
+    onlyInitializing
+  {
+    __EIP712_init_unchained("ACL", "2");
+  }
+
+  /// @dev The EIP-712 domain is defined by code, not by storage.
+  ///
+  /// `EIP712Upgradeable` persists name/version at initialization time and only
+  /// then — an implementation-only upgrade would leave an already-initialized
+  /// proxy reporting the V2 domain ("ACL", "1") while hashing the V3 types,
+  /// and every signature would fail to verify. Overriding the accessors (which
+  /// OZ marks `virtual` for exactly this case) makes the upgrade a pure
+  /// implementation swap: no reinitializer, no migration transaction.
+  function _EIP712Name() internal view virtual override returns (string memory) {
+    return "ACL";
+  }
+
+  function _EIP712Version()
+    internal
+    view
+    virtual
+    override
+    returns (string memory)
+  {
+    return "2";
+  }
+
+  /// @dev Emitted when `acp.expiration` is in the past (< block.timestamp)
+  error PermissionInvalid_Expired();
+
+  /// @dev Emitted when `issuerSignature` is malformed or was not signed by `acp.issuer`
+  error PermissionInvalid_IssuerSignature();
+
+  /// @dev Emitted when `recipientSignature` is malformed or was not signed by `acp.recipient`
+  error PermissionInvalid_RecipientSignature();
+
+  /// @dev Emitted when `revokerContract` returned `true` indicating that this permission has been externally disabled
+  error PermissionInvalid_Disabled();
+
+  /// @dev Validates an `acp`s access of sensitive data.
+  /// `acp` may be invalid or unauthorized for the following reasons:
+  ///    - Expired:                  `acp.expiration` is in the past (< block.timestamp)
+  ///    - Issuer signature:         `issuerSignature` is malformed or was not signed by `acp.issuer`
+  ///    - Recipient signature:      `recipientSignature` is malformed or was not signed by `acp.recipient`
+  ///    - Disabled:                 `revokerContract` returned `true` indicating that this permission has been externally disabled
+  /// @param acp ACP struct containing data necessary to validate data access and seal for return.
+  ///
+  /// NOTE: Functions protected by `withPermission` should return ONLY the sensitive data of `acp.issuer`.
+  /// !! Returning data of `msg.sender` will leak sensitive values - `msg.sender` cannot be trusted in view functions !!
+  modifier withPermission(ACP memory acp) {
+    // Expiration
+    if (acp.expiration < block.timestamp)
+      revert PermissionInvalid_Expired();
+
+    // Issuer signature
+    if (
+      !SignatureChecker.isValidSignatureNow(
+        acp.issuer,
+        _hashTypedDataV4(acp.issuerHash()),
+        acp.issuerSignature
+      )
+    ) revert PermissionInvalid_IssuerSignature();
+
+    // (if applicable) Recipient signature
+    if (
+      acp.recipient != address(0) &&
+      !SignatureChecker.isValidSignatureNow(
+        acp.recipient,
+        _hashTypedDataV4(acp.recipientHash()),
+        acp.recipientSignature
+      )
+    ) revert PermissionInvalid_RecipientSignature();
+
+    // (if applicable) Externally disabled (revoked)
+    if (
+      acp.revokerData != 0 &&
+      acp.revokerContract != address(0) &&
+      IPermissionCustomIdValidator(acp.revokerContract).disabled(
+        acp.issuer,
+        acp.revokerData
+      )
+    ) revert PermissionInvalid_Disabled();
+
+    _;
+  }
+
+  /// @dev Structure-validity probe (expiration / signatures / revocation).
+  function checkPermissionValidity(
+    ACP memory acp
+  ) public view withPermission(acp) returns (bool) {
+    return true;
+  }
 }
 
-/// @dev Signature type hashes for ACP. Field order must match the struct and the
+/// @dev Internal utility library to improve the readability of PermissionedUpgradeable.
+/// Primarily focused on signature type hashes. Field order must match the struct and the
 /// SDK's SignatureTypes exactly — pinned by tests on both sides.
 library ACPUtils {
-    function issuerHash(ACP memory acp) internal pure returns (bytes32) {
-        if (acp.recipient == address(0)) return issuerSelfHash(acp);
-        return issuerSharedHash(acp);
-    }
-
-    function issuerSelfHash(ACP memory acp) internal pure returns (bytes32) {
-        return
-            keccak256(
-                abi.encode(
-                    keccak256(
-                        "ACPIssuerSelf(address issuer,uint64 expiration,address recipient,uint256 revokerData,address revokerContract,uint8 scope,address[] contracts,bytes32[] handles,bytes32 sealingKey)"
-                    ),
-                    acp.issuer,
-                    acp.expiration,
-                    acp.recipient,
-                    acp.revokerData,
-                    acp.revokerContract,
-                    acp.scope,
-                    keccak256(abi.encodePacked(acp.contracts)),
-                    keccak256(abi.encodePacked(acp.handles)),
-                    acp.sealingKey
-                )
-            );
-    }
-
-    function issuerSharedHash(ACP memory acp) internal pure returns (bytes32) {
-        return
-            keccak256(
-                abi.encode(
-                    keccak256(
-                        "ACPIssuerShared(address issuer,uint64 expiration,address recipient,uint256 revokerData,address revokerContract,uint8 scope,address[] contracts,bytes32[] handles)"
-                    ),
-                    acp.issuer,
-                    acp.expiration,
-                    acp.recipient,
-                    acp.revokerData,
-                    acp.revokerContract,
-                    acp.scope,
-                    keccak256(abi.encodePacked(acp.contracts)),
-                    keccak256(abi.encodePacked(acp.handles))
-                )
-            );
-    }
-
-    function recipientHash(ACP memory acp) internal pure returns (bytes32) {
-        return
-            keccak256(
-                abi.encode(
-                    keccak256("ACPRecipient(bytes32 sealingKey,bytes issuerSignature)"),
-                    acp.sealingKey,
-                    keccak256(acp.issuerSignature)
-                )
-            );
-    }
+  function issuerHash(ACP memory acp) internal pure returns (bytes32) {
+    if (acp.recipient == address(0)) return issuerSelfHash(acp);
+    return issuerSharedHash(acp);
+  }
+
+  function issuerSelfHash(
+    ACP memory acp
+  ) internal pure returns (bytes32) {
+    return
+      keccak256(
+        abi.encode(
+          keccak256(
+            "ACPIssuerSelf(address issuer,uint64 expiration,address recipient,uint256 revokerData,address revokerContract,uint8 scope,address[] contracts,bytes32[] handles,bytes32 sealingKey)"
+          ),
+          acp.issuer,
+          acp.expiration,
+          acp.recipient,
+          acp.revokerData,
+          acp.revokerContract,
+          acp.scope,
+          keccak256(abi.encodePacked(acp.contracts)),
+          keccak256(abi.encodePacked(acp.handles)),
+          acp.sealingKey
+        )
+      );
+  }
+
+  function issuerSharedHash(
+    ACP memory acp
+  ) internal pure returns (bytes32) {
+    return
+      keccak256(
+        abi.encode(
+          keccak256(
+            "ACPIssuerShared(address issuer,uint64 expiration,address recipient,uint256 revokerData,address revokerContract,uint8 scope,address[] contracts,bytes32[] handles)"
+          ),
+          acp.issuer,
+          acp.expiration,
+          acp.recipient,
+          acp.revokerData,
+          acp.revokerContract,
+          acp.scope,
+          keccak256(abi.encodePacked(acp.contracts)),
+          keccak256(abi.encodePacked(acp.handles))
+        )
+      );
+  }
+
+  function recipientHash(
+    ACP memory acp
+  ) internal pure returns (bytes32) {
+    return
+      keccak256(
+        abi.encode(
+          keccak256("ACPRecipient(bytes32 sealingKey,bytes issuerSignature)"),
+          acp.sealingKey,
+          keccak256(acp.issuerSignature)
+        )
+      );
+  }
 }

package/contracts/cofhe-contracts.json

@@ -0,0 +1,10 @@
+{
+  "repo": "FhenixProtocol/cofhe-contracts",
+  "commit": "0afc699c29e64c16e602845d95b2e85d5ca159c4",
+  "sourceDir": "contracts/internal/host-chain/contracts",
+  "files": {
+    "ACPShareRegistry.sol": "27cfcadd82922ca56151ae4bde04fff8129aa1c26d4631a2e16a56d6a96a9971",
+    "ACPTimestampRevoker.sol": "be40add6302b68cff8c15fb5bcc54e7ef74db63df59cf350e8ccfbb06a7a74fc",
+    "Permissioned.sol": "34d8d2f4a41c9a5ffbd69e32e4e3d718a7d4fcde6289fbe132fa3c4a74de9c0d"
+  }
+}