@iexec-nox/nox-protocol-contracts 0.1.0-beta.5 → 0.1.0-beta.7

package/README.md

@@ -55,6 +55,14 @@ The default network is a local EDR simulation. For external networks, configure
 pnpm run deploy
 ```
 
+## Verify
+
+Verify deployed contracts on Etherscan. Requires `ETHERSCAN_API_KEY`
+
+```bash
+pnpm run verify arbitrumSepolia --network arbitrumSepolia
+```
+
 ## Configuration notes
 
 - Create2 salt is defined in [config/config.ts](config/config.ts).

package/contracts/interfaces/INoxCompute.sol

@@ -19,6 +19,7 @@ interface INoxCompute {
     error InvalidProof(bytes proof, string reason);
     error UnsupportedType();
     error IncompatibleTypes();
+    error NotPubliclyDecryptable(bytes32 handle);
 
     /// Emitted when admin role is granted
     event Allowed(address indexed sender, address indexed account, bytes32 indexed handle);
@@ -110,6 +111,20 @@ interface INoxCompute {
         bytes32 success,
         bytes32 result
     );
+    event SafeMul(
+        address indexed caller,
+        bytes32 leftHandOperand,
+        bytes32 rightHandOperand,
+        bytes32 success,
+        bytes32 result
+    );
+    event SafeDiv(
+        address indexed caller,
+        bytes32 numerator,
+        bytes32 denominator,
+        bytes32 success,
+        bytes32 result
+    );
     event Select(
         address indexed caller,
         bytes32 condition,
@@ -153,6 +168,8 @@ interface INoxCompute {
         Div,
         SafeAdd,
         SafeSub,
+        SafeMul,
+        SafeDiv,
         Select,
         Eq,
         Ne,
@@ -252,19 +269,30 @@ interface INoxCompute {
     function plaintextToEncrypted(bytes32 value, TEEType teeType) external returns (bytes32);
 
     /**
-     * @notice Validates a handle proof for a given owner and type.
+     * @notice Validates an input handle proof for a given owner and type.
      * @param handle handle to validate
      * @param owner owner of the provided handle
      * @param proof proof data
      * @param teeType expected handle type
      */
-    function validateProof(
+    function validateInputProof(
         bytes32 handle,
         address owner,
         bytes calldata proof,
         TEEType teeType
     ) external;
 
+    /**
+     * @notice Validates a decryption proof issued by the gateway for a publicly decryptable handle.
+     * @param handle Handle to decrypt
+     * @param decryptionProof Serialized decryption proof (signature + decrypted value)
+     * @return The decrypted value (variable length)
+     */
+    function validateDecryptionProof(
+        bytes32 handle,
+        bytes calldata decryptionProof
+    ) external view returns (bytes memory);
+
     /**
      * @notice Performs an addition between two encrypted values without overflow check.
      * @param leftHandOperand Left-hand side operand handle
@@ -341,7 +369,37 @@ interface INoxCompute {
         bytes32 rightHandOperand
     ) external returns (bytes32 success, bytes32 result);
 
-    // TODO add safeMul and safeDiv
+    /**
+     * @notice Performs a multiplication between two encrypted values with overflow check.
+     * If the operation succeeds, the value of the success handle will be an encrypted
+     * `true` and the result handle's value will be the encrypted product.
+     * If the operation fails (e.g., due to overflow), the success handle will contain
+     * an encrypted `false` and the result handle will contain an encrypted `0`.
+     * @param leftHandOperand Left-hand side operand handle
+     * @param rightHandOperand Right-hand side operand handle
+     * @return success Whether the operation was successful
+     * @return result Result handle
+     */
+    function safeMul(
+        bytes32 leftHandOperand,
+        bytes32 rightHandOperand
+    ) external returns (bytes32 success, bytes32 result);
+
+    /**
+     * @notice Performs a division between two encrypted values with division-by-zero check.
+     * If the operation succeeds, the value of the success handle will be an encrypted
+     * `true` and the result handle's value will be the encrypted quotient.
+     * If the operation fails (e.g., due to division by zero), the success handle will contain
+     * an encrypted `false` and the result handle will contain an encrypted `0`.
+     * @param numerator Value to be divided
+     * @param denominator Value to divide by
+     * @return success Whether the operation was successful
+     * @return result Result handle
+     */
+    function safeDiv(
+        bytes32 numerator,
+        bytes32 denominator
+    ) external returns (bytes32 success, bytes32 result);
 
     /**
      * @notice Selects between two encrypted values based on a condition

package/contracts/sdk/Nox.sol

@@ -21,7 +21,7 @@ library Nox {
      *      Supports Arbitrum Mainnet (42161), Arbitrum Sepolia (421614), and local dev chains (31337),
      *      including local forks of each network.
      */
-    function noxComputeContract() public view returns (address) {
+    function noxComputeContract() internal view returns (address) {
         // Arbitrum mainnet or its fork
         if (block.chainid == 42161) {
             // TODO: Update after mainnet deployment.
@@ -29,16 +29,16 @@ library Nox {
         }
         // Arbitrum Sepolia or its fork
         if (block.chainid == 421614) {
-            return 0x5633472D35E18464CA24Ab974954fB3b1B122eA6;
+            return 0xE4622fbFCd0bDd482775bBf5b3e72382C0D99208;
         }
         // Local development chain
         if (block.chainid == 31337) {
-            return 0x188D560Fd7F60f50e4c32a4484B1D0DC486714b3;
+            return 0x9bdef3F9fEc61eE7cDfE84BDE8398595c6E0b22d;
         }
         revert("Nox: Unsupported chain");
     }
 
-    function _noxComputeContract() internal view returns (INoxCompute) {
+    function _noxComputeContract() private view returns (INoxCompute) {
         return INoxCompute(noxComputeContract());
     }
 
@@ -119,19 +119,6 @@ library Nox {
             );
     }
 
-    /**
-     * @dev Convert a plaintext address to an encrypted address.
-     */
-    function toEaddress(address value) internal returns (eaddress) {
-        return
-            eaddress.wrap(
-                _noxComputeContract().plaintextToEncrypted(
-                    bytes32(uint256(uint160(value))),
-                    TEEType.Address
-                )
-            );
-    }
-
     /**
      * @dev Convert a plaintext value to an encrypted euint16 integer.
      */
@@ -182,7 +169,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (ebool) {
         bytes32 handle = externalEbool.unwrap(externalHandle);
-        _noxComputeContract().validateProof(handle, msg.sender, handleProof, TEEType.Bool);
+        _noxComputeContract().validateInputProof(handle, msg.sender, handleProof, TEEType.Bool);
         return ebool.wrap(handle);
     }
 
@@ -191,7 +178,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (eaddress) {
         bytes32 handle = externalEaddress.unwrap(externalHandle);
-        _noxComputeContract().validateProof(handle, msg.sender, handleProof, TEEType.Address);
+        _noxComputeContract().validateInputProof(handle, msg.sender, handleProof, TEEType.Address);
         return eaddress.wrap(handle);
     }
 
@@ -200,7 +187,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (euint16) {
         bytes32 handle = externalEuint16.unwrap(externalHandle);
-        _noxComputeContract().validateProof(handle, msg.sender, handleProof, TEEType.Uint16);
+        _noxComputeContract().validateInputProof(handle, msg.sender, handleProof, TEEType.Uint16);
         return euint16.wrap(handle);
     }
 
@@ -209,7 +196,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (euint256) {
         bytes32 handle = externalEuint256.unwrap(externalHandle);
-        _noxComputeContract().validateProof(handle, msg.sender, handleProof, TEEType.Uint256);
+        _noxComputeContract().validateInputProof(handle, msg.sender, handleProof, TEEType.Uint256);
         return euint256.wrap(handle);
     }
 
@@ -218,7 +205,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (eint16) {
         bytes32 handle = externalEint16.unwrap(externalHandle);
-        _noxComputeContract().validateProof(handle, msg.sender, handleProof, TEEType.Int16);
+        _noxComputeContract().validateInputProof(handle, msg.sender, handleProof, TEEType.Int16);
         return eint16.wrap(handle);
     }
 
@@ -227,7 +214,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (eint256) {
         bytes32 handle = externalEint256.unwrap(externalHandle);
-        _noxComputeContract().validateProof(handle, msg.sender, handleProof, TEEType.Int256);
+        _noxComputeContract().validateInputProof(handle, msg.sender, handleProof, TEEType.Int256);
         return eint256.wrap(handle);
     }
 
@@ -337,7 +324,45 @@ library Nox {
         return (ebool.wrap(success), eint256.wrap(result));
     }
 
-    // TODO add safeMul and safeDiv.
+    function safeMul(euint16 a, euint16 b) internal returns (ebool, euint16) {
+        (bytes32 success, bytes32 result) = _safeMul(euint16.unwrap(a), euint16.unwrap(b));
+        return (ebool.wrap(success), euint16.wrap(result));
+    }
+
+    function safeMul(euint256 a, euint256 b) internal returns (ebool, euint256) {
+        (bytes32 success, bytes32 result) = _safeMul(euint256.unwrap(a), euint256.unwrap(b));
+        return (ebool.wrap(success), euint256.wrap(result));
+    }
+
+    function safeMul(eint16 a, eint16 b) internal returns (ebool, eint16) {
+        (bytes32 success, bytes32 result) = _safeMul(eint16.unwrap(a), eint16.unwrap(b));
+        return (ebool.wrap(success), eint16.wrap(result));
+    }
+
+    function safeMul(eint256 a, eint256 b) internal returns (ebool, eint256) {
+        (bytes32 success, bytes32 result) = _safeMul(eint256.unwrap(a), eint256.unwrap(b));
+        return (ebool.wrap(success), eint256.wrap(result));
+    }
+
+    function safeDiv(euint16 a, euint16 b) internal returns (ebool, euint16) {
+        (bytes32 success, bytes32 result) = _safeDiv(euint16.unwrap(a), euint16.unwrap(b));
+        return (ebool.wrap(success), euint16.wrap(result));
+    }
+
+    function safeDiv(euint256 a, euint256 b) internal returns (ebool, euint256) {
+        (bytes32 success, bytes32 result) = _safeDiv(euint256.unwrap(a), euint256.unwrap(b));
+        return (ebool.wrap(success), euint256.wrap(result));
+    }
+
+    function safeDiv(eint16 a, eint16 b) internal returns (ebool, eint16) {
+        (bytes32 success, bytes32 result) = _safeDiv(eint16.unwrap(a), eint16.unwrap(b));
+        return (ebool.wrap(success), eint16.wrap(result));
+    }
+
+    function safeDiv(eint256 a, eint256 b) internal returns (ebool, eint256) {
+        (bytes32 success, bytes32 result) = _safeDiv(eint256.unwrap(a), eint256.unwrap(b));
+        return (ebool.wrap(success), eint256.wrap(result));
+    }
 
     function select(ebool condition, euint16 ifTrue, euint16 ifFalse) internal returns (euint16) {
         return
@@ -871,6 +896,86 @@ library Nox {
         return _noxComputeContract().isPubliclyDecryptable(eint256.unwrap(handle));
     }
 
+    // ============ Public decryption proof verification ============
+
+    /**
+     * @dev Verifies a decryption proof and returns the decrypted boolean value.
+     */
+    function publicDecrypt(ebool handle, bytes calldata decryptionProof) internal returns (bool) {
+        bytes memory result = _noxComputeContract().validateDecryptionProof(
+            ebool.unwrap(handle),
+            decryptionProof
+        );
+        return abi.decode(result, (bool));
+    }
+
+    /**
+     * @dev Verifies a decryption proof and returns the decrypted address value.
+     */
+    function publicDecrypt(
+        eaddress handle,
+        bytes calldata decryptionProof
+    ) internal returns (address) {
+        bytes memory result = _noxComputeContract().validateDecryptionProof(
+            eaddress.unwrap(handle),
+            decryptionProof
+        );
+        return abi.decode(result, (address));
+    }
+
+    /**
+     * @dev Verifies a decryption proof and returns the decrypted uint16 value.
+     */
+    function publicDecrypt(
+        euint16 handle,
+        bytes calldata decryptionProof
+    ) internal returns (uint16) {
+        bytes memory result = _noxComputeContract().validateDecryptionProof(
+            euint16.unwrap(handle),
+            decryptionProof
+        );
+        return abi.decode(result, (uint16));
+    }
+
+    /**
+     * @dev Verifies a decryption proof and returns the decrypted uint256 value.
+     */
+    function publicDecrypt(
+        euint256 handle,
+        bytes calldata decryptionProof
+    ) internal returns (uint256) {
+        bytes memory result = _noxComputeContract().validateDecryptionProof(
+            euint256.unwrap(handle),
+            decryptionProof
+        );
+        return abi.decode(result, (uint256));
+    }
+
+    /**
+     * @dev Verifies a decryption proof and returns the decrypted int16 value.
+     */
+    function publicDecrypt(eint16 handle, bytes calldata decryptionProof) internal returns (int16) {
+        bytes memory result = _noxComputeContract().validateDecryptionProof(
+            eint16.unwrap(handle),
+            decryptionProof
+        );
+        return abi.decode(result, (int16));
+    }
+
+    /**
+     * @dev Verifies a decryption proof and returns the decrypted int256 value.
+     */
+    function publicDecrypt(
+        eint256 handle,
+        bytes calldata decryptionProof
+    ) internal returns (int256) {
+        bytes memory result = _noxComputeContract().validateDecryptionProof(
+            eint256.unwrap(handle),
+            decryptionProof
+        );
+        return abi.decode(result, (int256));
+    }
+
     // ============ Private helpers ============
 
     function _assertInitialized(bytes32 handle) private pure {
@@ -913,6 +1018,18 @@ library Nox {
         return _noxComputeContract().safeSub(a, b);
     }
 
+    function _safeMul(bytes32 a, bytes32 b) private returns (bytes32, bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _noxComputeContract().safeMul(a, b);
+    }
+
+    function _safeDiv(bytes32 a, bytes32 b) private returns (bytes32, bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _noxComputeContract().safeDiv(a, b);
+    }
+
     function _select(bytes32 condition, bytes32 ifTrue, bytes32 ifFalse) private returns (bytes32) {
         _assertInitialized(condition);
         _assertInitialized(ifTrue);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iexec-nox/nox-protocol-contracts",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.7",
   "description": "Nox protocol smart contracts",
   "keywords": [
     "Nox",
@@ -26,6 +26,7 @@
     "set-gateway": "pnpm hardhat run scripts/set-gateway.ts",
     "set-kms-public-key": "pnpm hardhat run scripts/set-kms-public-key.ts",
     "upgrade": "pnpm hardhat run scripts/upgrade.ts",
+    "verify": "pnpm hardhat ignition verify",
     "format": "pnpm prettier --write .",
     "format:check": "pnpm prettier --check ."
   },
@@ -35,22 +36,22 @@
     ]
   },
   "dependencies": {
-    "@openzeppelin/contracts": "^5.4.0",
-    "@openzeppelin/contracts-upgradeable": "^5.4.0",
+    "@openzeppelin/contracts": "^5.6.1",
+    "@openzeppelin/contracts-upgradeable": "^5.6.1",
     "encrypted-types": "^0.0.4"
   },
   "devDependencies": {
-    "@nomicfoundation/hardhat-ignition": "^3.0.6",
-    "@nomicfoundation/hardhat-toolbox-viem": "^5.0.1",
-    "@types/node": "^22.8.5",
+    "@nomicfoundation/hardhat-ignition": "^3.0.9",
+    "@nomicfoundation/hardhat-toolbox-viem": "^5.0.2",
+    "@types/node": "^22.19.13",
     "forge-std": "github:foundry-rs/forge-std#v1.9.4",
-    "hardhat": "^3.1.10",
+    "hardhat": "^3.1.11",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.7",
-    "prettier": "^3.7.4",
+    "lint-staged": "^16.3.1",
+    "prettier": "^3.8.1",
     "prettier-plugin-solidity": "^2.2.1",
-    "typescript": "~5.8.0",
-    "viem": "^2.30.0"
+    "typescript": "^5.9.3",
+    "viem": "^2.46.3"
   },
   "homepage": "https://github.com/iExec-Nox/nox-protocol-contracts#readme",
   "repository": {