@inco/lightning 0.1.20

package/src/lightning-parts/EncryptedInput.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
+import {EventCounter} from "./primitives/EventCounter.sol";
+// import {console} from "forge-std/console.sol";
+import {euint256, ebool, ETypes, EVM_HOST_CHAIN_PREFIX, HANDLE_VERSION, HANDLE_INDEX} from "../Types.sol";
+import {HandleGeneration} from "./primitives/HandleGeneration.sol";
+
+abstract contract EncryptedInput is
+    BaseAccessControlList,
+    EventCounter,
+    HandleGeneration
+{
+    error HandleAlreadyExists();
+
+    event NewInput(
+        bytes32 indexed result,
+        address indexed contractAddress,
+        address indexed user,
+        ETypes inputType,
+        bytes ciphertext,
+        uint256 eventId
+    );
+
+    function newEuint256(
+        bytes memory ciphertext,
+        address user
+    ) external returns (euint256 newValue) {
+        return euint256.wrap(newInput(ciphertext, user, ETypes.Uint256));
+    }
+
+    function newEbool(
+        bytes memory ciphertext,
+        address user
+    ) external returns (ebool newValue) {
+        return ebool.wrap(newInput(ciphertext, user, ETypes.Bool));
+    }
+
+    function newInput(
+        bytes memory ciphertext,
+        address user,
+        ETypes inputType
+    ) internal returns (bytes32 newHandle) {
+        newHandle = getInputHandle(ciphertext, user, msg.sender, inputType);
+        // We assume that providing the same handle (which via HADU implies same plaintext, same context, and same
+        // instance of encryption)
+        require(!isAllowed(newHandle, user), HandleAlreadyExists());
+        // We allow to user since this is harmless and it is convenient to use the allow mapping to track existing
+        allowInternal(newHandle, user);
+        allowTransientInternal(newHandle, msg.sender);
+        emit NewInput(
+            newHandle,
+            msg.sender,
+            user,
+            inputType,
+            ciphertext,
+            getNewEventId()
+        );
+    }
+}

package/src/lightning-parts/EncryptedOperations.sol

