@inco/lightning 0.6.1 → 0.6.4

package/src/lightning-parts/EncryptedOperations.sol

@@ -23,9 +23,9 @@ abstract contract EncryptedOperations is
     bytes32 constant EUINT256 = bytes32(1 << uint256(ETypes.Uint256));
 
     bytes32 constant SUPPORTED_TYPES_MASK =
-        EBOOL |
-        EUINT160 |
-        EUINT256;
+    EBOOL |
+    EUINT160 |
+    EUINT256;
 
     event EAdd(
         euint256 indexed lhs,
@@ -198,41 +198,9 @@ abstract contract EncryptedOperations is
     function createResultHandle(
         EOps op,
         ETypes returnType,
-        bytes32 lhs,
-        bytes32 rhs
-    ) internal returns (bytes32 result) {
-        result = getOpResultHandle(op, returnType, lhs, rhs);
-        allowTransientInternal(result, msg.sender);
-    }
-
-    function createResultHandle(
-        EOps op,
-        ETypes returnType,
-        bytes32 inputA,
-        bytes32 inputB,
-        bytes32 inputC
-    ) internal returns (bytes32 result) {
-        result = getOpResultHandle(op, returnType, inputA, inputB, inputC);
-        allowTransientInternal(result, msg.sender);
-    }
-
-    // todo replace with production implem
-    function createResultHandle(
-        EOps op,
-        ETypes returnType,
-        uint256 counter,
-        bytes32 upperBound
-    ) internal returns (bytes32 result) {
-        result = getOpResultHandle(op, returnType, counter, upperBound);
-        allowTransientInternal(result, msg.sender);
-    }
-
-    function createResultHandle(
-        EOps op,
-        ETypes returnType,
-        bytes32 value
+        bytes memory packedInputs
     ) internal returns (bytes32 result) {
-        result = getOpResultHandle(op, returnType, value);
+        result = getOpResultHandle(op, returnType, packedInputs);
         allowTransientInternal(result, msg.sender);
     }
 
@@ -244,8 +212,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Add,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -261,8 +231,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Sub,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -278,8 +250,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Mul,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -295,8 +269,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Div,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -312,8 +288,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Rem,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -330,8 +308,8 @@ abstract contract EncryptedOperations is
         checkInput(lhs, typeToBitMask(lhsType));
         checkInput(rhs, typeToBitMask(rhsType));
         require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
-        result = createResultHandle(EOps.BitAnd, lhsType, lhs, rhs);
         uint256 id = getNextEventId();
+        result = createResultHandle(EOps.BitAnd, lhsType, abi.encodePacked(lhs, rhs));
         emit EBitAnd(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
@@ -345,8 +323,8 @@ abstract contract EncryptedOperations is
         checkInput(lhs, typeToBitMask(lhsType));
         checkInput(rhs, typeToBitMask(rhsType));
         require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
-        result = createResultHandle(EOps.BitOr, lhsType, lhs, rhs);
         uint256 id = getNextEventId();
+        result = createResultHandle(EOps.BitOr, lhsType, abi.encodePacked(lhs, rhs));
         emit EBitOr(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
@@ -360,8 +338,8 @@ abstract contract EncryptedOperations is
         checkInput(lhs, typeToBitMask(lhsType));
         checkInput(rhs, typeToBitMask(rhsType));
         require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
-        result = createResultHandle(EOps.BitXor, lhsType, lhs, rhs);
         uint256 id = getNextEventId();
+        result = createResultHandle(EOps.BitXor, lhsType, abi.encodePacked(lhs, rhs));
         emit EBitXor(lhs, rhs, result, id);
         setDigest(abi.encodePacked(result, id));
     }
@@ -374,8 +352,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Shl,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -391,8 +371,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Shr,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -408,8 +390,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Rotl,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -425,8 +409,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Rotr,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -445,8 +431,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Eq,
                 ETypes.Bool,
-                lhs,
-                rhs
+                abi.encodePacked(
+                    lhs,
+                    rhs
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -465,8 +453,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Ne,
                 ETypes.Bool,
-                lhs,
-                rhs
+                abi.encodePacked(
+                    lhs,
+                    rhs
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -482,8 +472,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Ge,
                 ETypes.Bool,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -499,8 +491,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Gt,
                 ETypes.Bool,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -516,8 +510,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Le,
                 ETypes.Bool,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -533,8 +529,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Lt,
                 ETypes.Bool,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -550,8 +548,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Min,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -567,8 +567,10 @@ abstract contract EncryptedOperations is
             createResultHandle(
                 EOps.Max,
                 ETypes.Uint256,
-                euint256.unwrap(lhs),
-                euint256.unwrap(rhs)
+                abi.encodePacked(
+                    euint256.unwrap(lhs),
+                    euint256.unwrap(rhs)
+                )
             )
         );
         uint256 id = getNextEventId();
@@ -579,7 +581,7 @@ 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, ebool.unwrap(operand))
+            createResultHandle(EOps.Not, ETypes.Bool, abi.encodePacked(ebool.unwrap(operand)))
         );
         uint256 id = getNextEventId();
         emit ENot(operand, result, id);
@@ -590,7 +592,7 @@ abstract contract EncryptedOperations is
         bytes32 ct,
         ETypes toType
     ) external returns (bytes32 result) {
-        bytes32 baseHandle = keccak256(abi.encodePacked(EOps.Cast, ct, toType));
+        bytes32 baseHandle = keccak256(abi.encodePacked(EOps.Cast, ct));
         result = embedTypeVersion(baseHandle, toType);
         allowTransientInternal(result, msg.sender);
         uint256 id = getNextEventId();
@@ -602,16 +604,12 @@ abstract contract EncryptedOperations is
         ETypes randType
     ) external paying payable returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
-
+        randCounter++;
         result = createResultHandle(
             EOps.Rand,
-            randType, 
-            bytes32(randCounter++),
-            bytes32(uint256(randType))
+            randType,
+            abi.encodePacked(bytes32(randCounter))
         );
-        //NOTE: We pass the incremented randCounter which is incremented using postfix increment above.
-        // Due to postfix returning the value before incrementing, the emitted randCounter will be larger by one than the number used to build the handle.
-        // So for security and replayability reasons, we always use the incremented randCounter when seeding on the covalidator side, which is fine for as long as we're consistent.
         uint256 id = getNextEventId();
         emit ERand(randCounter, randType, result, id);
         setDigest(abi.encodePacked(result, id));
@@ -623,17 +621,15 @@ abstract contract EncryptedOperations is
     ) external paying payable returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
         checkInput(upperBound, typeToBitMask(ETypes.Uint256));
-
+        randCounter++;
         result = createResultHandle(
             EOps.RandBounded,
             randType,
-            bytes32(randCounter++),
-            upperBound,
-            bytes32(uint256(randType))
+            abi.encodePacked(
+                bytes32(randCounter),
+                upperBound
+            )
         );
-        //NOTE: We pass the incremented randCounter which is incremented using postfix increment above.
-        // Due to postfix returning the value before incrementing, the emitted randCounter will be larger by one than the number used to build the handle.
-        // So for security and replayability reasons, we always use the incremented randCounter when seeding on the covalidator side, which is fine for as long as we're consistent.
         uint256 id = getNextEventId();
         emit ERandBounded(randCounter, randType, upperBound, result, id);
         setDigest(abi.encodePacked(result, id));