@inco/lightning 0.6.8 → 0.7.0

package/src/lightning-parts/EncryptedOperations.sol

@@ -7,173 +7,53 @@ import {HandleGeneration} from "./primitives/HandleGeneration.sol";
 import {IEncryptedOperations} from "./interfaces/IEncryptedOperations.sol";
 import {Fee} from "./Fee.sol";
 
-abstract contract EncryptedOperations is
-    IEncryptedOperations,
-    BaseAccessControlList,
-    HandleGeneration,
-    Fee
-{
+abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControlList, HandleGeneration, Fee {
+
     error UnexpectedType(ETypes actual, bytes32 expectedTypes);
     error UnsupportedType(ETypes actual);
 
     uint256 internal randCounter;
-
-    bytes32 constant EBOOL = bytes32(1 << uint256(ETypes.Bool));
-    bytes32 constant EUINT160 = bytes32(1 << uint256(ETypes.AddressOrUint160OrBytes20));
-    bytes32 constant EUINT256 = bytes32(1 << uint256(ETypes.Uint256));
-
-    bytes32 constant SUPPORTED_TYPES_MASK =
-    EBOOL |
-    EUINT160 |
-    EUINT256;
-
-    event EAdd(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event ESub(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event EMul(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event EDiv(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event ERem(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event EBitAnd(
-        bytes32 indexed lhs,
-        bytes32 indexed rhs,
-        bytes32 indexed result,
-        uint256 eventId
-    );
-    event EBitOr(
-        bytes32 indexed lhs,
-        bytes32 indexed rhs,
-        bytes32 indexed result,
-        uint256 eventId
-    );
-    event EBitXor(
-        bytes32 indexed lhs,
-        bytes32 indexed rhs,
-        bytes32 indexed result,
-        uint256 eventId
-    );
-    event EShl(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event EShr(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event ERotl(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event ERotr(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event EEq(
-        bytes32 indexed lhs,
-        bytes32 indexed rhs,
-        ebool indexed result,
-        uint256 eventId
-    );
-    event ENe(
-        bytes32 indexed lhs,
-        bytes32 indexed rhs,
-        ebool indexed result,
-        uint256 eventId
-    );
-    event EGe(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        ebool indexed result,
-        uint256 eventId
-    );
-    event EGt(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        ebool indexed result,
-        uint256 eventId
-    );
-    event ELe(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        ebool indexed result,
-        uint256 eventId
-    );
-    event ELt(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        ebool indexed result,
-        uint256 eventId
-    );
-    event EMin(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event EMax(
-        euint256 indexed lhs,
-        euint256 indexed rhs,
-        euint256 indexed result,
-        uint256 eventId
-    );
-    event ERand(
-        uint256 indexed counter,
-        ETypes randType,
-        bytes32 indexed result,
-        uint256 eventId
-    );
+    uint256 internal constant ONE = 1;
+
+    bytes32 constant EBOOL = bytes32(ONE << uint256(ETypes.Bool));
+    bytes32 constant EUINT160 = bytes32(ONE << uint256(ETypes.AddressOrUint160OrBytes20));
+    bytes32 constant EUINT256 = bytes32(ONE << uint256(ETypes.Uint256));
+
+    bytes32 constant SUPPORTED_TYPES_MASK = EBOOL | EUINT160 | EUINT256;
+
+    event EAdd(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event ESub(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event EMul(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event EDiv(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event ERem(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event EBitAnd(bytes32 indexed lhs, bytes32 indexed rhs, bytes32 indexed result, uint256 eventId);
+    event EBitOr(bytes32 indexed lhs, bytes32 indexed rhs, bytes32 indexed result, uint256 eventId);
+    event EBitXor(bytes32 indexed lhs, bytes32 indexed rhs, bytes32 indexed result, uint256 eventId);
+    event EShl(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event EShr(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event ERotl(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event ERotr(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event EEq(bytes32 indexed lhs, bytes32 indexed rhs, ebool indexed result, uint256 eventId);
+    event ENe(bytes32 indexed lhs, bytes32 indexed rhs, ebool indexed result, uint256 eventId);
+    event EGe(euint256 indexed lhs, euint256 indexed rhs, ebool indexed result, uint256 eventId);
+    event EGt(euint256 indexed lhs, euint256 indexed rhs, ebool indexed result, uint256 eventId);
+    event ELe(euint256 indexed lhs, euint256 indexed rhs, ebool indexed result, uint256 eventId);
+    event ELt(euint256 indexed lhs, euint256 indexed rhs, ebool indexed result, uint256 eventId);
+    event EMin(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event EMax(euint256 indexed lhs, euint256 indexed rhs, euint256 indexed result, uint256 eventId);
+    event ERand(uint256 indexed counter, ETypes randType, bytes32 indexed result, uint256 eventId);
     event ERandBounded(
-        uint256 indexed counter,
-        ETypes randType,
-        bytes32 indexed upperBound,
-        bytes32 indexed result,
-        uint256 eventId
+        uint256 indexed counter, ETypes randType, bytes32 indexed upperBound, bytes32 indexed result, uint256 eventId
     );
-    event EIfThenElse(
-        ebool control, // can't index >3 fields
+    event EIfThenElse( // can't index >3 fields
+        ebool control,
         bytes32 indexed ifTrue,
         bytes32 indexed ifFalse,
         bytes32 indexed result,
         uint256 eventId
     );
     event ENot(ebool indexed operand, ebool indexed result, uint256 eventId);
-    event ECast(
-        bytes32 indexed ct,
-        uint8 indexed toType,
-        bytes32 indexed result,
-        uint256 eventId
-    );
+    event ECast(bytes32 indexed ct, uint8 indexed toType, bytes32 indexed result, uint256 eventId);
 
     modifier checked(euint256 lhs, euint256 rhs) {
         checkInput(euint256.unwrap(lhs), typeToBitMask(ETypes.Uint256));
@@ -186,123 +66,65 @@ abstract contract EncryptedOperations is
         _;
     }
 
-
     function checkInput(bytes32 input, bytes32 requiredTypes) internal view {
-        require(
-            isAllowed(input, msg.sender),
-            SenderNotAllowedForHandle(input, msg.sender)
-        );
+        require(isAllowed(input, msg.sender), SenderNotAllowedForHandle(input, msg.sender));
         require(requiredTypes & typeToBitMask(typeOf(input)) != 0, UnexpectedType(typeOf(input), requiredTypes));
     }
 
-    function createResultHandle(
-        EOps op,
-        ETypes returnType,
-        bytes memory packedInputs
-    ) internal returns (bytes32 result) {
+    function createResultHandle(EOps op, ETypes returnType, bytes memory packedInputs)
+        internal
+        returns (bytes32 result)
+    {
         result = getOpResultHandle(op, returnType, packedInputs);
         allowTransientInternal(result, msg.sender);
     }
 
-    function eAdd(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eAdd(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Add,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Add, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EAdd(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eSub(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eSub(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Sub,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Sub, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit ESub(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eMul(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eMul(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Mul,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Mul, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EMul(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
-     }
+    }
 
-    function eDiv(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eDiv(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Div,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Div, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EDiv(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eRem(
-        euint256 lhs,
-        euint256 rhs
-    ) external virtual checked(lhs, rhs) returns (euint256 result) {
+    function eRem(euint256 lhs, euint256 rhs) external virtual checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Rem,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Rem, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit ERem(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eBitAnd(
-        bytes32 lhs,
-        bytes32 rhs
-    ) external returns (bytes32 result) {
+    function eBitAnd(bytes32 lhs, bytes32 rhs) external returns (bytes32 result) {
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
         checkInput(lhs, typeToBitMask(lhsType));
@@ -314,10 +136,7 @@ abstract contract EncryptedOperations is
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eBitOr(
-        bytes32 lhs,
-        bytes32 rhs
-    ) external returns (bytes32 result) {
+    function eBitOr(bytes32 lhs, bytes32 rhs) external returns (bytes32 result) {
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
         checkInput(lhs, typeToBitMask(lhsType));
@@ -329,10 +148,7 @@ abstract contract EncryptedOperations is
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eBitXor(
-        bytes32 lhs,
-        bytes32 rhs
-    ) external returns (bytes32 result) {
+    function eBitXor(bytes32 lhs, bytes32 rhs) external returns (bytes32 result) {
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
         checkInput(lhs, typeToBitMask(lhsType));
@@ -344,234 +160,110 @@ abstract contract EncryptedOperations is
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eShl(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eShl(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Shl,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Shl, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EShl(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eShr(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eShr(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Shr,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Shr, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EShr(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eRotl(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eRotl(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Rotl,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Rotl, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit ERotl(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eRotr(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eRotr(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Rotr,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Rotr, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit ERotr(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eEq(
-        bytes32 lhs,
-        bytes32 rhs
-    ) external returns (ebool result) {
+    function eEq(bytes32 lhs, bytes32 rhs) external returns (ebool result) {
         checkInput(lhs, SUPPORTED_TYPES_MASK);
         checkInput(rhs, SUPPORTED_TYPES_MASK);
 
-        result = ebool.wrap(
-            createResultHandle(
-                EOps.Eq,
-                ETypes.Bool,
-                abi.encodePacked(
-                    lhs,
-                    rhs
-                )
-            )
-        );
+        result = ebool.wrap(createResultHandle(EOps.Eq, ETypes.Bool, abi.encodePacked(lhs, rhs)));
         uint256 id = getNextEventId();
         emit EEq(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eNe(
-        bytes32 lhs,
-        bytes32 rhs
-    ) external returns (ebool result) {
+    function eNe(bytes32 lhs, bytes32 rhs) external returns (ebool result) {
         checkInput(lhs, SUPPORTED_TYPES_MASK);
         checkInput(rhs, SUPPORTED_TYPES_MASK);
 
-        result = ebool.wrap(
-            createResultHandle(
-                EOps.Ne,
-                ETypes.Bool,
-                abi.encodePacked(
-                    lhs,
-                    rhs
-                )
-            )
-        );
+        result = ebool.wrap(createResultHandle(EOps.Ne, ETypes.Bool, abi.encodePacked(lhs, rhs)));
         uint256 id = getNextEventId();
         emit ENe(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eGe(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (ebool result) {
+    function eGe(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (ebool result) {
         result = ebool.wrap(
-            createResultHandle(
-                EOps.Ge,
-                ETypes.Bool,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Ge, ETypes.Bool, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EGe(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eGt(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (ebool result) {
+    function eGt(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (ebool result) {
         result = ebool.wrap(
-            createResultHandle(
-                EOps.Gt,
-                ETypes.Bool,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Gt, ETypes.Bool, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EGt(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eLe(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (ebool result) {
+    function eLe(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (ebool result) {
         result = ebool.wrap(
-            createResultHandle(
-                EOps.Le,
-                ETypes.Bool,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Le, ETypes.Bool, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit ELe(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eLt(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (ebool result) {
+    function eLt(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (ebool result) {
         result = ebool.wrap(
-            createResultHandle(
-                EOps.Lt,
-                ETypes.Bool,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Lt, ETypes.Bool, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit ELt(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eMin(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eMin(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Min,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Min, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EMin(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eMax(
-        euint256 lhs,
-        euint256 rhs
-    ) external checked(lhs, rhs) returns (euint256 result) {
+    function eMax(euint256 lhs, euint256 rhs) external checked(lhs, rhs) returns (euint256 result) {
         result = euint256.wrap(
-            createResultHandle(
-                EOps.Max,
-                ETypes.Uint256,
-                abi.encodePacked(
-                    euint256.unwrap(lhs),
-                    euint256.unwrap(rhs)
-                )
-            )
+            createResultHandle(EOps.Max, ETypes.Uint256, abi.encodePacked(euint256.unwrap(lhs), euint256.unwrap(rhs)))
         );
         uint256 id = getNextEventId();
         emit EMax(lhs, rhs, result, id);
@@ -580,98 +272,64 @@ abstract contract EncryptedOperations is
 
     function eNot(ebool operand) external returns (ebool result) {
         checkInput(ebool.unwrap(operand), typeToBitMask(ETypes.Bool));
-        result = ebool.wrap(
-            createResultHandle(EOps.Not, ETypes.Bool, abi.encodePacked(ebool.unwrap(operand)))
-        );
+        result = ebool.wrap(createResultHandle(EOps.Not, ETypes.Bool, abi.encodePacked(ebool.unwrap(operand))));
         uint256 id = getNextEventId();
         emit ENot(operand, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eCast(
-        bytes32 ct,
-        ETypes toType
-    ) external returns (bytes32 result) {
-        bytes32 baseHandle = keccak256(abi.encodePacked(EOps.Cast, ct));
-        result = embedTypeVersion(baseHandle, toType);
+    function eCast(bytes32 ct, ETypes toType) external returns (bytes32 result) {
+        require(isTypeSupported(toType), UnsupportedType(toType));
+        result = createResultHandle(EOps.Cast, toType, abi.encodePacked(ct));
         allowTransientInternal(result, msg.sender);
         uint256 id = getNextEventId();
         emit ECast(ct, uint8(toType), result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eRand(
-        ETypes randType
-    ) external paying payable returns (bytes32 result) {
+    function eRand(ETypes randType) external payable paying returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
         randCounter++;
-        result = createResultHandle(
-            EOps.Rand,
-            randType,
-            abi.encodePacked(bytes32(randCounter))
-        );
+        result = createResultHandle(EOps.Rand, randType, abi.encodePacked(bytes32(randCounter)));
         uint256 id = getNextEventId();
         emit ERand(randCounter, randType, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function eRandBounded(
-        bytes32 upperBound,
-        ETypes randType
-    ) external paying payable returns (bytes32 result) {
+    function eRandBounded(bytes32 upperBound, ETypes randType) external payable paying returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
         checkInput(upperBound, typeToBitMask(ETypes.Uint256));
         randCounter++;
-        result = createResultHandle(
-            EOps.RandBounded,
-            randType,
-            abi.encodePacked(
-                bytes32(randCounter),
-                upperBound
-            )
-        );
+        result = createResultHandle(EOps.RandBounded, randType, abi.encodePacked(bytes32(randCounter), upperBound));
         uint256 id = getNextEventId();
         emit ERandBounded(randCounter, randType, upperBound, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
     // todo add support in testing framework
-    function eIfThenElse(
-        ebool control,
-        bytes32 ifTrue,
-        bytes32 ifFalse
-    ) external returns (bytes32 result) {
+    function eIfThenElse(ebool control, bytes32 ifTrue, bytes32 ifFalse) external returns (bytes32 result) {
         ETypes returnType = checkEIfThenElseInputs(control, ifTrue, ifFalse);
-        bytes32 baseHandle = keccak256(
-            abi.encodePacked(
-                EOps.IfThenElse,
-                ebool.unwrap(control),
-                ifTrue,
-                ifFalse
-            )
-        );
-        result = embedTypeVersion(baseHandle, returnType);
+        result =
+            createResultHandle(EOps.IfThenElse, returnType, abi.encodePacked(ebool.unwrap(control), ifTrue, ifFalse));
         allowTransientInternal(result, msg.sender);
         uint256 id = getNextEventId();
         emit EIfThenElse(control, ifTrue, ifFalse, result, id);
         setDigest(abi.encodePacked(result, id));
     }
 
-    function checkEIfThenElseInputs(
-        ebool control,
-        bytes32 ifTrue,
-        bytes32 ifFalse
-    ) internal view returns (ETypes ifTrueType) {
+    function checkEIfThenElseInputs(ebool control, bytes32 ifTrue, bytes32 ifFalse)
+        internal
+        view
+        returns (ETypes ifTrueType)
+    {
         checkInput(ebool.unwrap(control), typeToBitMask(ETypes.Bool));
         ifTrueType = typeOf(ifTrue);
         require(
             ifTrueType == ETypes.Uint256 || ifTrueType == ETypes.Bool || ifTrueType == ETypes.AddressOrUint160OrBytes20,
             UnsupportedType(ifTrueType)
         );
-        require(
-            isAllowed(ifTrue, msg.sender),
-            SenderNotAllowedForHandle(ifTrue, msg.sender)
-        );
+        require(isAllowed(ifTrue, msg.sender), SenderNotAllowedForHandle(ifTrue, msg.sender));
         checkInput(ifFalse, typeToBitMask(ifTrueType));
     }
+
 }