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

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @cofhe/mock-contracts Changelog
 
+## 1.0.0
+
+### Minor Changes
+
+- 6dcfb7d: ACPs sharing SNAPSHOTs (ctHashes rather than live data) can use the new on-chain ACP Sharing Registry `metadata` field to cite the origin of the snapshotted data (contract address + view-function / event), and the recipient can verify it on-chain. [Docs](https://cofhesdk.fhenix.io/sdk/acp#labelling-a-snapshot-share)
+
+  **@cofhe/sdk**
+
+  - `createSharing({ labels })`, `shareOnChain(acp, { labels | metadata })`; labels travel in `export()` / `importShared` as `SharedACP.metadata`.
+  - New `client.acp.verifyShareLabels`, `client.acp.getShareFromChain`, and `describeShareMetadata`. `IncomingShare` gains `metadata` and `appKey`.
+  - New `acp.app` config option: shares are tagged with the app's key and `getIncomingShares` lists only that app's shares ([docs](https://cofhesdk.fhenix.io/sdk/acp#mark-shares-for-your-app)).
+  - `@cofhe/sdk/acps` exports the metadata codec, label builders (`viewFunctionLabel`, `eventLogLabel`, `UNLABELLED`), verifiers, registry readers, `shareAppKey` and `ERC7984_ABI`.
+
+  **@cofhe/react**
+
+  - New `useCofheShareLabels`. `useCofheShareOnChain` accepts `{ acp, labels | metadata }`.
+  - The inbox shows each share's labels and their verification. [Docs](https://cofhesdk.fhenix.io/react/acp#share-labels)
+
+  **Mocks and plugins**
+
+  - `ACPShareRegistry`, `ACPTimestampRevoker` and `Permissioned` are copied verbatim from a pinned cofhe-contracts commit (`pnpm update:cofhe-contracts <commit>`). The share registry is deployed behind `MockERC1967Proxy`.
+  - Mocks now need Solidity ≥0.8.25 and `@openzeppelin/contracts-upgradeable` (new Hardhat plugin peer dependency; Foundry users add its remapping).
+
+### Patch Changes
+
+- d711ce2: The mocks now behave like the real TaskManager and TFHE-rs in more places. Tests that relied on the old mock behaviour may start failing, as they would on a real network.
+
+  - `FHE.asE*` (trivial encrypt) reverts with `InvalidInputForFunction` when the value does not fit the type (e.g. `FHE.asEuint8(256)`), and with `InvalidSecurityZone` for an out of range zone, instead of storing the value masked.
+  - `encryptInputs` against the mocks rejects out-of-range values with the same error as the production path, instead of passing them on to be masked (e.g. `Encryptable.uint8(256n)` became `0`).
+  - `FHE.not` on encrypted integers is a bitwise NOT (`not(euint8(2))` is 253, not 0), and `FHE.rol` / `FHE.ror` rotate within the type's width, with the amount taken modulo the width, instead of shifting.
+  - `FHE.rem(x, 0)` returns `x` instead of reverting.
+  - `FHE.random*` handles carry their type and security zone and can be allowed and computed on.
+  - `MockTaskManager.isPubliclyAllowed` returns whether a handle was made public with `FHE.allowGlobal` / `FHE.allowPublic`, instead of reverting with `NotImplemented`.
+  - Handles in a negative security zone go through the ACL like any other handle. Previously any contract could use them and `FHE.allow*` did nothing.
+  - `publishDecryptResultBatch` emits `DecryptionResult` with the caller as `requestor`, and the batch decrypt result functions revert with `LengthMismatch` when the arrays differ in length.
+  - `setSecurityZones` rejects an inverted range (`min > max`) with `InvalidSecurityZone`.
+
 ## 0.8.0
 
 ### Minor Changes

package/contracts/MockTaskManager.sol

@@ -16,6 +16,7 @@ error InvalidInputsAmount(string operation, uint256 got, uint256 expected);
 error InvalidOperationInputs(string operation);
 error TooManyInputs(string operation, uint256 got, uint256 maxAllowed);
 error InvalidBytesLength(uint256 got, uint256 expected);
+error LengthMismatch();
 // Type and security validation errors
 error InvalidTypeOrSecurityZone(string operation);
 error InvalidInputType(uint8 actual, uint8 expected);
@@ -158,10 +159,6 @@ library TMCommon {
     return uint256((SHIFTED_TYPE_MASK | SECURITY_ZONE_MASK) & hash);
   }
 
-  function isTriviallyEncryptedFromHash(uint256 hash) internal pure returns (bool) {
-    return (hash & TRIVIALLY_ENCRYPTED_MASK) == TRIVIALLY_ENCRYPTED_MASK;
-  }
-
   function computeDecryptResultHash(
     uint256 ctHash,
     uint256 result,
@@ -210,8 +207,17 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
   }
 
   function setSecurityZones(int32 minSZ, int32 maxSZ) external onlyOwner {
-    securityZoneMin = minSZ;
-    securityZoneMax = maxSZ;
+    _setSecurityZones(minSZ, maxSZ);
+  }
+
+  /// @dev Same check as the real task manager's `_setSecurityZones`, the one write path for the bounds.
+  ///      Without it `setSecurityZones(2, 1)` would be stored here while the real task manager reverts.
+  function _setSecurityZones(int32 newMin, int32 newMax) private {
+    if (newMin > newMax) {
+      revert InvalidSecurityZone(newMin, newMin, newMax);
+    }
+    securityZoneMin = newMin;
+    securityZoneMax = newMax;
   }
 
   function isInitialized() public view returns (bool) {
@@ -372,9 +378,7 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
   }
 
   function checkAllowed(uint256 ctHash) internal view {
-    if (!TMCommon.isTriviallyEncryptedFromHash(ctHash)) {
-      if (!acl.isAllowed(ctHash, msg.sender)) revert ACLNotAllowed(ctHash, msg.sender);
-    }
+    if (!acl.isAllowed(ctHash, msg.sender)) revert ACLNotAllowed(ctHash, msg.sender);
   }
 
   function isUnaryOperation(FunctionId funcId) internal pure returns (bool) {
@@ -575,12 +579,7 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
   /// @notice Publish a signed decrypt result to the chain
   /// @dev Anyone with a valid signature from the decrypt network can call this
   function publishDecryptResult(uint256 ctHash, uint256 result, bytes calldata signature) external {
-    _verifyDecryptResult(ctHash, result, signature, true);
-    _decryptResultReady[ctHash] = true;
-    _decryptResult[ctHash] = result;
-
-    _decryptResultReadyTimestamp[ctHash] = uint64(block.timestamp);
-    emit DecryptionResult(ctHash, result, msg.sender);
+    _publishDecryptResult(ctHash, result, signature);
   }
 
   function publishDecryptResultBatch(
@@ -588,14 +587,25 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
     uint256[] calldata results,
     bytes[] calldata signatures
   ) external {
-    // Mock implementation: process each result individually
-    // Note: publishDecryptResult is defined later in the contract
-    for (uint256 i = 0; i < ctHashes.length; i++) {
-      // Call via external interface to avoid forward reference issue
-      this.publishDecryptResult(ctHashes[i], results[i], signatures[i]);
+    uint256 length = ctHashes.length;
+    if (results.length != length || signatures.length != length) revert LengthMismatch();
+
+    for (uint256 i = 0; i < length; i++) {
+      _publishDecryptResult(ctHashes[i], results[i], signatures[i]);
     }
   }
 
+  /// @dev Shared by both publish functions, so a batch keeps its caller as the `DecryptionResult` requestor,
+  ///      like the real task manager. An external self-call would make the requestor this contract.
+  function _publishDecryptResult(uint256 ctHash, uint256 result, bytes calldata signature) private {
+    _verifyDecryptResult(ctHash, result, signature, true);
+    _decryptResultReady[ctHash] = true;
+    _decryptResult[ctHash] = result;
+
+    _decryptResultReadyTimestamp[ctHash] = uint64(block.timestamp);
+    emit DecryptionResult(ctHash, result, msg.sender);
+  }
+
   function verifyDecryptResult(uint256 ctHash, uint256 result, bytes calldata signature) external view returns (bool) {
     return _verifyDecryptResult(ctHash, result, signature, true);
   }
@@ -688,47 +698,36 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
   }
 
   function allow(uint256 ctHash, address account) external {
-    if (!TMCommon.isTriviallyEncryptedFromHash(ctHash)) {
-      acl.allow(ctHash, account, msg.sender);
+    acl.allow(ctHash, account, msg.sender);
 
-      // NOTE: MOCK
-      MOCK_trackedLogAllow(account == msg.sender ? 'FHE.allowThis' : 'FHE.allow', ctHash, account);
-    }
+    // NOTE: MOCK
+    MOCK_trackedLogAllow(account == msg.sender ? 'FHE.allowThis' : 'FHE.allow', ctHash, account);
   }
 
   function allowGlobal(uint256 ctHash) external {
-    if (!TMCommon.isTriviallyEncryptedFromHash(ctHash)) {
-      acl.allowGlobal(ctHash, msg.sender);
+    acl.allowGlobal(ctHash, msg.sender);
 
-      // NOTE: MOCK
-      MOCK_trackedLogAllow('FHE.allowGlobal', ctHash, msg.sender);
-    }
+    // NOTE: MOCK
+    MOCK_trackedLogAllow('FHE.allowGlobal', ctHash, msg.sender);
   }
 
   function allowTransient(uint256 ctHash, address account) external {
-    if (!TMCommon.isTriviallyEncryptedFromHash(ctHash)) {
-      acl.allowTransient(ctHash, account, msg.sender);
+    acl.allowTransient(ctHash, account, msg.sender);
 
-      // NOTE: MOCK
-      MOCK_trackedLogAllow('FHE.allowTransient', ctHash, account);
-    }
+    // NOTE: MOCK
+    MOCK_trackedLogAllow('FHE.allowTransient', ctHash, account);
   }
 
   function allowForDecryption(uint256 ctHash) external {
-    if (!TMCommon.isTriviallyEncryptedFromHash(ctHash)) {
-      uint256[] memory hashes = new uint256[](1);
-      hashes[0] = ctHash;
-      acl.allowForDecryption(hashes, msg.sender);
+    uint256[] memory hashes = new uint256[](1);
+    hashes[0] = ctHash;
+    acl.allowForDecryption(hashes, msg.sender);
 
-      // NOTE: MOCK
-      MOCK_trackedLogAllow('FHE.allowForDecryption', ctHash, msg.sender);
-    }
+    // NOTE: MOCK
+    MOCK_trackedLogAllow('FHE.allowForDecryption', ctHash, msg.sender);
   }
 
   function isAllowed(uint256 ctHash, address account) external view returns (bool) {
-    if (TMCommon.isTriviallyEncryptedFromHash(ctHash)) {
-      return true;
-    }
     return acl.isAllowed(ctHash, account);
   }
 
@@ -800,17 +799,11 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
   }
 
   function setSecurityZoneMax(int32 securityZone) external onlyOwner {
-    if (securityZone < securityZoneMin) {
-      revert InvalidSecurityZone(securityZone, securityZoneMin, securityZoneMax);
-    }
-    securityZoneMax = securityZone;
+    _setSecurityZones(securityZoneMin, securityZone);
   }
 
   function setSecurityZoneMin(int32 securityZone) external onlyOwner {
-    if (securityZone > securityZoneMax) {
-      revert InvalidSecurityZone(securityZone, securityZoneMin, securityZoneMax);
-    }
-    securityZoneMin = securityZone;
+    _setSecurityZones(securityZone, securityZoneMax);
   }
 
   function setACLContract(address _aclAddress) external onlyOwner {
@@ -891,7 +884,10 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
     uint256[] calldata results,
     bytes[] calldata signatures
   ) external view returns (bool) {
-    for (uint256 i = 0; i < ctHashes.length; i++) {
+    uint256 length = ctHashes.length;
+    if (results.length != length || signatures.length != length) revert LengthMismatch();
+
+    for (uint256 i = 0; i < length; i++) {
       if (!_verifyDecryptResult(ctHashes[i], results[i], signatures[i], true)) {
         return false;
       }
@@ -904,8 +900,11 @@ contract MockTaskManager is ITaskManager, MockCoFHE {
     uint256[] calldata results,
     bytes[] calldata signatures
   ) external view returns (bool[] memory) {
-    bool[] memory out = new bool[](ctHashes.length);
-    for (uint256 i = 0; i < ctHashes.length; i++) {
+    uint256 length = ctHashes.length;
+    if (results.length != length || signatures.length != length) revert LengthMismatch();
+
+    bool[] memory out = new bool[](length);
+    for (uint256 i = 0; i < length; i++) {
       out[i] = _verifyDecryptResult(ctHashes[i], results[i], signatures[i], false);
     }
     return out;

package/dist/index.d.mts

@@ -1101,6 +1101,10 @@ declare const MockTaskManagerArtifact: {
             readonly type: "string";
             readonly internalType: "string";
         }];
+    }, {
+        readonly type: "error";
+        readonly name: "LengthMismatch";
+        readonly inputs: readonly [];
     }, {
         readonly type: "error";
         readonly name: "OnlyAggregatorAllowed";

package/dist/index.d.ts

@@ -1101,6 +1101,10 @@ declare const MockTaskManagerArtifact: {
             readonly type: "string";
             readonly internalType: "string";
         }];
+    }, {
+        readonly type: "error";
+        readonly name: "LengthMismatch";
+        readonly inputs: readonly [];
     }, {
         readonly type: "error";
         readonly name: "OnlyAggregatorAllowed";

package/dist/index.js

@@ -1425,6 +1425,11 @@ var MockTaskManagerArtifact = {
         }
       ]
     },
+    {
+      type: "error",
+      name: "LengthMismatch",
+      inputs: []
+    },
     {
       type: "error",
       name: "OnlyAggregatorAllowed",