@inco/lightning 0.6.8 → 0.7.0

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

@@ -5,92 +5,64 @@ import {TEELifecycle} from "../../lightning-parts/TEELifecycle.sol";
 import {BootstrapResult, AddNodeResult} from "../../lightning-parts/TEELifecycle.types.sol";
 import {MockRemoteAttestation} from "../FakeIncoInfra/MockRemoteAttestation.sol";
 import {FakeQuoteVerifier} from "../FakeIncoInfra/FakeQuoteVerifier.sol";
-import {Test} from "forge-std/Test.sol";
 
-contract TEELifecycleMockTest is Test, MockRemoteAttestation, TEELifecycle {
+contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
+
     // Constants for testing
-    bytes testNetworkPubkey = hex"04ff5c6dd72ad7583288b84ee2598e081fe0bc6ef543c342e925a5dfcff9afb2444d25454d7d5dcfadc9ed99477c245efa93caf58d7f58143300d81cc948e7bdf5";
+    bytes testNetworkPubkey = hex"02516bda9e68a1c3dce74dc1b6ed7d91a91d51c1e1933947f06331cef59631e9eb";
     // See DEFAULT_MRTD in attestation/src/remote_attestation.rs
-    bytes testMrtd = hex"010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101";
+    bytes testMrtd =
+        hex"010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101";
     // See DEFAULT_MR_AGGREGATED in attestation/src/remote_attestation.rs to
     // see the calculation of the default value.
     bytes32 testMrAggregated = hex"c3a67bac251d4946d7b17481d39631676042fe3afab06e70c22105ad8383c19f";
 
     function setUp() public {
-        getTEELifecycleStorage().quoteVerifier = new FakeQuoteVerifier();
+        getTeeLifecycleStorage().quoteVerifier = new FakeQuoteVerifier();
     }
 
     function testSuccessfulBootstrap() public {
-        (
-            BootstrapResult memory bootstrapResult,
-            ,
-            ,
-            bytes memory quote,
-            bytes memory signature,
-            bytes32 mrAggregated
-        ) = successfulBootstrapResult();
+        (BootstrapResult memory bootstrapResult,,, bytes memory quote, bytes memory signature, bytes32 mrAggregated) =
+            successfulBootstrapResult();
         vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrAggregated);
+        this.approveNewTeeVersion(mrAggregated);
         this.verifyBootstrapResult(bootstrapResult, quote, signature);
         assertTrue(this.isBootstrapComplete(), "Bootstrap should be complete");
         vm.stopPrank();
     }
 
     function testInvalidMrtd() public {
-        bytes
-            memory badMrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        bytes memory badMrtd =
+            hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
 
-        (
-            BootstrapResult memory bootstrapResult,
-            ,
-            address bootstrapPartyAddress,
-            bytes memory quote,
-            bytes memory signature,
-            bytes32 mrAggregated
-        ) = successfulBootstrapResult();
+        (BootstrapResult memory bootstrapResult, bytes memory quote, bytes memory signature, bytes32 mrAggregated) =
+            successfulBootstrapResult(this, testNetworkPubkey, teeEOA, teePrivKey);
 
-        quote = createQuote(badMrtd, bootstrapPartyAddress); // Replace with bad MRTD
+        quote = createQuote(badMrtd, teeEOA); // Replace with bad MRTD
         vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrAggregated);
+        this.approveNewTeeVersion(mrAggregated);
         vm.expectRevert(TEELifecycle.InvalidReportMrAggregated.selector);
         this.verifyBootstrapResult(bootstrapResult, quote, signature);
         vm.stopPrank();
     }
 
     function testInvalidSignature() public {
-        (
-            BootstrapResult memory bootstrapResult,
-            ,
-            ,
-            bytes memory quote,
-            ,
-            bytes32 mrAggregated
-        ) = successfulBootstrapResult();
-        (uint256 bootstrapPartyFakePrivkey, ) = getLabeledKeyPair(
-            "bootstrapPartyFake"
-        );
-        bytes memory signatureInvalid = signBootstrapResult(
-            bootstrapResult,
-            bootstrapPartyFakePrivkey
-        );
+        (BootstrapResult memory bootstrapResult,,, bytes memory quote,, bytes32 mrAggregated) =
+            successfulBootstrapResult();
+        (uint256 bootstrapPartyFakePrivkey,) = getLabeledKeyPair("bootstrapPartyFake");
+        bytes memory signatureInvalid = signBootstrapResult(bootstrapResult, bootstrapPartyFakePrivkey);
         vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrAggregated);
