@iexec-nox/nox-protocol-contracts 0.1.0-beta.2 → 0.1.0-beta.4

package/contracts/sdk/Nox.sol

@@ -11,18 +11,57 @@ import "encrypted-types/EncryptedTypes.sol";
  * @notice Library providing convenient functions for TEE confidential computations.
  * @dev If an invalid or non-existent handle is passed to any function in the Nox protocol,
  *      the transaction will revert as it will not be recognized by the ACL.
- *
- *      NOX_COMPUTE and ACL are deterministic across all EVM chains using the CreateX factory.
- *      These addresses are derived from the CREATE2 salt configured in hardhat.config.ts.
- *
- *      IMPORTANT: If a fresh deployment is performed (not an upgrade), the proxy addresses will change.
- *      In that case, update these constants with the new deployed addresses.
  */
 library Nox {
-    // TODO: Update these addresses after deploying with the production salt.
-    INoxCompute internal constant NOX_COMPUTE =
-        INoxCompute(0x463Bdd46031353138713a47D7056F7c85024a4A6);
-    IACL internal constant ACL = IACL(0x3219A802B61028Fc29848863268FE17d750E5701);
+    // ============ Errors ============
+
+    error UninitializedHandle();
+
+    // ============ Internal address resolution ============
+
+    /**
+     * @dev Returns the NoxCompute contract address for the current chain.
+     *      Supports Arbitrum Mainnet (42161), Arbitrum Sepolia (421614), and local dev chains (31337),
+     *      including local forks of each network.
+     */
+    function _compute() internal view returns (INoxCompute) {
+        // Arbitrum mainnet or its fork
+        if (block.chainid == 42161) {
+            // TODO: Update after mainnet deployment.
+            return INoxCompute(address(0));
+        }
+        // Arbitrum Sepolia or its fork
+        if (block.chainid == 421614) {
+            return INoxCompute(0xd2856C55447FBb45c85a4C484796fe690981B069);
+        }
+        // Local development chain
+        if (block.chainid == 31337) {
+            return INoxCompute(0x463Bdd46031353138713a47D7056F7c85024a4A6);
+        }
+        revert("Nox: Unsupported chain");
+    }
+
+    /**
+     * @dev Returns the ACL contract address for the current chain.
+     *      Supports Arbitrum Mainnet (42161), Arbitrum Sepolia (421614), and local dev chains (31337),
+     *      including local forks of each network.
+     */
+    function _acl() internal view returns (IACL) {
+        // Arbitrum mainnet or its fork
+        if (block.chainid == 42161) {
+            // TODO: Update after mainnet deployment.
+            return IACL(address(0));
+        }
+        // Arbitrum Sepolia or its fork
+        if (block.chainid == 421614) {
+            return IACL(0xDC91Ec3F965F2F5F143DbBfcC92cC1340857D3d1);
+        }
+        // Local development chain
+        if (block.chainid == 31337) {
+            return IACL(0x3219A802B61028Fc29848863268FE17d750E5701);
+        }
+        revert("Nox: Unsupported chain");
+    }
 
     // =========== Handle initialization checks ============
 
@@ -94,7 +133,7 @@ library Nox {
     function toEbool(bool value) internal returns (ebool) {
         return
             ebool.wrap(
-                NOX_COMPUTE.plaintextToEncrypted(bytes32(uint256(value ? 1 : 0)), TEEType.Bool)
+                _compute().plaintextToEncrypted(bytes32(uint256(value ? 1 : 0)), TEEType.Bool)
             );
     }
 
@@ -104,7 +143,7 @@ library Nox {
     function toEaddress(address value) internal returns (eaddress) {
         return
             eaddress.wrap(
-                NOX_COMPUTE.plaintextToEncrypted(bytes32(uint256(uint160(value))), TEEType.Address)
+                _compute().plaintextToEncrypted(bytes32(uint256(uint160(value))), TEEType.Address)
             );
     }
 
@@ -113,14 +152,14 @@ library Nox {
      */
     function toEuint16(uint16 value) internal returns (euint16) {
         return
-            euint16.wrap(NOX_COMPUTE.plaintextToEncrypted(bytes32(uint256(value)), TEEType.Uint16));
+            euint16.wrap(_compute().plaintextToEncrypted(bytes32(uint256(value)), TEEType.Uint16));
     }
 
     /**
      * @dev Convert a plaintext value to an encrypted euint256 integer.
      */
     function toEuint256(uint256 value) internal returns (euint256) {
-        return euint256.wrap(NOX_COMPUTE.plaintextToEncrypted(bytes32(value), TEEType.Uint256));
+        return euint256.wrap(_compute().plaintextToEncrypted(bytes32(value), TEEType.Uint256));
     }
 
     /**
@@ -129,7 +168,7 @@ library Nox {
     function toEint16(int16 value) internal returns (eint16) {
         return
             eint16.wrap(
-                NOX_COMPUTE.plaintextToEncrypted(bytes32(uint256(uint16(value))), TEEType.Int16)
+                _compute().plaintextToEncrypted(bytes32(uint256(uint16(value))), TEEType.Int16)
             );
     }
 
@@ -138,7 +177,7 @@ library Nox {
      */
     function toEint256(int256 value) internal returns (eint256) {
         return
-            eint256.wrap(NOX_COMPUTE.plaintextToEncrypted(bytes32(uint256(value)), TEEType.Int256));
+            eint256.wrap(_compute().plaintextToEncrypted(bytes32(uint256(value)), TEEType.Int256));
     }
 
     // ============ Handle validation ============
@@ -148,7 +187,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (ebool) {
         bytes32 handle = externalEbool.unwrap(externalHandle);
-        NOX_COMPUTE.validateProof(handle, msg.sender, handleProof, TEEType.Bool);
+        _compute().validateProof(handle, msg.sender, handleProof, TEEType.Bool);
         return ebool.wrap(handle);
     }
 
@@ -157,7 +196,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (eaddress) {
         bytes32 handle = externalEaddress.unwrap(externalHandle);
-        NOX_COMPUTE.validateProof(handle, msg.sender, handleProof, TEEType.Address);
+        _compute().validateProof(handle, msg.sender, handleProof, TEEType.Address);
         return eaddress.wrap(handle);
     }
 
@@ -166,7 +205,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (euint16) {
         bytes32 handle = externalEuint16.unwrap(externalHandle);
-        NOX_COMPUTE.validateProof(handle, msg.sender, handleProof, TEEType.Uint16);
+        _compute().validateProof(handle, msg.sender, handleProof, TEEType.Uint16);
         return euint16.wrap(handle);
     }
 
@@ -175,7 +214,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (euint256) {
         bytes32 handle = externalEuint256.unwrap(externalHandle);
-        NOX_COMPUTE.validateProof(handle, msg.sender, handleProof, TEEType.Uint256);
+        _compute().validateProof(handle, msg.sender, handleProof, TEEType.Uint256);
         return euint256.wrap(handle);
     }
 
@@ -184,7 +223,7 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (eint16) {
         bytes32 handle = externalEint16.unwrap(externalHandle);
-        NOX_COMPUTE.validateProof(handle, msg.sender, handleProof, TEEType.Int16);
+        _compute().validateProof(handle, msg.sender, handleProof, TEEType.Int16);
         return eint16.wrap(handle);
     }
 
@@ -193,131 +232,113 @@ library Nox {
         bytes calldata handleProof
     ) internal returns (eint256) {
         bytes32 handle = externalEint256.unwrap(externalHandle);
-        NOX_COMPUTE.validateProof(handle, msg.sender, handleProof, TEEType.Int256);
+        _compute().validateProof(handle, msg.sender, handleProof, TEEType.Int256);
         return eint256.wrap(handle);
     }
 
     // ============ Arithmetic primitives ============
 
     function add(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(NOX_COMPUTE.add(euint16.unwrap(a), euint16.unwrap(b)));
+        return euint16.wrap(_add(euint16.unwrap(a), euint16.unwrap(b)));
     }
 
     function add(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(NOX_COMPUTE.add(euint256.unwrap(a), euint256.unwrap(b)));
+        return euint256.wrap(_add(euint256.unwrap(a), euint256.unwrap(b)));
     }
 
     function add(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(NOX_COMPUTE.add(eint16.unwrap(a), eint16.unwrap(b)));
+        return eint16.wrap(_add(eint16.unwrap(a), eint16.unwrap(b)));
     }
 
     function add(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(NOX_COMPUTE.add(eint256.unwrap(a), eint256.unwrap(b)));
+        return eint256.wrap(_add(eint256.unwrap(a), eint256.unwrap(b)));
     }
 
     function sub(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(NOX_COMPUTE.sub(euint16.unwrap(a), euint16.unwrap(b)));
+        return euint16.wrap(_sub(euint16.unwrap(a), euint16.unwrap(b)));
     }
 
     function sub(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(NOX_COMPUTE.sub(euint256.unwrap(a), euint256.unwrap(b)));
+        return euint256.wrap(_sub(euint256.unwrap(a), euint256.unwrap(b)));
     }
 
     function sub(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(NOX_COMPUTE.sub(eint16.unwrap(a), eint16.unwrap(b)));
+        return eint16.wrap(_sub(eint16.unwrap(a), eint16.unwrap(b)));
     }
 
     function sub(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(NOX_COMPUTE.sub(eint256.unwrap(a), eint256.unwrap(b)));
+        return eint256.wrap(_sub(eint256.unwrap(a), eint256.unwrap(b)));
     }
 
     function mul(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(NOX_COMPUTE.mul(euint16.unwrap(a), euint16.unwrap(b)));
+        return euint16.wrap(_mul(euint16.unwrap(a), euint16.unwrap(b)));
     }
 
     function mul(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(NOX_COMPUTE.mul(euint256.unwrap(a), euint256.unwrap(b)));
+        return euint256.wrap(_mul(euint256.unwrap(a), euint256.unwrap(b)));
     }
 
     function mul(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(NOX_COMPUTE.mul(eint16.unwrap(a), eint16.unwrap(b)));
+        return eint16.wrap(_mul(eint16.unwrap(a), eint16.unwrap(b)));
     }
 
     function mul(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(NOX_COMPUTE.mul(eint256.unwrap(a), eint256.unwrap(b)));
+        return eint256.wrap(_mul(eint256.unwrap(a), eint256.unwrap(b)));
     }
 
     function div(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(NOX_COMPUTE.div(euint16.unwrap(a), euint16.unwrap(b)));
+        return euint16.wrap(_div(euint16.unwrap(a), euint16.unwrap(b)));
     }
 
     function div(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(NOX_COMPUTE.div(euint256.unwrap(a), euint256.unwrap(b)));
+        return euint256.wrap(_div(euint256.unwrap(a), euint256.unwrap(b)));
     }
 
     function div(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(NOX_COMPUTE.div(eint16.unwrap(a), eint16.unwrap(b)));
+        return eint16.wrap(_div(eint16.unwrap(a), eint16.unwrap(b)));
     }
 
     function div(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(NOX_COMPUTE.div(eint256.unwrap(a), eint256.unwrap(b)));
+        return eint256.wrap(_div(eint256.unwrap(a), eint256.unwrap(b)));
     }
 
     function safeAdd(euint16 a, euint16 b) internal returns (ebool, euint16) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeAdd(
-            euint16.unwrap(a),
-            euint16.unwrap(b)
-        );
+        (bytes32 success, bytes32 result) = _safeAdd(euint16.unwrap(a), euint16.unwrap(b));
         return (ebool.wrap(success), euint16.wrap(result));
     }
 
     function safeAdd(euint256 a, euint256 b) internal returns (ebool, euint256) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeAdd(
-            euint256.unwrap(a),
-            euint256.unwrap(b)
-        );
+        (bytes32 success, bytes32 result) = _safeAdd(euint256.unwrap(a), euint256.unwrap(b));
         return (ebool.wrap(success), euint256.wrap(result));
     }
 
     function safeAdd(eint16 a, eint16 b) internal returns (ebool, eint16) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeAdd(eint16.unwrap(a), eint16.unwrap(b));
+        (bytes32 success, bytes32 result) = _safeAdd(eint16.unwrap(a), eint16.unwrap(b));
         return (ebool.wrap(success), eint16.wrap(result));
     }
 
     function safeAdd(eint256 a, eint256 b) internal returns (ebool, eint256) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeAdd(
-            eint256.unwrap(a),
-            eint256.unwrap(b)
-        );
+        (bytes32 success, bytes32 result) = _safeAdd(eint256.unwrap(a), eint256.unwrap(b));
         return (ebool.wrap(success), eint256.wrap(result));
     }
 
     function safeSub(euint16 a, euint16 b) internal returns (ebool, euint16) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeSub(
-            euint16.unwrap(a),
-            euint16.unwrap(b)
-        );
+        (bytes32 success, bytes32 result) = _safeSub(euint16.unwrap(a), euint16.unwrap(b));
         return (ebool.wrap(success), euint16.wrap(result));
     }
 
     function safeSub(euint256 a, euint256 b) internal returns (ebool, euint256) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeSub(
-            euint256.unwrap(a),
-            euint256.unwrap(b)
-        );
+        (bytes32 success, bytes32 result) = _safeSub(euint256.unwrap(a), euint256.unwrap(b));
         return (ebool.wrap(success), euint256.wrap(result));
     }
 
     function safeSub(eint16 a, eint16 b) internal returns (ebool, eint16) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeSub(eint16.unwrap(a), eint16.unwrap(b));
