@inco/lightning 0.1.20

package/src/lightning-parts/primitives/EventCounter.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+contract EventCounterStorage {
+    struct Storage {
+        uint256 eventCounter;
+    }
+
+    bytes32 private constant eventCounterStorageLocation =
+        keccak256("lightning.storage.EventCounter");
+
+    function getEventCounterStorage()
+        internal
+        pure
+        returns (Storage storage $)
+    {
+        bytes32 loc = eventCounterStorageLocation;
+        assembly {
+            $.slot := loc
+        }
+    }
+}
+
+contract EventCounter is EventCounterStorage {
+    function getNewEventId() internal returns (uint256 newEventId) {
+        newEventId = getEventCounterStorage().eventCounter++;
+    }
+
+    function getEventCounter() external view returns (uint256) {
+        return getEventCounterStorage().eventCounter;
+    }
+}

package/src/lightning-parts/primitives/HandleGeneration.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {ETypes, EOps, EVM_HOST_CHAIN_PREFIX, HANDLE_INDEX} from "../../Types.sol";
+import {HandleMetadata} from "./HandleMetadata.sol";
+
+contract HandleGeneration is HandleMetadata {
+    function getTrivialEncryptHandle(
+        bytes32 plaintextBytes,
+        ETypes handleType
+    ) public view returns (bytes32 generatedHandle) {
+        generatedHandle = keccak256(
+            abi.encodePacked(
+                EVM_HOST_CHAIN_PREFIX,
+                block.chainid, // todo cache this
+                EOps.TrivialEncrypt,
+                plaintextBytes,
+                handleType,
+                address(this) // todo cache this
+            )
+        );
+        generatedHandle = embedTypeVersion(generatedHandle, handleType);
+    }
+
+    function getInputHandle(
+        bytes memory ciphertext,
+        address user,
+        address contractAddress,
+        ETypes inputType
+    ) public view returns (bytes32 generatedHandle) {
+        // Here we ensure that our hashing scheme is binary-compatible between IncoLightning and IncoFhevm, this helps
+        // keep client-side code consistent in its ciphertext, context => handle mappings
+        bytes32 ctIndexHash = keccak256(
+            abi.encodePacked(keccak256(ciphertext), HANDLE_INDEX)
+        );
+        bytes32 prehandle = embedIndexTypeVersion(ctIndexHash, inputType);
+        // We must also propagate the handle metadata to the final handle
+        generatedHandle = embedIndexTypeVersion(
+            keccak256(
+                abi.encodePacked(
+                    prehandle,
+                    EVM_HOST_CHAIN_PREFIX,
+                    block.chainid, // todo cache this
+                    address(this), // todo cache this
+                    user,
+                    contractAddress
+                )
+            ),
+            inputType
+        );
+    }
+
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        bytes32 lhs,
+        bytes32 rhs
+    ) public pure returns (bytes32 generatedHandle) {
+        generatedHandle = getOpResultHandle(
+            keccak256(abi.encodePacked(op, lhs, rhs)),
+            returnType
+        );
+    }
+
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        uint256 counter,
+        bytes32 upperBound
+    ) public pure returns (bytes32 generatedHandle) {
+        generatedHandle = getOpResultHandle(
+            keccak256(abi.encodePacked(op, counter, upperBound)),
+            returnType
+        );
+    }
+
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        bytes32 value
+    ) public pure returns (bytes32 generatedHandle) {
+        generatedHandle = getOpResultHandle(
+            keccak256(abi.encodePacked(op, value)),
+            returnType
+        );
+    }
+
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        bytes32 inputA,
+        bytes32 inputB,
+        bytes32 inputC
+    ) public pure returns (bytes32 generatedHandle) {
+        generatedHandle = getOpResultHandle(
+            keccak256(abi.encodePacked(op, inputA, inputB, inputC)),
+            returnType
+        );
+    }
+
+    function getOpResultHandle(
+        bytes32 baseHandle,
+        ETypes returnType
+    ) internal pure returns (bytes32 generatedHandle) {
+        generatedHandle = embedTypeVersion(baseHandle, returnType);
+    }
+}

package/src/lightning-parts/primitives/HandleMetadata.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {HANDLE_VERSION, HANDLE_INDEX, ETypes} from "../../Types.sol";
+
+contract HandleMetadata {
+    function embedIndexTypeVersion(
+        bytes32 prehandle,
+        ETypes inputType
+    ) internal pure returns (bytes32 result) {
+        // Create a mask to clear the last three bytes
+        bytes32 mask = bytes32(
+            uint256(
+                0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00FFFF
+            )
+        );
+        // Clear the last three bytes of the original value
+        bytes32 clearedOriginal = prehandle & mask;
+        // Combine the cleared original value with the new last three bytes
+        result = clearedOriginal | bytes32((uint256(HANDLE_INDEX) << 16));
+        result = embedTypeVersion(result, inputType);
+    }
+
+    function embedTypeVersion(
+        bytes32 prehandle,
+        ETypes handleType
+    ) internal pure returns (bytes32 result) {
+        result =
+            prehandle &
+            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000;
+        result = bytes32(uint256(result) | (uint256(handleType) << 8)); // append type
+        result = bytes32(uint256(result) | HANDLE_VERSION);
+    }
+
+    function typeOf(bytes32 handle) internal pure returns (ETypes) {
+        return ETypes(uint8(uint256(handle) >> 8));
+    }
+}