+        this.approveNewTeeVersion(mrAggregated);
         vm.expectRevert(TEELifecycle.InvalidEIP712Signature.selector);
         this.verifyBootstrapResult(bootstrapResult, quote, signatureInvalid);
         vm.stopPrank();
     }
 
     function testBootstrapAlreadyComplete() public {
-        (
-            BootstrapResult memory bootstrapResult,
-            ,
-            ,
-            bytes memory quote,
-            bytes memory signature,
-            bytes32 mrAggregated
-        ) = successfulBootstrapResult();
+        (BootstrapResult memory bootstrapResult,,, bytes memory quote, bytes memory signature, bytes32 mrAggregated) =
+            successfulBootstrapResult();
         vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrAggregated);
+        this.approveNewTeeVersion(mrAggregated);
         this.verifyBootstrapResult(bootstrapResult, quote, signature);
         vm.expectRevert(TEELifecycle.BootstrapAlreadyCompleted.selector);
         this.verifyBootstrapResult(bootstrapResult, quote, signature);
@@ -98,77 +70,57 @@ contract TEELifecycleMockTest is Test, MockRemoteAttestation, TEELifecycle {
     }
 
     function testAddNodeBootstrapNotComplete() public {
-        bytes
-            memory mrtd = hex"2a90c8fa38672cafd791d994beb6836b99383b2563736858632284f0f760a6446efd1e7ec457cf08b629ea630f7b4525";
+        bytes memory mrtd =
+            hex"2a90c8fa38672cafd791d994beb6836b99383b2563736858632284f0f760a6446efd1e7ec457cf08b629ea630f7b4525";
         (, address newCoval) = getLabeledKeyPair("newCoval");
         bytes memory quote = createQuote(mrtd, newCoval);
         vm.startPrank(this.owner());
         vm.expectRevert(TEELifecycle.BootstrapNotComplete.selector);
-        this.verifyAddNodeResult(testMrAggregated, AddNodeResult({network_pubkey: hex"00"}), quote, hex"");
+        this.verifyAddNodeResult(testMrAggregated, AddNodeResult({networkPubkey: hex"00"}), quote, hex"");
         vm.stopPrank();
     }
 
     function testAddNodeInvalidMrtd() public {
-        (
-            BootstrapResult memory bootstrapResult,
-            ,
-            ,
-            bytes memory quote,
-            bytes memory signature,
-            bytes32 mrAggregated
-        ) = successfulBootstrapResult();
+        (BootstrapResult memory bootstrapResult,,, bytes memory quote, bytes memory signature, bytes32 mrAggregated) =
+            successfulBootstrapResult();
         vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrAggregated);
+        this.approveNewTeeVersion(mrAggregated);
         this.verifyBootstrapResult(bootstrapResult, quote, signature);
-        bytes
-            memory badMrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        bytes memory badMrtd =
+            hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
         (, address newCoval) = getLabeledKeyPair("newCoval");
         bytes memory badQuote = createQuote(badMrtd, newCoval);
         vm.expectRevert(TEELifecycle.InvalidReportMrAggregated.selector);
-        this.verifyAddNodeResult(mrAggregated, AddNodeResult({network_pubkey: testNetworkPubkey}), badQuote, signature);
+        this.verifyAddNodeResult(mrAggregated, AddNodeResult({networkPubkey: testNetworkPubkey}), badQuote, signature);
         vm.stopPrank();
     }
 
     function testAddNodeInvalidNetworkPubkey() public {
-        (
-            BootstrapResult memory bootstrapResult,
-            ,
-            ,
-            bytes memory quote,
-            bytes memory signature,
-            bytes32 mrAggregated
-        ) = successfulBootstrapResult();
+        (BootstrapResult memory bootstrapResult,,, bytes memory quote, bytes memory signature, bytes32 mrAggregated) =
+            successfulBootstrapResult();
         vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrAggregated);
