@inco/lightning 0.4.0 → 0.5.1

package/src/test/FakeIncoInfra/getOpForSelector.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {DecryptionRequested} from "../../lightning-parts/DecryptionHandler.sol";
 import {EncryptedOperations} from "../../lightning-parts/EncryptedOperations.sol";
 import {TrivialEncryption} from "../../lightning-parts/TrivialEncryption.sol";
 import {EncryptedInput} from "../../lightning-parts/EncryptedInput.sol";
@@ -63,8 +62,6 @@ function getOpForSelector(bytes32 opEventSelector) pure returns (EOps) {
         return EOps.Rand;
     } else if (opEventSelector == EncryptedOperations.ERandBounded.selector) {
         return EOps.RandBounded;
-    } else if (opEventSelector == DecryptionRequested.selector) {
-        return EOps.DecryptionRequested;
     } else {
         revert("getOpForSelector: Unsupported selector");
     }

package/src/test/IncoTest.sol

@@ -2,14 +2,16 @@
 pragma solidity ^0.8;
 
 import {MockOpHandler} from "./FakeIncoInfra/MockOpHandler.sol";
-import {IncoLightning} from "../IncoLightning.sol";
+import {IIncoLightning} from "../interfaces/IIncoLightning.sol";
 import {inco} from "../Lib.sol";
 import {DeployUtils} from "../DeployUtils.sol";
 import {deployedBy} from "../Lib.sol";
+import {FakeDecryptionAttester} from "./FakeIncoInfra/FakeDecryptionAttester.sol";
 import {console} from "forge-std/console.sol";
 import {FakeQuoteVerifier} from "./FakeIncoInfra/FakeQuoteVerifier.sol";
+import {IOwnable} from "@inco/shared/src/IOwnable.sol";
 
