@iexec-nox/nox-protocol-contracts 0.1.0-beta.8 → 0.1.0

package/contracts/sdk/Nox.sol

@@ -1,6 +1,7 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.0;
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
 
+import {HandleUtils} from "../shared/HandleUtils.sol";
 import {TEEType, TypeUtils} from "../shared/TypeUtils.sol";
 import {INoxCompute} from "../interfaces/INoxCompute.sol";
 import "encrypted-types/EncryptedTypes.sol";
@@ -12,7 +13,7 @@ import "encrypted-types/EncryptedTypes.sol";
 library Nox {
     // ============ Errors ============
 
-    error UninitializedHandle();
+    error MalformedDecryptedData(bytes data);
 
     // ============ Address resolution ============
 
@@ -33,7 +34,7 @@ library Nox {
         }
         // Local development chain
         if (block.chainid == 31337) {
-            return 0x6cC89dEd8c25E1460fa8408099C8Ab5b902D8b6B;
+            return 0x39847AeBa923Cc7367d4684194091D022B3F8548;
         }
         revert("Nox: Unsupported chain");
     }
@@ -47,7 +48,7 @@ library Nox {
      * Public handles are already accessible by everyone and don't need ACL.
      */
     function _allowIfNotPublic(bytes32 handle, address account) private {
-        if (!TypeUtils.isPublicHandle(handle)) {
+        if (!HandleUtils.isPublicHandle(handle)) {
             _noxComputeContract().allow(handle, account);
         }
     }
@@ -57,7 +58,7 @@ library Nox {
      * Public handles are already accessible by everyone and don't need ACL.
      */
     function _allowTransientIfNotPublic(bytes32 handle, address account) private {
-        if (!TypeUtils.isPublicHandle(handle)) {
+        if (!HandleUtils.isPublicHandle(handle)) {
             _noxComputeContract().allowTransient(handle, account);
         }
     }
@@ -67,7 +68,7 @@ library Nox {
      * Public handles are already accessible by everyone and don't need ACL.
      */
     function _disallowTransientIfNotPublic(bytes32 handle, address account) private {
-        if (!TypeUtils.isPublicHandle(handle)) {
+        if (!HandleUtils.isPublicHandle(handle)) {
             _noxComputeContract().disallowTransient(handle, account);
         }
     }
@@ -251,153 +252,301 @@ library Nox {
     // ============ Arithmetic primitives ============
 
     function add(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(_add(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            euint16.wrap(
+                _noxComputeContract().add(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function add(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(_add(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            euint256.wrap(
+                _noxComputeContract().add(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function add(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(_add(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            eint16.wrap(
+                _noxComputeContract().add(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function add(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(_add(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            eint256.wrap(
+                _noxComputeContract().add(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function sub(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(_sub(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            euint16.wrap(
+                _noxComputeContract().sub(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function sub(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(_sub(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            euint256.wrap(
+                _noxComputeContract().sub(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function sub(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(_sub(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            eint16.wrap(
+                _noxComputeContract().sub(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function sub(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(_sub(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            eint256.wrap(
+                _noxComputeContract().sub(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function mul(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(_mul(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            euint16.wrap(
+                _noxComputeContract().mul(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function mul(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(_mul(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            euint256.wrap(
+                _noxComputeContract().mul(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function mul(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(_mul(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            eint16.wrap(
+                _noxComputeContract().mul(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function mul(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(_mul(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            eint256.wrap(
+                _noxComputeContract().mul(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function div(euint16 a, euint16 b) internal returns (euint16) {
-        return euint16.wrap(_div(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            euint16.wrap(
+                _noxComputeContract().div(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function div(euint256 a, euint256 b) internal returns (euint256) {
-        return euint256.wrap(_div(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            euint256.wrap(
+                _noxComputeContract().div(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function div(eint16 a, eint16 b) internal returns (eint16) {
-        return eint16.wrap(_div(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            eint16.wrap(
+                _noxComputeContract().div(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function div(eint256 a, eint256 b) internal returns (eint256) {
-        return eint256.wrap(_div(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            eint256.wrap(
+                _noxComputeContract().div(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function safeAdd(euint16 a, euint16 b) internal returns (ebool, euint16) {
-        (bytes32 success, bytes32 result) = _safeAdd(euint16.unwrap(a), euint16.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeAdd(
+            _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+            _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+        );
         return (ebool.wrap(success), euint16.wrap(result));
     }
 
     function safeAdd(euint256 a, euint256 b) internal returns (ebool, euint256) {
-        (bytes32 success, bytes32 result) = _safeAdd(euint256.unwrap(a), euint256.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeAdd(
+            _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+            _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+        );
         return (ebool.wrap(success), euint256.wrap(result));
     }
 
     function safeAdd(eint16 a, eint16 b) internal returns (ebool, eint16) {
-        (bytes32 success, bytes32 result) = _safeAdd(eint16.unwrap(a), eint16.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeAdd(
+            _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+            _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+        );
         return (ebool.wrap(success), eint16.wrap(result));
     }
 
     function safeAdd(eint256 a, eint256 b) internal returns (ebool, eint256) {
-        (bytes32 success, bytes32 result) = _safeAdd(eint256.unwrap(a), eint256.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeAdd(
+            _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+            _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+        );
         return (ebool.wrap(success), eint256.wrap(result));
     }
 
     function safeSub(euint16 a, euint16 b) internal returns (ebool, euint16) {
-        (bytes32 success, bytes32 result) = _safeSub(euint16.unwrap(a), euint16.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeSub(
+            _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+            _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+        );
         return (ebool.wrap(success), euint16.wrap(result));
     }
 
     function safeSub(euint256 a, euint256 b) internal returns (ebool, euint256) {
-        (bytes32 success, bytes32 result) = _safeSub(euint256.unwrap(a), euint256.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeSub(
+            _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+            _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+        );
         return (ebool.wrap(success), euint256.wrap(result));
     }
 
     function safeSub(eint16 a, eint16 b) internal returns (ebool, eint16) {
-        (bytes32 success, bytes32 result) = _safeSub(eint16.unwrap(a), eint16.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeSub(
+            _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+            _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+        );
         return (ebool.wrap(success), eint16.wrap(result));
     }
 
     function safeSub(eint256 a, eint256 b) internal returns (ebool, eint256) {
-        (bytes32 success, bytes32 result) = _safeSub(eint256.unwrap(a), eint256.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeSub(
+            _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+            _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+        );
         return (ebool.wrap(success), eint256.wrap(result));
     }
 
     function safeMul(euint16 a, euint16 b) internal returns (ebool, euint16) {
-        (bytes32 success, bytes32 result) = _safeMul(euint16.unwrap(a), euint16.unwrap(b));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeMul(
+            _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+            _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+        );
         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));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeMul(
+            _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+            _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+        );
         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));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeMul(
+            _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+            _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+        );
         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));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeMul(
+            _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+            _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+        );
         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));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeDiv(
+            _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+            _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+        );
         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));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeDiv(
+            _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+            _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+        );
         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));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeDiv(
+            _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+            _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+        );
         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));
+        (bytes32 success, bytes32 result) = _noxComputeContract().safeDiv(
+            _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+            _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+        );
         return (ebool.wrap(success), eint256.wrap(result));
     }
 
     function select(ebool condition, euint16 ifTrue, euint16 ifFalse) internal returns (euint16) {
         return
             euint16.wrap(
-                _select(ebool.unwrap(condition), euint16.unwrap(ifTrue), euint16.unwrap(ifFalse))
+                _noxComputeContract().select(
+                    _resolveUndefinedHandle(ebool.unwrap(condition), TEEType.Bool),
+                    _resolveUndefinedHandle(euint16.unwrap(ifTrue), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(ifFalse), TEEType.Uint16)
+                )
             );
     }
 
@@ -408,118 +557,274 @@ library Nox {
     ) internal returns (euint256) {
         return
             euint256.wrap(
-                _select(ebool.unwrap(condition), euint256.unwrap(ifTrue), euint256.unwrap(ifFalse))
+                _noxComputeContract().select(
+                    _resolveUndefinedHandle(ebool.unwrap(condition), TEEType.Bool),
+                    _resolveUndefinedHandle(euint256.unwrap(ifTrue), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(ifFalse), TEEType.Uint256)
+                )
             );
     }
 
     function select(ebool condition, eint16 ifTrue, eint16 ifFalse) internal returns (eint16) {
         return
             eint16.wrap(
-                _select(ebool.unwrap(condition), eint16.unwrap(ifTrue), eint16.unwrap(ifFalse))
+                _noxComputeContract().select(
+                    _resolveUndefinedHandle(ebool.unwrap(condition), TEEType.Bool),
+                    _resolveUndefinedHandle(eint16.unwrap(ifTrue), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(ifFalse), TEEType.Int16)
+                )
             );
     }
 
     function select(ebool condition, eint256 ifTrue, eint256 ifFalse) internal returns (eint256) {
         return
             eint256.wrap(
-                _select(ebool.unwrap(condition), eint256.unwrap(ifTrue), eint256.unwrap(ifFalse))
+                _noxComputeContract().select(
+                    _resolveUndefinedHandle(ebool.unwrap(condition), TEEType.Bool),
+                    _resolveUndefinedHandle(eint256.unwrap(ifTrue), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(ifFalse), TEEType.Int256)
+                )
             );
     }
 
     function eq(euint16 a, euint16 b) internal returns (ebool) {
-        return ebool.wrap(_eq(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().eq(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function eq(euint256 a, euint256 b) internal returns (ebool) {
-        return ebool.wrap(_eq(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().eq(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function eq(eint16 a, eint16 b) internal returns (ebool) {
-        return ebool.wrap(_eq(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().eq(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function eq(eint256 a, eint256 b) internal returns (ebool) {
-        return ebool.wrap(_eq(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().eq(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function ne(euint16 a, euint16 b) internal returns (ebool) {
-        return ebool.wrap(_ne(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ne(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function ne(euint256 a, euint256 b) internal returns (ebool) {
-        return ebool.wrap(_ne(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ne(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function ne(eint16 a, eint16 b) internal returns (ebool) {
-        return ebool.wrap(_ne(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ne(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function ne(eint256 a, eint256 b) internal returns (ebool) {
-        return ebool.wrap(_ne(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ne(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function lt(euint16 a, euint16 b) internal returns (ebool) {
-        return ebool.wrap(_lt(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().lt(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function lt(euint256 a, euint256 b) internal returns (ebool) {
-        return ebool.wrap(_lt(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().lt(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function lt(eint16 a, eint16 b) internal returns (ebool) {
-        return ebool.wrap(_lt(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().lt(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function lt(eint256 a, eint256 b) internal returns (ebool) {
-        return ebool.wrap(_lt(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().lt(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function le(euint16 a, euint16 b) internal returns (ebool) {
-        return ebool.wrap(_le(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().le(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function le(euint256 a, euint256 b) internal returns (ebool) {
-        return ebool.wrap(_le(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().le(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function le(eint16 a, eint16 b) internal returns (ebool) {
-        return ebool.wrap(_le(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().le(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function le(eint256 a, eint256 b) internal returns (ebool) {
-        return ebool.wrap(_le(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().le(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function gt(euint16 a, euint16 b) internal returns (ebool) {
-        return ebool.wrap(_gt(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().gt(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function gt(euint256 a, euint256 b) internal returns (ebool) {
-        return ebool.wrap(_gt(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().gt(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function gt(eint16 a, eint16 b) internal returns (ebool) {
-        return ebool.wrap(_gt(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().gt(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function gt(eint256 a, eint256 b) internal returns (ebool) {
-        return ebool.wrap(_gt(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().gt(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     function ge(euint16 a, euint16 b) internal returns (ebool) {
-        return ebool.wrap(_ge(euint16.unwrap(a), euint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ge(
+                    _resolveUndefinedHandle(euint16.unwrap(a), TEEType.Uint16),
+                    _resolveUndefinedHandle(euint16.unwrap(b), TEEType.Uint16)
+                )
+            );
     }
 
     function ge(euint256 a, euint256 b) internal returns (ebool) {
-        return ebool.wrap(_ge(euint256.unwrap(a), euint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ge(
+                    _resolveUndefinedHandle(euint256.unwrap(a), TEEType.Uint256),
+                    _resolveUndefinedHandle(euint256.unwrap(b), TEEType.Uint256)
+                )
+            );
     }
 
     function ge(eint16 a, eint16 b) internal returns (ebool) {
-        return ebool.wrap(_ge(eint16.unwrap(a), eint16.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ge(
+                    _resolveUndefinedHandle(eint16.unwrap(a), TEEType.Int16),
+                    _resolveUndefinedHandle(eint16.unwrap(b), TEEType.Int16)
+                )
+            );
     }
 
     function ge(eint256 a, eint256 b) internal returns (ebool) {
-        return ebool.wrap(_ge(eint256.unwrap(a), eint256.unwrap(b)));
+        return
+            ebool.wrap(
+                _noxComputeContract().ge(
+                    _resolveUndefinedHandle(eint256.unwrap(a), TEEType.Int256),
+                    _resolveUndefinedHandle(eint256.unwrap(b), TEEType.Int256)
+                )
+            );
     }
 
     // ============ ADVANCED FUNCTIONS ============
@@ -534,11 +839,12 @@ library Nox {
         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)
-        );
+        (bytes32 _success, bytes32 _newBalanceFrom, bytes32 _newBalanceTo) = _noxComputeContract()
+            .transfer(
+                _resolveUndefinedHandle(euint256.unwrap(balanceFrom), TEEType.Uint256),
+                _resolveUndefinedHandle(euint256.unwrap(balanceTo), TEEType.Uint256),
+                _resolveUndefinedHandle(euint256.unwrap(amount), TEEType.Uint256)
+            );
         success = ebool.wrap(_success);
         newBalanceFrom = euint256.wrap(_newBalanceFrom);
         newBalanceTo = euint256.wrap(_newBalanceTo);
@@ -554,11 +860,12 @@ library Nox {
         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)
-        );
+        (bytes32 _success, bytes32 _newBalanceTo, bytes32 _newTotalSupply) = _noxComputeContract()
+            .mint(
+                _resolveUndefinedHandle(euint256.unwrap(balanceTo), TEEType.Uint256),
+                _resolveUndefinedHandle(euint256.unwrap(amount), TEEType.Uint256),
+                _resolveUndefinedHandle(euint256.unwrap(totalSupply), TEEType.Uint256)
+            );
         success = ebool.wrap(_success);
         newBalanceTo = euint256.wrap(_newBalanceTo);
         newTotalSupply = euint256.wrap(_newTotalSupply);
@@ -574,11 +881,12 @@ library Nox {
         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)
-        );
+        (bytes32 _success, bytes32 _newBalanceFrom, bytes32 _newTotalSupply) = _noxComputeContract()
+            .burn(
+                _resolveUndefinedHandle(euint256.unwrap(balanceFrom), TEEType.Uint256),
+                _resolveUndefinedHandle(euint256.unwrap(amount), TEEType.Uint256),
+                _resolveUndefinedHandle(euint256.unwrap(totalSupply), TEEType.Uint256)
+            );
         success = ebool.wrap(_success);
         newBalanceFrom = euint256.wrap(_newBalanceFrom);
         newTotalSupply = euint256.wrap(_newTotalSupply);
@@ -1005,7 +1313,9 @@ library Nox {
             ebool.unwrap(handle),
             decryptionProof
         );
-        return abi.decode(result, (bool));
+        require(result.length == 1, MalformedDecryptedData(result));
+        require(result[0] == 0x00 || result[0] == 0x01, MalformedDecryptedData(result));
+        return result[0] != 0x00;
     }
 
     /**
@@ -1019,7 +1329,8 @@ library Nox {
             eaddress.unwrap(handle),
             decryptionProof
         );
-        return abi.decode(result, (address));
+        require(result.length == 20, MalformedDecryptedData(result));
+        return address(bytes20(result));
     }
 
     /**
@@ -1033,7 +1344,8 @@ library Nox {
             euint16.unwrap(handle),
             decryptionProof
         );
-        return abi.decode(result, (uint16));
+        require(result.length == 2, MalformedDecryptedData(result));
+        return uint16(bytes2(result));
     }
 
     /**
@@ -1047,7 +1359,8 @@ library Nox {
             euint256.unwrap(handle),
             decryptionProof
         );
-        return abi.decode(result, (uint256));
+        require(result.length == 32, MalformedDecryptedData(result));
+        return uint256(bytes32(result));
     }
 
     /**
@@ -1061,7 +1374,8 @@ library Nox {
             eint16.unwrap(handle),
             decryptionProof
         );
-        return abi.decode(result, (int16));
+        require(result.length == 2, MalformedDecryptedData(result));
+        return int16(uint16(bytes2(result)));
     }
 
     /**
@@ -1075,139 +1389,20 @@ library Nox {
             eint256.unwrap(handle),
             decryptionProof
         );
-        return abi.decode(result, (int256));
+        require(result.length == 32, MalformedDecryptedData(result));
+        return int256(uint256(bytes32(result)));
     }
 
     // ============ Private helpers ============
 
-    function _assertInitialized(bytes32 handle) private pure {
-        // TODO remove this function and all related asserts and use
-        // default zero values offchain in runner (0, address(0), ...)
-        // when the handle is uninitialized (0x00...00).
-        require(handle != bytes32(0), UninitializedHandle());
-    }
-
-    function _add(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().add(a, b);
-    }
-
-    function _sub(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().sub(a, b);
-    }
-
-    function _mul(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().mul(a, b);
-    }
-
-    function _div(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().div(a, b);
-    }
-
-    function _safeAdd(bytes32 a, bytes32 b) private returns (bytes32, bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().safeAdd(a, b);
-    }
-
-    function _safeSub(bytes32 a, bytes32 b) private returns (bytes32, bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        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);
-        _assertInitialized(ifFalse);
-        return _noxComputeContract().select(condition, ifTrue, ifFalse);
-    }
-
-    function _eq(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().eq(a, b);
-    }
-
-    function _ne(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().ne(a, b);
-    }
-
-    function _lt(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().lt(a, b);
-    }
-
-    function _le(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().le(a, b);
-    }
-
-    function _gt(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().gt(a, b);
-    }
-
-    function _ge(bytes32 a, bytes32 b) private returns (bytes32) {
-        _assertInitialized(a);
-        _assertInitialized(b);
-        return _noxComputeContract().ge(a, b);
-    }
-
-    function _transfer(
-        bytes32 balanceFrom,
-        bytes32 balanceTo,
-        bytes32 amount
-    ) private returns (bytes32, bytes32, bytes32) {
-        _assertInitialized(balanceFrom);
-        _assertInitialized(balanceTo);
-        _assertInitialized(amount);
-        return _noxComputeContract().transfer(balanceFrom, balanceTo, amount);
-    }
-
-    function _mint(
-        bytes32 balanceTo,
-        bytes32 amount,
-        bytes32 totalSupply
-    ) private returns (bytes32, bytes32, bytes32) {
-        _assertInitialized(balanceTo);
-        _assertInitialized(amount);
-        _assertInitialized(totalSupply);
-        return _noxComputeContract().mint(balanceTo, amount, totalSupply);
-    }
-
-    function _burn(
-        bytes32 balanceFrom,
-        bytes32 amount,
-        bytes32 totalSupply
-    ) private returns (bytes32, bytes32, bytes32) {
-        _assertInitialized(balanceFrom);
-        _assertInitialized(amount);
-        _assertInitialized(totalSupply);
-        return _noxComputeContract().burn(balanceFrom, amount, totalSupply);
+    /**
+     * @dev Resolves an undefined (bytes32(0)) handle to the typed zero handle for the given type.
+     * If the handle is already non-zero, returns it unchanged.
+     */
+    function _resolveUndefinedHandle(
+        bytes32 handle,
+        TEEType teeType
+    ) private view returns (bytes32) {
+        return handle == bytes32(0) ? HandleUtils.zeroHandle(teeType) : handle;
     }
 }