+        this.approveNewTeeVersion(mrAggregated);
         this.verifyBootstrapResult(bootstrapResult, quote, signature);
         vm.expectRevert(TEELifecycle.InvalidNetworkPubkey.selector);
-        this.verifyAddNodeResult(testMrAggregated, AddNodeResult({network_pubkey: hex"00"}), quote, signature);
+        this.verifyAddNodeResult(testMrAggregated, AddNodeResult({networkPubkey: hex"00"}), quote, signature);
         vm.stopPrank();
     }
 
     function testAddNodeInvalidSignature() public {
-        (
-            BootstrapResult memory bootstrapResult,
-            ,
-            ,
-            bytes memory quote,
-            bytes memory signature,
-            bytes32 mrAggregated
-        ) = successfulBootstrapResult();
+        (BootstrapResult memory bootstrapResult,,, bytes memory quote, bytes memory signature, bytes32 mrAggregated) =
+            successfulBootstrapResult();
         vm.startPrank(this.owner());
-        this.approveNewTEEVersion(mrAggregated);
+        this.approveNewTeeVersion(mrAggregated);
         this.verifyBootstrapResult(bootstrapResult, quote, signature);
 
-        (uint256 maliciousNewNodePrivkey,) = getLabeledKeyPair(
-            "maliciousNewNode"
-        );
-        bytes memory badSignature = signAddNodeResult(
-            AddNodeResult({network_pubkey: testNetworkPubkey}),
-            maliciousNewNodePrivkey
-        );
+        (uint256 maliciousNewNodePrivkey,) = getLabeledKeyPair("maliciousNewNode");
+        bytes memory badSignature =
+            signAddNodeResult(AddNodeResult({networkPubkey: testNetworkPubkey}), maliciousNewNodePrivkey);
 
         vm.expectRevert(TEELifecycle.InvalidEIP712Signature.selector);
-        this.verifyAddNodeResult(testMrAggregated, AddNodeResult({network_pubkey: testNetworkPubkey}), quote, badSignature);
+        this.verifyAddNodeResult(
+            testMrAggregated, AddNodeResult({networkPubkey: testNetworkPubkey}), quote, badSignature
+        );
         vm.stopPrank();
     }
 