package/src/lightning-parts/primitives/SignatureVerifier.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+contract SignatureVerifierStorage {
+    struct StorageForSigVerifier {
+        address PubkeyAddress;
+    }
+
+    bytes32 private constant SignatureVerifierStorageLocation =
+        keccak256("inco.storage.SignatureVerifier");
+
+    function getSigVerifierStorage()
+        internal
+        pure
+        returns (StorageForSigVerifier storage $)
+    {
+        bytes32 loc = SignatureVerifierStorageLocation;
+        assembly {
+            $.slot := loc
+        }
+    }
+}
+
+contract SignatureVerifier is OwnableUpgradeable, SignatureVerifierStorage {
+    using ECDSA for bytes32;
+
+    event PubkeyAddressChanged(address newPubkeyAddress);
+
+    function editPubkeyAddress(address newPubkeyAddress) external onlyOwner {
+        getSigVerifierStorage().PubkeyAddress = newPubkeyAddress;
+        emit PubkeyAddressChanged(newPubkeyAddress);
+    }
+
+    function opSignerPubkeyAddress() public view returns (address) {
+        return getSigVerifierStorage().PubkeyAddress;
+    }
+
+    function isValidSignature(
+        bytes32 hash,
+        bytes memory signature
+    ) public view returns (bool) {
+        return hash.recover(signature) == getSigVerifierStorage().PubkeyAddress;
+    }
+}

package/src/lightning-parts/test/HandleMetadata.t.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {TestUtils} from "@inco/shared/src/TestUtils.sol";
+import {HandleMetadata} from "../primitives/HandleMetadata.sol";
+import {TrivialEncryption} from "../TrivialEncryption.sol";
+import {EncryptedOperations} from "../EncryptedOperations.sol";
+import {EncryptedInput} from "../EncryptedInput.sol";
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {ETypes, ebool, euint256} from "../../Types.sol";
+
+contract TestHandleMetadata is
+    EIP712,
+    HandleMetadata,
+    TestUtils,
+    TrivialEncryption,
+    EncryptedOperations,
+    EncryptedInput
+{
+    constructor() EIP712("", "") {}
+
+    function testTypeAssignment() public pure {
+        bytes32 someHandle = bytes32(keccak256("someHandle"));
+        assert(
+            typeOf(embedIndexTypeVersion(someHandle, ETypes.Bool)) ==
+                ETypes.Bool
+        );
+        assert(
+            typeOf(embedIndexTypeVersion(someHandle, ETypes.Uint256)) ==
+                ETypes.Uint256
+        );
+    }
+
+    function testTrivialEncryptionHandleType() public {
+        bytes32 boolHandle = ebool.unwrap(this.asEbool(true));
+        assert(typeOf(boolHandle) == ETypes.Bool);
+        bytes32 uintHandle = euint256.unwrap(this.asEuint256(42));
+        assert(typeOf(uintHandle) == ETypes.Uint256);
+    }
+
+    function testOperationsHandleType() public {
+        euint256 a = this.asEuint256(42);
+        euint256 b = this.asEuint256(12);
+        ebool control = this.asEbool(true);
+        ebool c = this.asEbool(false);
+        ebool d = this.asEbool(true);
+
+        assert(typeOf(euint256.unwrap(this.eAdd(a, b))) == ETypes.Uint256);
+        assert(typeOf(euint256.unwrap(this.eSub(a, b))) == ETypes.Uint256);
+        assert(typeOf(ebool.unwrap(this.eGe(a, b))) == ETypes.Bool);
+        assert(
+            typeOf(
+                this.eIfThenElse(
+                    control,
+                    euint256.unwrap(a),
+                    euint256.unwrap(b)
+                )
+            ) == ETypes.Uint256
+        );
+        assert(
+            typeOf(
+                this.eIfThenElse(control, ebool.unwrap(c), ebool.unwrap(d))
+            ) == ETypes.Bool
+        );
+    }
+
+    function testEIfThenElseChecksTypeCoherence() public {
+        ebool control = this.asEbool(false);
+        euint256 a = this.asEuint256(42);
+        ebool b = this.asEbool(true);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                EncryptedOperations.UnexpectedType.selector,
+                ETypes.Bool,
+                ETypes.Uint256
+            )
+        );
+        this.eIfThenElse(control, euint256.unwrap(a), ebool.unwrap(b));
+    }
+
+    function testEncryptedInputHandleType() public {
+        euint256 a = this.newEuint256("ciphertext", address(this));
+        assert(typeOf(euint256.unwrap(a)) == ETypes.Uint256);
+        ebool b = this.newEbool("ciphertext", address(this));
+        assert(typeOf(ebool.unwrap(b)) == ETypes.Bool);
+    }
+}