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

package/contracts/interfaces/INoxCompute.sol

@@ -110,6 +110,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 +167,8 @@ interface INoxCompute {
         Div,
         SafeAdd,
         SafeSub,
+        SafeMul,
+        SafeDiv,
         Select,
         Eq,
         Ne,
@@ -341,7 +357,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.
@@ -33,12 +33,12 @@ library Nox {
         }
         // Local development chain
         if (block.chainid == 31337) {
-            return 0x188D560Fd7F60f50e4c32a4484B1D0DC486714b3;
+            return 0x9cF45FFE48126380cFCC40215a1d6D7fffbffb05;
         }
         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.
      */
@@ -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
@@ -913,6 +938,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.6",
   "description": "Nox protocol smart contracts",
   "keywords": [
     "Nox",
@@ -40,17 +40,17 @@
     "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.8",
+    "@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",
     "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": {