+        (bytes32 success, bytes32 result) = _safeSub(eint16.unwrap(a), eint16.unwrap(b));
         return (ebool.wrap(success), eint16.wrap(result));
     }
 
     function safeSub(eint256 a, eint256 b) internal returns (ebool, eint256) {
-        (bytes32 success, bytes32 result) = NOX_COMPUTE.safeSub(
-            eint256.unwrap(a),
-            eint256.unwrap(b)
-        );
+        (bytes32 success, bytes32 result) = _safeSub(eint256.unwrap(a), eint256.unwrap(b));
         return (ebool.wrap(success), eint256.wrap(result));
     }
 
@@ -326,11 +347,7 @@ library Nox {
     function select(ebool condition, euint16 ifTrue, euint16 ifFalse) internal returns (euint16) {
         return
             euint16.wrap(
-                NOX_COMPUTE.select(
-                    ebool.unwrap(condition),
-                    euint16.unwrap(ifTrue),
-                    euint16.unwrap(ifFalse)
-                )
+                _select(ebool.unwrap(condition), euint16.unwrap(ifTrue), euint16.unwrap(ifFalse))
             );
     }
 
@@ -341,204 +358,350 @@ library Nox {
     ) internal returns (euint256) {
         return
             euint256.wrap(
-                NOX_COMPUTE.select(
-                    ebool.unwrap(condition),
-                    euint256.unwrap(ifTrue),
-                    euint256.unwrap(ifFalse)
-                )
+                _select(ebool.unwrap(condition), euint256.unwrap(ifTrue), euint256.unwrap(ifFalse))
             );
     }
 
     function select(ebool condition, eint16 ifTrue, eint16 ifFalse) internal returns (eint16) {
         return
             eint16.wrap(
-                NOX_COMPUTE.select(
-                    ebool.unwrap(condition),
-                    eint16.unwrap(ifTrue),
-                    eint16.unwrap(ifFalse)
-                )
+                _select(ebool.unwrap(condition), eint16.unwrap(ifTrue), eint16.unwrap(ifFalse))
             );
     }
 
     function select(ebool condition, eint256 ifTrue, eint256 ifFalse) internal returns (eint256) {
         return
             eint256.wrap(
-                NOX_COMPUTE.select(
-                    ebool.unwrap(condition),
-                    eint256.unwrap(ifTrue),
-                    eint256.unwrap(ifFalse)
-                )
+                _select(ebool.unwrap(condition), eint256.unwrap(ifTrue), eint256.unwrap(ifFalse))
             );
     }
 
+    function eq(euint16 a, euint16 b) internal returns (ebool) {
+        return ebool.wrap(_eq(euint16.unwrap(a), euint16.unwrap(b)));
+    }
+
+    function eq(euint256 a, euint256 b) internal returns (ebool) {
+        return ebool.wrap(_eq(euint256.unwrap(a), euint256.unwrap(b)));
+    }
+
+    function eq(eint16 a, eint16 b) internal returns (ebool) {
+        return ebool.wrap(_eq(eint16.unwrap(a), eint16.unwrap(b)));
+    }
+
+    function eq(eint256 a, eint256 b) internal returns (ebool) {
+        return ebool.wrap(_eq(eint256.unwrap(a), eint256.unwrap(b)));
+    }
+
+    function ne(euint16 a, euint16 b) internal returns (ebool) {
+        return ebool.wrap(_ne(euint16.unwrap(a), euint16.unwrap(b)));
+    }
+
+    function ne(euint256 a, euint256 b) internal returns (ebool) {
+        return ebool.wrap(_ne(euint256.unwrap(a), euint256.unwrap(b)));
+    }
+
+    function ne(eint16 a, eint16 b) internal returns (ebool) {
+        return ebool.wrap(_ne(eint16.unwrap(a), eint16.unwrap(b)));
+    }
+
+    function ne(eint256 a, eint256 b) internal returns (ebool) {
+        return ebool.wrap(_ne(eint256.unwrap(a), eint256.unwrap(b)));
+    }
+
+    function lt(euint16 a, euint16 b) internal returns (ebool) {
+        return ebool.wrap(_lt(euint16.unwrap(a), euint16.unwrap(b)));
+    }
+
+    function lt(euint256 a, euint256 b) internal returns (ebool) {
+        return ebool.wrap(_lt(euint256.unwrap(a), euint256.unwrap(b)));
+    }
+
+    function lt(eint16 a, eint16 b) internal returns (ebool) {
+        return ebool.wrap(_lt(eint16.unwrap(a), eint16.unwrap(b)));
+    }
+
+    function lt(eint256 a, eint256 b) internal returns (ebool) {
+        return ebool.wrap(_lt(eint256.unwrap(a), eint256.unwrap(b)));
+    }
+
+    function le(euint16 a, euint16 b) internal returns (ebool) {
+        return ebool.wrap(_le(euint16.unwrap(a), euint16.unwrap(b)));
+    }
+
+    function le(euint256 a, euint256 b) internal returns (ebool) {
+        return ebool.wrap(_le(euint256.unwrap(a), euint256.unwrap(b)));
+    }
+
+    function le(eint16 a, eint16 b) internal returns (ebool) {
+        return ebool.wrap(_le(eint16.unwrap(a), eint16.unwrap(b)));
+    }
+
+    function le(eint256 a, eint256 b) internal returns (ebool) {
+        return ebool.wrap(_le(eint256.unwrap(a), eint256.unwrap(b)));
+    }
+
+    function gt(euint16 a, euint16 b) internal returns (ebool) {
+        return ebool.wrap(_gt(euint16.unwrap(a), euint16.unwrap(b)));
+    }
+
+    function gt(euint256 a, euint256 b) internal returns (ebool) {
+        return ebool.wrap(_gt(euint256.unwrap(a), euint256.unwrap(b)));
+    }
+
+    function gt(eint16 a, eint16 b) internal returns (ebool) {
+        return ebool.wrap(_gt(eint16.unwrap(a), eint16.unwrap(b)));
+    }
+
+    function gt(eint256 a, eint256 b) internal returns (ebool) {
+        return ebool.wrap(_gt(eint256.unwrap(a), eint256.unwrap(b)));
+    }
+
+    function ge(euint16 a, euint16 b) internal returns (ebool) {
+        return ebool.wrap(_ge(euint16.unwrap(a), euint16.unwrap(b)));
+    }
+
+    function ge(euint256 a, euint256 b) internal returns (ebool) {
+        return ebool.wrap(_ge(euint256.unwrap(a), euint256.unwrap(b)));
+    }
+
+    function ge(eint16 a, eint16 b) internal returns (ebool) {
+        return ebool.wrap(_ge(eint16.unwrap(a), eint16.unwrap(b)));
+    }
+
+    function ge(eint256 a, eint256 b) internal returns (ebool) {
+        return ebool.wrap(_ge(eint256.unwrap(a), eint256.unwrap(b)));
+    }
+
+    // ============ ADVANCED FUNCTIONS ============
+
+    /**
+     * @dev Atomically transfers `amount` from `balanceFrom` to `balanceTo`.
+     * Returns the new balances and whether the transfer was successful.
+     * The transfer will fail if `balanceFrom < amount`.
+     */
+    function transfer(
+        euint256 balanceFrom,
+        euint256 balanceTo,
+        euint256 amount
+    ) internal returns (ebool success, euint256 newBalanceFrom, euint256 newBalanceTo) {
+        (bytes32 _success, bytes32 _newBalanceFrom, bytes32 _newBalanceTo) = _transfer(
+            euint256.unwrap(balanceFrom),
+            euint256.unwrap(balanceTo),
+            euint256.unwrap(amount)
+        );
+        success = ebool.wrap(_success);
+        newBalanceFrom = euint256.wrap(_newBalanceFrom);
+        newBalanceTo = euint256.wrap(_newBalanceTo);
+    }
+
+    /**
+     * @dev Atomically mints `amount` to `balanceTo` and increases `totalSupply` by `amount`.
+     * Returns the new balance, new total supply, and whether the mint was successful.
+     * The mint will fail if `totalSupply + amount` overflows.
+     */
+    function mint(
+        euint256 balanceTo,
+        euint256 amount,
+        euint256 totalSupply
+    ) internal returns (ebool success, euint256 newBalanceTo, euint256 newTotalSupply) {
+        (bytes32 _success, bytes32 _newBalanceTo, bytes32 _newTotalSupply) = _mint(
+            euint256.unwrap(balanceTo),
+            euint256.unwrap(amount),
+            euint256.unwrap(totalSupply)
+        );
+        success = ebool.wrap(_success);
+        newBalanceTo = euint256.wrap(_newBalanceTo);
+        newTotalSupply = euint256.wrap(_newTotalSupply);
+    }
+
+    /**
+     * @dev Atomically burns `amount` from `balanceFrom` and decreases `totalSupply` by `amount`.
+     * Returns the new balance, new total supply, and whether the burn was successful.
+     * The burn will fail if `balanceFrom < amount`.
+     */
+    function burn(
+        euint256 balanceFrom,
+        euint256 amount,
+        euint256 totalSupply
+    ) internal returns (ebool success, euint256 newBalanceFrom, euint256 newTotalSupply) {
+        (bytes32 _success, bytes32 _newBalanceFrom, bytes32 _newTotalSupply) = _burn(
+            euint256.unwrap(balanceFrom),
+            euint256.unwrap(amount),
+            euint256.unwrap(totalSupply)
+        );
+        success = ebool.wrap(_success);
+        newBalanceFrom = euint256.wrap(_newBalanceFrom);
+        newTotalSupply = euint256.wrap(_newTotalSupply);
+    }
+
     // ============ PERMISSION MANAGEMENT ============
 
     /**
      * @dev Allows the use of value for the address account.
      */
     function allow(ebool value, address account) internal {
-        ACL.allow(ebool.unwrap(value), account);
+        _acl().allow(ebool.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value for the address account.
      */
     function allow(eaddress value, address account) internal {
-        ACL.allow(eaddress.unwrap(value), account);
+        _acl().allow(eaddress.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value for the address account.
      */
     function allow(euint16 value, address account) internal {
-        ACL.allow(euint16.unwrap(value), account);
+        _acl().allow(euint16.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value for the address account.
      */
     function allow(euint256 value, address account) internal {
-        ACL.allow(euint256.unwrap(value), account);
+        _acl().allow(euint256.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value for the address account.
      */
     function allow(eint16 value, address account) internal {
-        ACL.allow(eint16.unwrap(value), account);
+        _acl().allow(eint16.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value for the address account.
      */
     function allow(eint256 value, address account) internal {
-        ACL.allow(eint256.unwrap(value), account);
+        _acl().allow(eint256.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value for this address (address(this)).
      */
     function allowThis(ebool value) internal {
-        ACL.allow(ebool.unwrap(value), address(this));
+        _acl().allow(ebool.unwrap(value), address(this));
     }
 
     /**
      * @dev Allows the use of value for this address (address(this)).
      */
     function allowThis(eaddress value) internal {
-        ACL.allow(eaddress.unwrap(value), address(this));
+        _acl().allow(eaddress.unwrap(value), address(this));
     }
 
     /**
      * @dev Allows the use of value for this address (address(this)).
      */
     function allowThis(euint16 value) internal {
-        ACL.allow(euint16.unwrap(value), address(this));
+        _acl().allow(euint16.unwrap(value), address(this));
     }
 
     /**
      * @dev Allows the use of value for this address (address(this)).
      */
     function allowThis(euint256 value) internal {
-        ACL.allow(euint256.unwrap(value), address(this));
+        _acl().allow(euint256.unwrap(value), address(this));
     }
 
     /**
      * @dev Allows the use of value for this address (address(this)).
      */
     function allowThis(eint16 value) internal {
-        ACL.allow(eint16.unwrap(value), address(this));
+        _acl().allow(eint16.unwrap(value), address(this));
     }
 
     /**
      * @dev Allows the use of value for this address (address(this)).
      */
     function allowThis(eint256 value) internal {
-        ACL.allow(eint256.unwrap(value), address(this));
+        _acl().allow(eint256.unwrap(value), address(this));
     }
 
     /**
      * @dev Allows the use of value by address account for this transaction.
      */
     function allowTransient(ebool value, address account) internal {
-        ACL.allowTransient(ebool.unwrap(value), account);
+        _acl().allowTransient(ebool.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value by address account for this transaction.
      */
     function allowTransient(eaddress value, address account) internal {
-        ACL.allowTransient(eaddress.unwrap(value), account);
+        _acl().allowTransient(eaddress.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value by address account for this transaction.
      */
     function allowTransient(euint16 value, address account) internal {
-        ACL.allowTransient(euint16.unwrap(value), account);
+        _acl().allowTransient(euint16.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value by address account for this transaction.
      */
     function allowTransient(euint256 value, address account) internal {
-        ACL.allowTransient(euint256.unwrap(value), account);
+        _acl().allowTransient(euint256.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value by address account for this transaction.
      */
     function allowTransient(eint16 value, address account) internal {
-        ACL.allowTransient(eint16.unwrap(value), account);
+        _acl().allowTransient(eint16.unwrap(value), account);
     }
 
     /**
      * @dev Allows the use of value by address account for this transaction.
      */
     function allowTransient(eint256 value, address account) internal {
-        ACL.allowTransient(eint256.unwrap(value), account);
+        _acl().allowTransient(eint256.unwrap(value), account);
     }
 
     /**
      * @dev Checks if the handle is allowed for the account.
      */
     function isAllowed(ebool handle, address account) internal view returns (bool) {
-        return ACL.isAllowed(ebool.unwrap(handle), account);
+        return _acl().isAllowed(ebool.unwrap(handle), account);
     }
 
     /**
      * @dev Checks if the handle is allowed for the account.
      */
     function isAllowed(eaddress handle, address account) internal view returns (bool) {
-        return ACL.isAllowed(eaddress.unwrap(handle), account);
+        return _acl().isAllowed(eaddress.unwrap(handle), account);
     }
 
     /**
      * @dev Checks if the handle is allowed for the account.
      */
     function isAllowed(euint16 handle, address account) internal view returns (bool) {
-        return ACL.isAllowed(euint16.unwrap(handle), account);
+        return _acl().isAllowed(euint16.unwrap(handle), account);
     }
 
     /**
      * @dev Checks if the handle is allowed for the account.
      */
     function isAllowed(euint256 handle, address account) internal view returns (bool) {
-        return ACL.isAllowed(euint256.unwrap(handle), account);
+        return _acl().isAllowed(euint256.unwrap(handle), account);
     }
 
     /**
      * @dev Checks if the handle is allowed for the account.
      */
     function isAllowed(eint16 handle, address account) internal view returns (bool) {
-        return ACL.isAllowed(eint16.unwrap(handle), account);
+        return _acl().isAllowed(eint16.unwrap(handle), account);
     }
 
     /**
      * @dev Checks if the handle is allowed for the account.
      */
     function isAllowed(eint256 handle, address account) internal view returns (bool) {
-        return ACL.isAllowed(eint256.unwrap(handle), account);
+        return _acl().isAllowed(eint256.unwrap(handle), account);
     }
 
     // ============ VIEWER MANAGEMENT ============
@@ -547,84 +710,84 @@ library Nox {
      * @dev Adds a viewer for an ebool handle.
      */
     function addViewer(ebool value, address viewer) internal {
-        ACL.addViewer(ebool.unwrap(value), viewer);
+        _acl().addViewer(ebool.unwrap(value), viewer);
     }
 
     /**
      * @dev Adds a viewer for an eaddress handle.
      */
     function addViewer(eaddress value, address viewer) internal {
-        ACL.addViewer(eaddress.unwrap(value), viewer);
+        _acl().addViewer(eaddress.unwrap(value), viewer);
     }
 
     /**
      * @dev Adds a viewer for an euint16 handle.
      */
     function addViewer(euint16 value, address viewer) internal {
-        ACL.addViewer(euint16.unwrap(value), viewer);
+        _acl().addViewer(euint16.unwrap(value), viewer);
     }
 
     /**
      * @dev Adds a viewer for an euint256 handle.
      */
     function addViewer(euint256 value, address viewer) internal {
-        ACL.addViewer(euint256.unwrap(value), viewer);
+        _acl().addViewer(euint256.unwrap(value), viewer);
     }
 
     /**
      * @dev Adds a viewer for an eint16 handle.
      */
     function addViewer(eint16 value, address viewer) internal {
-        ACL.addViewer(eint16.unwrap(value), viewer);
+        _acl().addViewer(eint16.unwrap(value), viewer);
     }
 
     /**
      * @dev Adds a viewer for an eint256 handle.
      */
     function addViewer(eint256 value, address viewer) internal {
-        ACL.addViewer(eint256.unwrap(value), viewer);
+        _acl().addViewer(eint256.unwrap(value), viewer);
     }
 
     /**
      * @dev Checks if the viewer can view the handle.
      */
     function isViewer(ebool handle, address viewer) internal view returns (bool) {
-        return ACL.isViewer(ebool.unwrap(handle), viewer);
+        return _acl().isViewer(ebool.unwrap(handle), viewer);
     }
 
     /**
      * @dev Checks if the viewer can view the handle.
      */
     function isViewer(eaddress handle, address viewer) internal view returns (bool) {
-        return ACL.isViewer(eaddress.unwrap(handle), viewer);
+        return _acl().isViewer(eaddress.unwrap(handle), viewer);
     }
 
     /**
      * @dev Checks if the viewer can view the handle.
      */
     function isViewer(euint16 handle, address viewer) internal view returns (bool) {
-        return ACL.isViewer(euint16.unwrap(handle), viewer);
+        return _acl().isViewer(euint16.unwrap(handle), viewer);
     }
 
     /**
      * @dev Checks if the viewer can view the handle.
      */
     function isViewer(euint256 handle, address viewer) internal view returns (bool) {
-        return ACL.isViewer(euint256.unwrap(handle), viewer);
+        return _acl().isViewer(euint256.unwrap(handle), viewer);
     }
 
     /**
      * @dev Checks if the viewer can view the handle.
      */
     function isViewer(eint16 handle, address viewer) internal view returns (bool) {
-        return ACL.isViewer(eint16.unwrap(handle), viewer);
+        return _acl().isViewer(eint16.unwrap(handle), viewer);
     }
 
     /**
      * @dev Checks if the viewer can view the handle.
      */
     function isViewer(eint256 handle, address viewer) internal view returns (bool) {
-        return ACL.isViewer(eint256.unwrap(handle), viewer);
+        return _acl().isViewer(eint256.unwrap(handle), viewer);
     }
 
     // ============ PUBLIC DECRYPTION ============
@@ -633,83 +796,201 @@ library Nox {
      * @dev Marks an ebool handle as publicly decryptable.
      */
     function allowPublicDecryption(ebool value) internal {
-        ACL.allowPublicDecryption(ebool.unwrap(value));
+        _acl().allowPublicDecryption(ebool.unwrap(value));
     }
 
     /**
      * @dev Marks an eaddress handle as publicly decryptable.
      */
     function allowPublicDecryption(eaddress value) internal {
-        ACL.allowPublicDecryption(eaddress.unwrap(value));
+        _acl().allowPublicDecryption(eaddress.unwrap(value));
     }
 
     /**
      * @dev Marks an euint16 handle as publicly decryptable.
      */
     function allowPublicDecryption(euint16 value) internal {
-        ACL.allowPublicDecryption(euint16.unwrap(value));
+        _acl().allowPublicDecryption(euint16.unwrap(value));
     }
 
     /**
      * @dev Marks an euint256 handle as publicly decryptable.
      */
     function allowPublicDecryption(euint256 value) internal {
-        ACL.allowPublicDecryption(euint256.unwrap(value));
+        _acl().allowPublicDecryption(euint256.unwrap(value));
     }
 
     /**
      * @dev Marks an eint16 handle as publicly decryptable.
      */
     function allowPublicDecryption(eint16 value) internal {
-        ACL.allowPublicDecryption(eint16.unwrap(value));
+        _acl().allowPublicDecryption(eint16.unwrap(value));
     }
 
     /**
      * @dev Marks an eint256 handle as publicly decryptable.
      */
     function allowPublicDecryption(eint256 value) internal {
-        ACL.allowPublicDecryption(eint256.unwrap(value));
+        _acl().allowPublicDecryption(eint256.unwrap(value));
     }
 
     /**
      * @dev Checks if the handle is publicly decryptable.
      */
     function isPubliclyDecryptable(ebool handle) internal view returns (bool) {
-        return ACL.isPubliclyDecryptable(ebool.unwrap(handle));
+        return _acl().isPubliclyDecryptable(ebool.unwrap(handle));
     }
 
     /**
      * @dev Checks if the handle is publicly decryptable.
      */
     function isPubliclyDecryptable(eaddress handle) internal view returns (bool) {
-        return ACL.isPubliclyDecryptable(eaddress.unwrap(handle));
+        return _acl().isPubliclyDecryptable(eaddress.unwrap(handle));
     }
 
     /**
      * @dev Checks if the handle is publicly decryptable.
      */
     function isPubliclyDecryptable(euint16 handle) internal view returns (bool) {
-        return ACL.isPubliclyDecryptable(euint16.unwrap(handle));
+        return _acl().isPubliclyDecryptable(euint16.unwrap(handle));
     }
 
     /**
      * @dev Checks if the handle is publicly decryptable.
      */
     function isPubliclyDecryptable(euint256 handle) internal view returns (bool) {
-        return ACL.isPubliclyDecryptable(euint256.unwrap(handle));
+        return _acl().isPubliclyDecryptable(euint256.unwrap(handle));
     }
 
     /**
      * @dev Checks if the handle is publicly decryptable.
      */
     function isPubliclyDecryptable(eint16 handle) internal view returns (bool) {
-        return ACL.isPubliclyDecryptable(eint16.unwrap(handle));
+        return _acl().isPubliclyDecryptable(eint16.unwrap(handle));
     }
 
     /**
      * @dev Checks if the handle is publicly decryptable.
      */
     function isPubliclyDecryptable(eint256 handle) internal view returns (bool) {
-        return ACL.isPubliclyDecryptable(eint256.unwrap(handle));
+        return _acl().isPubliclyDecryptable(eint256.unwrap(handle));
+    }
+
+    // ============ Private helpers ============
+
+    function _assertInitialized(bytes32 handle) private pure {
+        require(handle != bytes32(0), UninitializedHandle());
+    }
+
+    function _add(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().add(a, b);
+    }
+
+    function _sub(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().sub(a, b);
+    }
+
+    function _mul(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().mul(a, b);
+    }
+
+    function _div(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().div(a, b);
+    }
+
+    function _safeAdd(bytes32 a, bytes32 b) private returns (bytes32, bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().safeAdd(a, b);
+    }
+
+    function _safeSub(bytes32 a, bytes32 b) private returns (bytes32, bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().safeSub(a, b);
+    }
+
+    function _select(bytes32 condition, bytes32 ifTrue, bytes32 ifFalse) private returns (bytes32) {
+        _assertInitialized(condition);
+        _assertInitialized(ifTrue);
+        _assertInitialized(ifFalse);
+        return _compute().select(condition, ifTrue, ifFalse);
+    }
+
+    function _eq(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().eq(a, b);
+    }
+
+    function _ne(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().ne(a, b);
+    }
+
+    function _lt(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().lt(a, b);
+    }
+
+    function _le(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().le(a, b);
+    }
+
+    function _gt(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().gt(a, b);
+    }
+
+    function _ge(bytes32 a, bytes32 b) private returns (bytes32) {
+        _assertInitialized(a);
+        _assertInitialized(b);
+        return _compute().ge(a, b);
+    }
+
+    function _transfer(
+        bytes32 balanceFrom,
+        bytes32 balanceTo,
+        bytes32 amount
+    ) private returns (bytes32, bytes32, bytes32) {
+        _assertInitialized(balanceFrom);
+        _assertInitialized(balanceTo);
+        _assertInitialized(amount);
+        return _compute().transfer(balanceFrom, balanceTo, amount);
+    }
+
+    function _mint(
+        bytes32 balanceTo,
+        bytes32 amount,
+        bytes32 totalSupply
+    ) private returns (bytes32, bytes32, bytes32) {
+        _assertInitialized(balanceTo);
+        _assertInitialized(amount);
+        _assertInitialized(totalSupply);
+        return _compute().mint(balanceTo, amount, totalSupply);
+    }
+
+    function _burn(
+        bytes32 balanceFrom,
+        bytes32 amount,
+        bytes32 totalSupply
+    ) private returns (bytes32, bytes32, bytes32) {
+        _assertInitialized(balanceFrom);
+        _assertInitialized(amount);
+        _assertInitialized(totalSupply);
+        return _compute().burn(balanceFrom, amount, totalSupply);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iexec-nox/nox-protocol-contracts",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.4",
   "description": "Nox protocol smart contracts",
   "keywords": [
     "Nox",
@@ -24,6 +24,8 @@
     "deploy": "pnpm hardhat run scripts/deploy.ts",
     "set-gateway": "pnpm hardhat run scripts/set-gateway.ts",
     "set-kms-public-key": "pnpm hardhat run scripts/set-kms-public-key.ts",
+    "upgrade-acl": "pnpm hardhat run scripts/upgrade-acl.ts",
+    "upgrade-nox-compute": "pnpm hardhat run scripts/upgrade-nox-compute.ts",
     "format": "pnpm prettier --write .",
     "format:check": "pnpm prettier --check ."
   },