-contract IncoTest is MockOpHandler, DeployUtils {
+contract IncoTest is MockOpHandler, DeployUtils, FakeDecryptionAttester {
     address immutable owner;
     address immutable testDeployer;
 
@@ -27,16 +29,14 @@ contract IncoTest is MockOpHandler, DeployUtils {
         deployCreateX();
         vm.startPrank(testDeployer);
         vm.setEnv("USE_TDX_HW", "false"); // results in the test deployment using the FakeQuoteVerifier
-        IncoLightning proxy = deployIncoLightningUsingConfig({
+        (IIncoLightning proxy, ) = deployIncoLightningUsingConfig({
             deployer: testDeployer,
-        // The highest precedent deployment
+            // The highest precedent deployment
             pepper: "testnet",
-            minorVersionForSalt: 1,
-            patchVersionForSalt: 29,
-            includePreviewFeatures: false,
-            teeLifecycleAddress: address(0)
+            quoteVerifier: new FakeQuoteVerifier()
         });
-        proxy.transferOwnership(owner);
+        IOwnable(address(proxy)).transferOwnership(owner);
+        IOwnable(address(inco.incoVerifier())).transferOwnership(owner);
         vm.stopPrank();
         console.log(
             "Deployed %s (proxy) to: %s",
@@ -48,8 +48,9 @@ contract IncoTest is MockOpHandler, DeployUtils {
             address(proxy) == address(inco),
             "generated inco address in Lib.sol does not match address of inco deployed by IncoTest"
         );
-        vm.prank(owner);
-        inco.addSigner(teePubkeyAddress);
+        vm.startPrank(owner);
+        inco.incoVerifier().addSigner(teePubkeyAddress);
+        vm.stopPrank();
         vm.recordLogs();
     }
 }

package/src/test/TEELifecycle/TEELifecycleMockTest.t.sol

@@ -1,145 +1,166 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.0;
 
-import "@inco/lightning/src/lightning-parts/TEELifecycle.sol";
-import "@inco/lightning/src/lightning-parts/TEELifecycle.types.sol";
+import {TEELifecycle} from "../../lightning-parts/TEELifecycle.sol";
+import {BootstrapResult} from "../../lightning-parts/TEELifecycle.types.sol";
 import {MockRemoteAttestation} from "../FakeIncoInfra/MockRemoteAttestation.sol";
 import {FakeQuoteVerifier} from "../FakeIncoInfra/FakeQuoteVerifier.sol";
-
-import "forge-std/Vm.sol";
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 
 contract TEELifecycleMockTest is Test, MockRemoteAttestation, TEELifecycle {
-
     function setUp() public {
         quoteVerifier = new FakeQuoteVerifier();
     }
 
-    function test_successfulBootstrap() public {
-        (BootstrapResult memory bootstrapResult, , , bytes memory quote, bytes memory signature, bytes memory mrtd) = successfulBootstrapResult();
+    function testSuccessfulBootstrap() public {
+        (
+            BootstrapResult memory bootstrapResult,
+            ,
+            ,
+            bytes memory quote,
+            bytes memory signature,
+            bytes memory mrtd
+        ) = successfulBootstrapResult();
         vm.startPrank(this.owner());
         this.approveNewTEEVersion(mrtd);
-        this.verifyBootstrapResult(
-            bootstrapResult,
-            quote,
-            signature
-        );
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
         assertTrue(this.isBootstrapComplete(), "Bootstrap should be complete");
         vm.stopPrank();
     }
-    
-    function test_invalidMrtd() public {
-        bytes memory badMrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
 
-        (BootstrapResult memory bootstrapResult, , address bootstrapPartyAddress, bytes memory quote, bytes memory signature, bytes memory mrtd) = successfulBootstrapResult();
+    function testInvalidMrtd() public {
+        bytes
+            memory badMrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+
+        (
+            BootstrapResult memory bootstrapResult,
+            ,
+            address bootstrapPartyAddress,
+            bytes memory quote,
+            bytes memory signature,
+            bytes memory mrtd
+        ) = successfulBootstrapResult();
 
         quote = createQuote(badMrtd, bootstrapPartyAddress); // Replace with bad MRTD
         vm.startPrank(this.owner());
         this.approveNewTEEVersion(mrtd);
-        vm.expectRevert(bytes("Invalid report MRTD"));
-        this.verifyBootstrapResult(
-            bootstrapResult,
-            quote,
-            signature
-        );
+        vm.expectRevert(TEELifecycle.InvalidReportMRTD.selector);
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
         vm.stopPrank();
     }
 
-    function test_invalidSignature() public {
-        (BootstrapResult memory bootstrapResult, , , bytes memory quote, , bytes memory mrtd) = successfulBootstrapResult();
-        (uint256 bootstrapPartyFakePrivkey, ) = getLabeledKeyPair("bootstrapPartyFake");
-        bytes memory signatureInvalid = signBootstrapResult(bootstrapResult, bootstrapPartyFakePrivkey);
-        vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrtd);
-        vm.expectRevert(bytes("Invalid signature for bootstrap data"));
-        this.verifyBootstrapResult(
+    function testInvalidSignature() public {
+        (
+            BootstrapResult memory bootstrapResult,
+            ,
+            ,
+            bytes memory quote,
+            ,
+            bytes memory mrtd
+        ) = successfulBootstrapResult();
+        (uint256 bootstrapPartyFakePrivkey, ) = getLabeledKeyPair(
+            "bootstrapPartyFake"
+        );
+        bytes memory signatureInvalid = signBootstrapResult(
             bootstrapResult,
-            quote,
-            signatureInvalid
+            bootstrapPartyFakePrivkey
         );
+        vm.startPrank(this.owner());
+        this.approveNewTEEVersion(mrtd);
+        vm.expectRevert(TEELifecycle.InvalidBootstrapDataSignature.selector);
+        this.verifyBootstrapResult(bootstrapResult, quote, signatureInvalid);
         vm.stopPrank();
     }
 
-    function test_bootstrapAlreadyComplete() public {
-        (BootstrapResult memory bootstrapResult, , , bytes memory quote, bytes memory signature, bytes memory mrtd) = successfulBootstrapResult();
+    function testBootstrapAlreadyComplete() public {
+        (
+            BootstrapResult memory bootstrapResult,
+            ,
+            ,
+            bytes memory quote,
+            bytes memory signature,
+            bytes memory mrtd
+        ) = successfulBootstrapResult();
         vm.startPrank(this.owner());
         this.approveNewTEEVersion(mrtd);
-        this.verifyBootstrapResult(
-            bootstrapResult,
-            quote,
-            signature
-        );
-        vm.expectRevert(bytes("Bootstrap already completed"));
-        this.verifyBootstrapResult(
-            bootstrapResult,
-            quote,
-            signature
-        );
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
+        vm.expectRevert(TEELifecycle.BootstrapAlreadyCompleted.selector);
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
         vm.stopPrank();
     }
 
-    function test_approveNewTEEInvalidMrtd() public {
+    function testApproveNewTEEInvalidMrtd() public {
         bytes memory mrtd = hex"deadbeef";
         vm.startPrank(this.owner());
-        vm.expectRevert(bytes("MRTD must be 48 bytes"));
+        vm.expectRevert(TEELifecycle.MrtdInvalidLength.selector);
         this.approveNewTEEVersion(mrtd);
         vm.stopPrank();
     }
 
-    function test_bootstrapNotCompleteNewCoval() public {
-        bytes memory mrtd = hex"2a90c8fa38672cafd791d994beb6836b99383b2563736858632284f0f760a6446efd1e7ec457cf08b629ea630f7b4525";
+    function testBootstrapNotCompleteNewCoval() public {
+        bytes
+            memory mrtd = hex"2a90c8fa38672cafd791d994beb6836b99383b2563736858632284f0f760a6446efd1e7ec457cf08b629ea630f7b4525";
         (, address newCoval) = getLabeledKeyPair("newCoval");
         bytes memory quote = createQuote(mrtd, newCoval);
         vm.startPrank(this.owner());
-        vm.expectRevert(bytes("Bootstrap not complete"));
+        vm.expectRevert(TEELifecycle.BootstrapNotComplete.selector);
         this.addNewCovalidator(quote);
         vm.stopPrank();
     }
 
-    function test_invalidMrtdNewCoval() public {
-        (BootstrapResult memory bootstrapResult, , , bytes memory quote, bytes memory signature, bytes memory mrtd) = successfulBootstrapResult();
+    function testInvalidMrtdNewCoval() public {
+        (
+            BootstrapResult memory bootstrapResult,
+            ,
+            ,
+            bytes memory quote,
+            bytes memory signature,
+            bytes memory mrtd
+        ) = successfulBootstrapResult();
         vm.startPrank(this.owner());
         this.approveNewTEEVersion(mrtd);
-        this.verifyBootstrapResult(
-            bootstrapResult,
-            quote,
-            signature
-        );
-        bytes memory badMrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
+        bytes
+            memory badMrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
         (, address newCoval) = getLabeledKeyPair("newCoval");
         bytes memory quoteNew = createQuote(badMrtd, newCoval);
-        
-        vm.expectRevert(bytes("Invalid report MRTD"));
+
+        vm.expectRevert(TEELifecycle.InvalidMrtdReport.selector);
         this.addNewCovalidator(quoteNew);
         vm.stopPrank();
     }
 
     // Helper function to create a successful bootstrap result
-    function successfulBootstrapResult() internal returns (BootstrapResult memory bootstrapResult, uint256 bootstrapPartyPrivkey, address bootstrapPartyAddress, bytes memory quote, bytes memory signature, bytes memory mrtd) {
-        (bootstrapPartyPrivkey, bootstrapPartyAddress) = getLabeledKeyPair("bootstrapParty");
-        bytes memory eciesPubkey = hex"04ff5c6dd72ad7583288b84ee2598e081fe0bc6ef543c342e925a5dfcff9afb2444d25454d7d5dcfadc9ed99477c245efa93caf58d7f58143300d81cc948e7bdf5";
+    function successfulBootstrapResult()
+        internal
+        returns (
+            BootstrapResult memory bootstrapResult,
+            uint256 bootstrapPartyPrivkey,
+            address bootstrapPartyAddress,
+            bytes memory quote,
+            bytes memory signature,
+            bytes memory mrtd
+        )
+    {
+        (bootstrapPartyPrivkey, bootstrapPartyAddress) = getLabeledKeyPair(
+            "bootstrapParty"
+        );
+        bytes
+            memory eciesPubkey = hex"04ff5c6dd72ad7583288b84ee2598e081fe0bc6ef543c342e925a5dfcff9afb2444d25454d7d5dcfadc9ed99477c245efa93caf58d7f58143300d81cc948e7bdf5";
         mrtd = hex"2a90c8fa38672cafd791d994beb6836b99383b2563736858632284f0f760a6446efd1e7ec457cf08b629ea630f7b4525";
 
-        bootstrapResult = BootstrapResult({
-            ecies_pubkey: eciesPubkey
-        });
+        bootstrapResult = BootstrapResult({ecies_pubkey: eciesPubkey});
 
-        quote = createQuote(
-            mrtd,
-            bootstrapPartyAddress
-        );
+        quote = createQuote(mrtd, bootstrapPartyAddress);
         signature = signBootstrapResult(bootstrapResult, bootstrapPartyPrivkey);
     }
-    
+
     // Helper function to sign the bootstrap result
     function signBootstrapResult(
         BootstrapResult memory bootstrapResult,
         uint256 privateKey
     ) internal view returns (bytes memory) {
-        bytes32 bootstrapResultDigest = bootstrapResultDigest(
-            bootstrapResult
-        );
+        bytes32 bootstrapResultDigest = bootstrapResultDigest(bootstrapResult);
         return getSignatureForDigest(bootstrapResultDigest, privateKey);
     }
-
-}
+}

package/src/test/TestAddTwo.t.sol

@@ -7,9 +7,15 @@ import {IncoTest} from "./IncoTest.sol";
 import {AddTwo} from "./AddTwo.sol";
 
 contract TestAddTwo is IncoTest {
-    function testAddTwo() public {
-        AddTwo addTwo = new AddTwo(inco);
+    AddTwo addTwo;
+
+    function setUp() public override {
+        super.setUp();
+        addTwo = new AddTwo(inco);
         vm.label(address(addTwo), "addTwo");
+    }
+
+    function testAddTwo() public {
         euint256 a = inco.asEuint256(3);
         inco.allow(euint256.unwrap(a), address(addTwo));
         euint256 b = addTwo.addTwo(a);
@@ -17,13 +23,14 @@ contract TestAddTwo is IncoTest {
         assertEq(getUint256Value(b), 5);
     }
 
-    function testAddTwoScalar() public {
-        AddTwo addTwo = new AddTwo(inco);
-        vm.label(address(addTwo), "addTwoScalar");
-        euint256 a = inco.asEuint256(3);
-        inco.allow(euint256.unwrap(a), address(addTwo));
-        euint256 b = addTwo.addTwoScalar(a);
+    function testAddTwoEoaAndPublicReveal() public {
+        (euint256 result, euint256 revealedResult) = addTwo.addTwoEOA(
+            fakePrepareEuint256Ciphertext(3)
+        );
         processAllOperations();
-        assertEq(getUint256Value(b), 5);
+        assertEq(getUint256Value(result), 5);
+        assertEq(getUint256Value(revealedResult), 5);
+        assertFalse(inco.isAllowed(euint256.unwrap(result), bob));
+        assertTrue(inco.isAllowed(euint256.unwrap(revealedResult), bob));
     }
 }

package/src/test/TestFakeInfra.t.sol

@@ -2,13 +2,14 @@
 pragma solidity ^0.8;
 
 import {IncoTest} from "./IncoTest.sol";
-import {e, euint256, ebool, eaddress} from "../Lib.sol";
+import {e, euint256, ebool, eaddress, inco} from "../Lib.sol";
 import {SenderNotAllowedForHandle} from "../Types.sol";
 import {TEELifecycle} from "../lightning-parts/TEELifecycle.sol";
 import {MockRemoteAttestation} from "./FakeIncoInfra/MockRemoteAttestation.sol";
-
-import {MINIMUM_QUOTE_LENGTH} from "@automata-network/dcap-attestation/types/Constants.sol";
-import {TD10ReportBody} from "@automata-network/dcap-attestation/types/V4Structs.sol";
+import {
+    TD10ReportBody,
+    MINIMUM_QUOTE_LENGTH
+} from "../interfaces/automata-interfaces/Types.sol";
 
 contract TakesEInput {
     using e for bytes;
@@ -26,18 +27,6 @@ contract TakesEInput {
     function setB(bytes memory boolEInput) external {
         b = boolEInput.newEbool(msg.sender);
     }
-
-    function decryptA() external {
-        a.requestDecryption(this.aDecryptionCallback.selector, "");
-    }
-
-    function aDecryptionCallback(
-        uint256,
-        uint256 _decryptedA,
-        bytes memory
-    ) external {
-        decryptedA = _decryptedA;
-    }
 }
 
 // its meta: this is testing correct behavior of our testing infrastructure
@@ -288,14 +277,6 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
         assertEq(getBoolValue(inputContract.b()), true);
     }
 
-    function testDecryption() public {
-        TakesEInput inputContract = new TakesEInput();
-        inputContract.setA(fakePrepareEuint256Ciphertext(37));
-        inputContract.decryptA();
-        processAllOperations();
-        assertEq(inputContract.decryptedA(), 37);
-    }
-
     function testUninitializedHandleIsDisallowed() public {
         bytes32 randomHandle = keccak256("random handle");
         euint256 a = e.asEuint256(12);
@@ -310,12 +291,14 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
     }
 
     function testCreateQuote() public {
-        bytes memory mrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        bytes
+            memory mrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
         address signer = address(0x1234567890123456789012345678901234567890);
         bytes memory quote = createQuote(mrtd, signer);
-        TEELifecycle lifecycle = new TEELifecycle();
+        TEELifecycle lifecycle = TEELifecycle(address(inco.incoVerifier()));
         TD10ReportBody memory tdReport = lifecycle.parseTD10ReportBody(quote);
-        (address reportDataSigner, bytes memory reportMrtd) = lifecycle.parseReport(tdReport);
+        (address reportDataSigner, bytes memory reportMrtd) = lifecycle
+            .parseReport(tdReport);
         assertEq(reportDataSigner, signer);
         assertEq(keccak256(reportMrtd), keccak256(mrtd));
         assertEq(quote.length, MINIMUM_QUOTE_LENGTH);

package/src/test/TestUpgrade.t.sol

@@ -9,6 +9,9 @@ import {IOwnerManager} from "safe-smart-account/interfaces/IOwnerManager.sol";
 import {IncoTest} from "./IncoTest.sol";
 import {inco} from "../Lib.sol";
 import {IncoLightning} from "../IncoLightning.sol";
+import {IVersion} from "../version/interfaces/IVersion.sol";
+import {Version} from "../version/Version.sol";
+import {IIncoVerifier} from "../interfaces/IIncoVerifier.sol";
 import {
     MAJOR_VERSION,
     MINOR_VERSION,
@@ -27,9 +30,15 @@ contract IncoLightningV2 is IncoLightning {
     uint8 constant MINOR_VERSION_MOCK = 255;
     uint8 constant PATCH_VERSION_MOCK = 255;
 
-    constructor(bytes32 salt) IncoLightning(salt) {}
+    constructor(bytes32 salt) IncoLightning(salt, IIncoVerifier(address(0))) {}
 
-    function getVersion() public view virtual override returns (string memory) {
+    function getVersion()
+        public
+        view
+        virtual
+        override(IVersion, Version)
+        returns (string memory)
+    {
         return
             versionString(
                 MAJOR_VERSION_MOCK,
@@ -86,8 +95,6 @@ contract TestUpgrade is IncoTest {
         bytes32 salt = getSalt(
             "IncoLightningV2",
             255,
-            255,
-            255,
             testDeployer,
             "testnet"
         );

package/src/test/TestVersion.t.sol

@@ -26,11 +26,4 @@ contract TestVersion is Test {
             "SomeContract_1_2_3__12345678"
         );
     }
-
-    function testVersionEip712() public view {
-        (, string memory name, string memory version, , , , ) = someContract
-            .eip712Domain();
-        assertEq(name, "SomeContract");
-        assertEq(version, "1_2_3");
-    }
 }

package/src/version/IncoLightningConfig.sol

@@ -4,10 +4,11 @@ pragma solidity ^0.8;
 // Change these constants for new contracts
 // Since this file only contains these constants, it could be generated reacting to cli inputs
 
-// IMPORTANT if you are changing this file, run `make update_config` afterwards for it to take effect
 // UPDATE the CHANGELOG on new versions
 
 string constant CONTRACT_NAME = "incoLightning";
-uint8 constant MAJOR_VERSION = 0;
-uint8 constant MINOR_VERSION = 2;
-uint8 constant PATCH_VERSION = 1;
+uint8 constant MAJOR_VERSION = 1;
+uint8 constant MINOR_VERSION = 0;
+uint8 constant PATCH_VERSION = 0;
+
+string constant VERIFIER_NAME = "incoVerifier";

package/src/version/SessionVerifierConfig.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+string constant SESSION_VERIFIER_NAME = "sessionVerifier";
+uint8 constant SESSION_VERIFIER_MAJOR_VERSION = 0;
+uint8 constant SESSION_VERIFIER_MINOR_VERSION = 1;
+uint8 constant SESSION_VERIFIER_PATCH_VERSION = 2;
+bytes32 constant SESSION_VERIFIER_PEPPER = keccak256("");

package/src/version/Version.sol

@@ -2,10 +2,13 @@
 pragma solidity ^0.8;
 
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
-import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
-import {ShortStrings, ShortString} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+import {
+    ShortStrings,
+    ShortString
+} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+import {IVersion} from "./interfaces/IVersion.sol";
 
-contract Version is EIP712 {
+contract Version is IVersion {
     using ShortStrings for ShortString;
     using ShortStrings for string;
 
@@ -21,12 +24,7 @@ contract Version is EIP712 {
         uint8 _patchVersion,
         bytes32 _salt,
         string memory _name
-    )
-        EIP712(
-            _name,
-            versionString(_majorVersion, _minorVersion, _patchVersion)
-        )
-    {
+    ) {
         majorVersion = _majorVersion;
         minorVersion = _minorVersion;
         patchVersion = _patchVersion;

package/src/version/interfaces/IVersion.sol

@@ -0,0 +1,8 @@
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+interface IVersion {
+    function getVersionedName() external view returns (string memory);
+    function getVersion() external view returns (string memory);
+    function getName() external view returns (string memory);
+}