@@ -184,9 +136,7 @@ contract TEELifecycleMockTest is Test, MockRemoteAttestation, TEELifecycle {
             bytes32 mrAggregated
         )
     {
-        (bootstrapPartyPrivkey, bootstrapPartyAddress) = getLabeledKeyPair(
-            "bootstrapParty"
-        );
+        (bootstrapPartyPrivkey, bootstrapPartyAddress) = getLabeledKeyPair("bootstrapParty");
         mrAggregated = testMrAggregated;
         bootstrapResult = BootstrapResult({ecies_pubkey: testNetworkPubkey});
 
@@ -195,20 +145,23 @@ contract TEELifecycleMockTest is Test, MockRemoteAttestation, TEELifecycle {
     }
 
     // Helper function to sign the bootstrap result
-    function signBootstrapResult(
-        BootstrapResult memory bootstrapResult,
-        uint256 privateKey
-    ) internal view returns (bytes memory) {
+    function signBootstrapResult(BootstrapResult memory bootstrapResult, uint256 privateKey)
+        internal
+        view
+        returns (bytes memory)
+    {
         bytes32 bootstrapResultDigest = bootstrapResultDigest(bootstrapResult);
         return getSignatureForDigest(bootstrapResultDigest, privateKey);
     }
 
     // Helper function to sign the add node result
-    function signAddNodeResult(
-        AddNodeResult memory addNodeResult,
-        uint256 privateKey
-    ) internal view returns (bytes memory) {
+    function signAddNodeResult(AddNodeResult memory addNodeResult, uint256 privateKey)
+        internal
+        view
+        returns (bytes memory)
+    {
         bytes32 addNodeResultDigest = addNodeResultDigest(addNodeResult);
         return getSignatureForDigest(addNodeResultDigest, privateKey);
     }
+
 }

package/src/test/TestAddTwo.t.sol

@@ -7,6 +7,7 @@ import {IncoTest} from "./IncoTest.sol";
 import {AddTwo} from "./AddTwo.sol";
 
 contract TestAddTwo is IncoTest {
+
     AddTwo addTwo;
 
     function setUp() public override {
@@ -25,9 +26,8 @@ contract TestAddTwo is IncoTest {
     }
 
     function testAddTwoEoaAndPublicReveal() public {
-        (euint256 result, euint256 revealedResult) = addTwo.addTwoEOA(
-            fakePrepareEuint256Ciphertext(3, address(this), address(addTwo))
-        );
+        (euint256 result, euint256 revealedResult) =
+            addTwo.addTwoEoa(fakePrepareEuint256Ciphertext(3, address(this), address(addTwo)));
         processAllOperations();
         assertEq(getUint256Value(result), 5);
         assertEq(getUint256Value(revealedResult), 5);
@@ -41,4 +41,5 @@ contract TestAddTwo is IncoTest {
         assertEq(getBoolValue(trueVal), true);
         assertTrue(inco.isAllowed(ebool.unwrap(trueVal), bob));
     }
+
 }

package/src/test/TestDeploy.t.sol

@@ -9,24 +9,22 @@ import {inco} from "../Lib.sol";
 import {IncoTest} from "./IncoTest.sol";
 
 contract ReturnTwo is UUPSUpgradeable {
+
     function getTwo() external pure returns (uint256) {
         return 2;
     }
 
     function _authorizeUpgrade(address) internal override {}
+
 }
 
 contract TestDeploy is Test, IncoTest {
+
     // todo test that inco gets deployed at the predicted address
 
     function testDeployedCorrectly() public {
         vm.expectEmit(false, false, true, false, address(inco));
-        emit TrivialEncryption.TrivialEncrypt(
-            bytes32(uint256(1)),
-            bytes32(uint256(1)),
-            ETypes.Bool,
-            0
-        );
+        emit TrivialEncryption.TrivialEncrypt(bytes32(uint256(1)), bytes32(uint256(1)), ETypes.Bool, 0);
         inco.asEbool(true);
     }
 
@@ -36,4 +34,5 @@ contract TestDeploy is Test, IncoTest {
         inco.upgradeToAndCall(address(newImplem), "");
         assertEq(ReturnTwo(address(inco)).getTwo(), 2);
     }
+
 }

package/src/test/TestExtractDataOfEventTooLarge.t.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8;
 
 import {Test, Vm, console} from "forge-std/Test.sol";
 
-event EventTooLarge(
-    bytes32 control, // can't index >3 fields
+event EventTooLarge( // can't index >3 fields
+    bytes32 control,
     bytes32 indexed ifTrue,
     bytes32 indexed ifFalse,
     bytes32 indexed result,
@@ -12,18 +12,15 @@ event EventTooLarge(
 );
 
 contract Emitter {
+
     function emitEventTooLarge() external {
-        emit EventTooLarge(
-            bytes32(uint256(1)),
-            bytes32(uint256(2)),
-            bytes32(uint256(3)),
-            bytes32(uint256(4)),
-            5
-        );
+        emit EventTooLarge(bytes32(uint256(1)), bytes32(uint256(2)), bytes32(uint256(3)), bytes32(uint256(4)), 5);
     }
+
 }
 
 contract TestExtractDataOfEventTooLarge is Test {
+
     function testEmit() public {
         Emitter emitter = new Emitter();
         vm.recordLogs();
@@ -40,4 +37,5 @@ contract TestExtractDataOfEventTooLarge is Test {
         assertEq(first32Bytes, bytes32(uint256(1)));
         assertEq(second32Bytes, bytes32(uint256(5)));
     }
+
 }

package/src/test/TestFakeInfra.t.sol

@@ -5,13 +5,10 @@ import {IncoTest} from "./IncoTest.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 {
-    TD10ReportBody,
-    MINIMUM_QUOTE_LENGTH
-} from "../interfaces/automata-interfaces/Types.sol";
+import {Td10ReportBody, MINIMUM_QUOTE_LENGTH} from "../interfaces/automata-interfaces/Types.sol";
 
 contract TakesEInput is IncoTest {
+
     using e for bytes;
     using e for euint256;
 
@@ -27,10 +24,12 @@ contract TakesEInput is IncoTest {
     function setB(bytes memory boolEInput) external {
         b = boolEInput.newEbool(msg.sender);
     }
+
 }
 
 // its meta: this is testing correct behavior of our testing infrastructure
-contract TestFakeInfra is IncoTest, MockRemoteAttestation {
+contract TestFakeInfra is IncoTest {
+
     using e for euint256;
     using e for ebool;
     using e for uint256;
@@ -153,10 +152,7 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
         euint256 b = e.asEuint256(4);
         euint256 c = a.rotr(b);
         processAllOperations();
-        assertEq(
-            getUint256Value(c),
-            72370055773322622139731865630429942408293740416025352524660990004945706024960
-        );
+        assertEq(getUint256Value(c), 72370055773322622139731865630429942408293740416025352524660990004945706024960);
     }
 
     function testEEq() public {
@@ -272,17 +268,9 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
         TakesEInput inputContract = new TakesEInput();
         vm.deal(address(inputContract), 1 ether);
         address self = address(this);
-        bytes memory ciphertext = fakePrepareEuint256Ciphertext(
-            12,
-            self,
-            address(inputContract)
-        );
+        bytes memory ciphertext = fakePrepareEuint256Ciphertext(12, self, address(inputContract));
         inputContract.setA(ciphertext);
-        inputContract.setB(
-            fakePrepareEboolCiphertext(true,
-                self,
-                address(inputContract)
-            ));
+        inputContract.setB(fakePrepareEboolCiphertext(true, self, address(inputContract)));
         processAllOperations();
         assertEq(getUint256Value(inputContract.a()), 12);
         assertEq(getBoolValue(inputContract.b()), true);
@@ -291,35 +279,24 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
     function testUninitializedHandleIsDisallowed() public {
         bytes32 randomHandle = keccak256("random handle");
         euint256 a = e.asEuint256(12);
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                SenderNotAllowedForHandle.selector,
-                randomHandle,
-                address(this)
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(SenderNotAllowedForHandle.selector, randomHandle, address(this)));
         a.add(euint256.wrap(randomHandle));
     }
 
     function testCreateQuote() public view {
-        bytes
-            memory mrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        bytes memory mrtd =
+            hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
         address signer = address(0x1234567890123456789012345678901234567890);
         bytes memory quote = createQuote(mrtd, signer);
         TEELifecycle lifecycle = TEELifecycle(address(inco.incoVerifier()));
-        TD10ReportBody memory tdReport = lifecycle.parseTD10ReportBody(quote);
-        (address reportDataSigner, bytes32 reportMrAggregated) = lifecycle
-            .parseReport(tdReport);
+        Td10ReportBody memory tdReport = lifecycle.parseTd10ReportBody(quote);
+        (address reportDataSigner, bytes32 reportMrAggregated) = lifecycle.parseReport(tdReport);
         assertEq(reportDataSigner, signer);
         assertEq(
             reportMrAggregated,
-            lifecycle.computeMrAggregated(
-                tdReport.mrTd,
-                tdReport.rtMr0,
-                tdReport.rtMr1,
-                tdReport.rtMr2
-            )
+            lifecycle.computeMrAggregated(tdReport.mrTd, tdReport.rtMr0, tdReport.rtMr1, tdReport.rtMr2)
         );
         assertEq(quote.length, MINIMUM_QUOTE_LENGTH);
     }
+
 }