@@ -0,0 +1,610 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {euint256, ebool, EOps, SenderNotAllowedForHandle, ETypes, isTypeSupported} from "../Types.sol";
+import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
+import {EventCounter} from "./primitives/EventCounter.sol";
+import {HandleGeneration} from "./primitives/HandleGeneration.sol";
+
+abstract contract EncryptedOperations is
+    BaseAccessControlList,
+    EventCounter,
+    HandleGeneration
+{
+    error UnexpectedType(ETypes actual, ETypes expected);
+    error UnsupportedType(ETypes actual);
+
+    uint256 private randCounter;
+
+    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(
+        euint256 indexed lhs,
+        euint256 indexed rhs,
+        ebool indexed result,
+        uint256 eventId
+    );
+    event ENe(
+        euint256 indexed lhs,
+        euint256 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
+    );
+    event EIfThenElse(
+        ebool control, // can't index >3 fields
+        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
+    );
+
+    modifier checked(euint256 lhs, euint256 rhs) {
+        checkInput(euint256.unwrap(lhs), ETypes.Uint256);
+        checkInput(euint256.unwrap(rhs), ETypes.Uint256);
+        _;
+    }
+
+    modifier checkedHandle(euint256 handle) {
+        checkInput(euint256.unwrap(handle), ETypes.Uint256);
+        _;
+    }
+
+    function checkInput(bytes32 input, ETypes requiredType) internal view {
+        require(
+            isAllowed(input, msg.sender),
+            SenderNotAllowedForHandle(input, msg.sender)
+        );
+        require(
+            typeOf(input) == requiredType,
+            UnexpectedType(typeOf(input), requiredType)
+        );
+    }
+
+    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
+    ) internal returns (bytes32 result) {
+        result = getOpResultHandle(op, returnType, value);
+        allowTransientInternal(result, msg.sender);
+    }
+
+    function eAdd(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Add,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EAdd(lhs, rhs, result, getNewEventId());
+    }
+
+    function eSub(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Sub,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit ESub(lhs, rhs, result, getNewEventId());
+    }
+
+    function eMul(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Mul,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EMul(lhs, rhs, result, getNewEventId());
+    }
+
+    function eDiv(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Div,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EDiv(lhs, rhs, result, getNewEventId());
+    }
+
+    function eRem(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Rem,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit ERem(lhs, rhs, result, getNewEventId());
+    }
+
+    function eBitAnd(
+        bytes32 lhs,
+        bytes32 rhs
+    ) external returns (bytes32 result) {
+        ETypes lhsType = typeOf(lhs);
+        ETypes rhsType = typeOf(rhs);
+        checkInput(lhs, lhsType);
+        checkInput(rhs, rhsType);
+        require(lhsType == rhsType, UnexpectedType(lhsType, rhsType));
+        result = createResultHandle(EOps.BitAnd, lhsType, lhs, rhs);
+        emit EBitAnd(lhs, rhs, result, getNewEventId());
+    }
+
+    function eBitOr(
+        bytes32 lhs,
+        bytes32 rhs
+    ) external returns (bytes32 result) {
+        ETypes lhsType = typeOf(lhs);
+        ETypes rhsType = typeOf(rhs);
+        checkInput(lhs, lhsType);
+        checkInput(rhs, rhsType);
+        require(lhsType == rhsType, UnexpectedType(lhsType, rhsType));
+        result = createResultHandle(EOps.BitOr, lhsType, lhs, rhs);
+        emit EBitOr(lhs, rhs, result, getNewEventId());
+    }
+
+    function eBitXor(
+        bytes32 lhs,
+        bytes32 rhs
+    ) external returns (bytes32 result) {
+        ETypes lhsType = typeOf(lhs);
+        ETypes rhsType = typeOf(rhs);
+        checkInput(lhs, lhsType);
+        checkInput(rhs, rhsType);
+        require(lhsType == rhsType, UnexpectedType(lhsType, rhsType));
+        result = createResultHandle(EOps.BitXor, lhsType, lhs, rhs);
+        emit EBitXor(lhs, rhs, result, getNewEventId());
+    }
+
+    function eShl(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Shl,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EShl(lhs, rhs, result, getNewEventId());
+    }
+
+    function eShr(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Shr,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EShr(lhs, rhs, result, getNewEventId());
+    }
+
+    function eRotl(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Rotl,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit ERotl(lhs, rhs, result, getNewEventId());
+    }
+
+    function eRotr(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Rotr,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit ERotr(lhs, rhs, result, getNewEventId());
+    }
+
+    function eEq(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (ebool result) {
+        result = ebool.wrap(
+            createResultHandle(
+                EOps.Eq,
+                ETypes.Bool,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EEq(lhs, rhs, result, getNewEventId());
+    }
+
+    function eNe(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (ebool result) {
+        result = ebool.wrap(
+            createResultHandle(
+                EOps.Ne,
+                ETypes.Bool,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit ENe(lhs, rhs, result, getNewEventId());
+    }
+
+    function eGe(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (ebool result) {
+        result = ebool.wrap(
+            createResultHandle(
+                EOps.Ge,
+                ETypes.Bool,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EGe(lhs, rhs, result, getNewEventId());
+    }
+
+    function eGt(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (ebool result) {
+        result = ebool.wrap(
+            createResultHandle(
+                EOps.Gt,
+                ETypes.Bool,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EGt(lhs, rhs, result, getNewEventId());
+    }
+
+    function eLe(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (ebool result) {
+        result = ebool.wrap(
+            createResultHandle(
+                EOps.Le,
+                ETypes.Bool,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit ELe(lhs, rhs, result, getNewEventId());
+    }
+
+    function eLt(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (ebool result) {
+        result = ebool.wrap(
+            createResultHandle(
+                EOps.Lt,
+                ETypes.Bool,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit ELt(lhs, rhs, result, getNewEventId());
+    }
+
+    function eMin(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Min,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EMin(lhs, rhs, result, getNewEventId());
+    }
+
+    function eMax(
+        euint256 lhs,
+        euint256 rhs
+    ) external checked(lhs, rhs) returns (euint256 result) {
+        result = euint256.wrap(
+            createResultHandle(
+                EOps.Max,
+                ETypes.Uint256,
+                euint256.unwrap(lhs),
+                euint256.unwrap(rhs)
+            )
+        );
+        emit EMax(lhs, rhs, result, getNewEventId());
+    }
+
+    function eNot(ebool operand) external returns (ebool result) {
+        checkInput(ebool.unwrap(operand), ETypes.Bool);
+        result = ebool.wrap(
+            createResultHandle(EOps.Not, ETypes.Bool, ebool.unwrap(operand))
+        );
+        emit ENot(operand, result, getNewEventId());
+    }
+
+    function eCast(
+        bytes32 ct,
+        ETypes toType
+    ) external returns (bytes32 result) {
+        bytes32 baseHandle = keccak256(abi.encodePacked(EOps.Cast, ct, toType));
+        result = embedTypeVersion(baseHandle, toType);
+        allowTransientInternal(result, msg.sender);
+        emit ECast(ct, uint8(toType), result, getNewEventId());
+    }
+
+    function eRand(
+        ETypes randType
+    ) external returns (bytes32 result) {
+        require(isTypeSupported(randType), UnsupportedType(randType));
+
+        result = createResultHandle(
+            EOps.Rand,
+            randType,
+            bytes32(randCounter++),
+            bytes32(uint256(randType))
+        );
+        emit ERand(randCounter, randType, result, getNewEventId());
+    }
+
+    function eRandBounded(
+        bytes32 upperBound,
+        ETypes randType
+    ) external returns (bytes32 result) {
+        require(isTypeSupported(randType), UnsupportedType(randType));
+        checkInput(upperBound, ETypes.Uint256);
+
+        result = createResultHandle(
+            EOps.RandBounded,
+            randType,
+            bytes32(randCounter++),
+            upperBound,
+            bytes32(uint256(randType))
+        );
+        emit ERandBounded(randCounter, randType, upperBound, result, getNewEventId());
+    }
+
+    // todo add support in testing framework
+    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);
+        allowTransientInternal(result, msg.sender);
+        emit EIfThenElse(control, ifTrue, ifFalse, result, getNewEventId());
+    }
+
+    function checkEIfThenElseInputs(
+        ebool control,
+        bytes32 ifTrue,
+        bytes32 ifFalse
+    ) internal view returns (ETypes ifTrueType) {
+        checkInput(ebool.unwrap(control), ETypes.Bool);
+        ifTrueType = typeOf(ifTrue);
+        require(
+            ifTrueType == ETypes.Uint256 || ifTrueType == ETypes.Bool,
+            UnsupportedType(ifTrueType)
+        );
+        require(
+            isAllowed(ifTrue, msg.sender),
+            SenderNotAllowedForHandle(ifTrue, msg.sender)
+        );
+        checkInput(ifFalse, ifTrueType);
+    }
+}

package/src/lightning-parts/TrivialEncryption.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {EventCounter} from "./primitives/EventCounter.sol";
+import {euint256, ebool, ETypes} from "../Types.sol";
+import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
+import {HandleGeneration} from "./primitives/HandleGeneration.sol";
+
+abstract contract TrivialEncryption is
+    BaseAccessControlList,
+    EventCounter,
+    HandleGeneration
+{
+    event TrivialEncrypt(
+        bytes32 indexed result,
+        bytes32 plainTextBytes,
+        ETypes handleType,
+        uint256 eventId
+    );
+
+    function asEuint256(uint256 value) external returns (euint256 newEuint256) {
+        return euint256.wrap(newTrivialEncrypt(bytes32(value), ETypes.Uint256));
+    }
+
+    function asEbool(bool value) external returns (ebool newEbool) {
+        bytes32 castedValue = bytes32(uint256(value ? 1 : 0));
+        return ebool.wrap(newTrivialEncrypt(castedValue, ETypes.Bool));
+    }
+
+    function newTrivialEncrypt(
+        bytes32 plainTextBytes,
+        ETypes handleType
+    ) internal returns (bytes32 newHandle) {
+        newHandle = getTrivialEncryptHandle(plainTextBytes, handleType);
+        allowTransientInternal(newHandle, msg.sender);
+        emit TrivialEncrypt(
+            newHandle,
+            plainTextBytes,
+            handleType,
+            getNewEventId()
+        );
+    }
+}