@inco/lightning 0.9.0-devnet-test-10 → 0.10.0-devnet-1

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

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.0;
+pragma solidity ^0.8;
 
 import {TEELifecycle} from "../../lightning-parts/TEELifecycle.sol";
 import {BootstrapResult, AddNodeResult, UpgradeResult} from "../../lightning-parts/TEELifecycle.types.sol";
@@ -24,7 +24,8 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
         hex"010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101";
     // See DEFAULT_MR_AGGREGATED in attestation/src/remote_attestation.rs to
     // see the calculation of the default value.
-    bytes32 testMrAggregated = hex"c3a67bac251d4946d7b17481d39631676042fe3afab06e70c22105ad8383c19f";
+    // Note: This uses abi.encode (not encodePacked) to avoid hash collision vulnerabilities.
+    bytes32 testMrAggregated = hex"3d48a1faa8620d86ae037f4fd6746987733d085314b3cd5d5d074ade8bab6ebd";
 
     function setUp() public {
         getTeeLifecycleStorage().quoteVerifier = new FakeQuoteVerifier();
@@ -133,61 +134,6 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
         vm.stopPrank();
     }
 
-    function testRemoveApprovedTeeVersionPreservesOrder() public {
-        bytes32 mrAggregated1 = hex"1111111111111111111111111111111111111111111111111111111111111111";
-        bytes32 mrAggregated2 = hex"2222222222222222222222222222222222222222222222222222222222222222";
-        bytes32 mrAggregated3 = hex"3333333333333333333333333333333333333333333333333333333333333333";
-
-        vm.startPrank(this.owner());
-
-        // Add three versions
-        this.approveNewTeeVersion(mrAggregated1);
-        this.approveNewTeeVersion(mrAggregated2);
-        this.approveNewTeeVersion(mrAggregated3);
-
-        // Verify all exist in order
-        assertEq(this.approvedTeeVersions(0), mrAggregated1);
-        assertEq(this.approvedTeeVersions(1), mrAggregated2);
-        assertEq(this.approvedTeeVersions(2), mrAggregated3);
-
-        // Remove the middle one (mrAggregated2)
-        this.removeApprovedTeeVersion(mrAggregated2);
-
-        // Verify insertion order is preserved: mrAggregated1 stays at 0, mrAggregated3 shifts to 1
-        assertEq(this.approvedTeeVersions(0), mrAggregated1);
-        assertEq(this.approvedTeeVersions(1), mrAggregated3);
-
-        // Verify index 2 is now out of bounds
-        vm.expectRevert(TEELifecycle.IndexOutOfBounds.selector);
-        this.approvedTeeVersions(2);
-
-        vm.stopPrank();
-    }
-
-    function testRemoveApprovedTeeVersionNotFound() public {
-        bytes32 nonExistentMrAggregated = hex"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-
-        vm.startPrank(this.owner());
-        vm.expectRevert(TEELifecycle.TEEVersionNotFound.selector);
-        this.removeApprovedTeeVersion(nonExistentMrAggregated);
-        vm.stopPrank();
-    }
-
-    function testRemoveApprovedTeeVersionOnlyOwner() public {
-        bytes32 mrAggregated = hex"1111111111111111111111111111111111111111111111111111111111111111";
-
-        vm.startPrank(this.owner());
-        this.approveNewTeeVersion(mrAggregated);
-        vm.stopPrank();
-
-        // Try to remove as non-owner
-        address nonOwner = address(0x1234);
-        vm.startPrank(nonOwner);
-        vm.expectRevert();
-        this.removeApprovedTeeVersion(mrAggregated);
-        vm.stopPrank();
-    }
-
     // Helper function to create a successful bootstrap result
     function successfulBootstrapResult()
         internal
@@ -310,6 +256,7 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
 
     function testVerifyUpgradeResult_BootstrapNotComplete() public {
         UpgradeResult memory upgradeResult = UpgradeResult({networkPubkey: testNetworkPubkey});
+        vm.prank(this.owner());
         vm.expectRevert(TEELifecycle.BootstrapNotComplete.selector);
         this.verifyUpgradeResult(testMrAggregated, upgradeResult, hex"", hex"");
     }
@@ -325,6 +272,7 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
 
         // Try upgrade with wrong network pubkey
         UpgradeResult memory upgradeResult = UpgradeResult({networkPubkey: hex"deadbeef"});
+        vm.prank(this.owner());
         vm.expectRevert(TEELifecycle.InvalidNetworkPubkey.selector);
         this.verifyUpgradeResult(mrAggregated, upgradeResult, quote, signature);
     }
@@ -341,6 +289,7 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
         // Try upgrade with unapproved MR_AGGREGATED
         bytes32 unapprovedMr = bytes32(uint256(1234));
         UpgradeResult memory upgradeResult = UpgradeResult({networkPubkey: testNetworkPubkey});
+        vm.prank(this.owner());
         vm.expectRevert(TEELifecycle.TEEVersionNotFound.selector);
         this.verifyUpgradeResult(unapprovedMr, upgradeResult, quote, signature);
     }
@@ -449,4 +398,83 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
         );
     }
 
+    // ============ Tests for reset() ============
+
+    function testReset_OnlyOwner() public {
+        address nonOwner = address(0x1234);
+        vm.startPrank(nonOwner);
+        vm.expectRevert();
+        this.reset();
+        vm.stopPrank();
+    }
+
+    function testReset_WithMultipleSigners() public {
+        // Complete bootstrap with first signer
+        (
+            BootstrapResult memory bootstrapResult,,
+            address bootstrapPartyAddress,
+            bytes memory quote,
+            bytes memory signature,
+            bytes32 mrAggregated
+        ) = successfulBootstrapResult();
+
+        vm.startPrank(this.owner());
+        this.approveNewTeeVersion(mrAggregated);
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
+
+        // Add a second node
+        (uint256 newNodePrivkey, address newNodeAddress) = getLabeledKeyPair("newNode");
+        AddNodeResult memory addNodeResult = AddNodeResult({networkPubkey: testNetworkPubkey});
+        bytes memory addNodeSignature = signAddNodeResult(addNodeResult, newNodePrivkey);
+        bytes memory addNodeQuote = createQuote(testMrtd, newNodeAddress);
+        this.verifyAddNodeResult(mrAggregated, addNodeResult, addNodeQuote, addNodeSignature);
+
+        // Verify state before reset
+        assertTrue(this.isBootstrapComplete(), "Bootstrap should be complete before reset");
+        assertEq(this.networkPubkey(), testNetworkPubkey, "Network pubkey should be set before reset");
+        assertEq(this.approvedTeeVersions(0), mrAggregated, "Approved TEE version should exist before reset");
+        assertEq(this.getSignersCount(), 2, "Should have 2 signers before reset");
+        assertTrue(this.isSigner(bootstrapPartyAddress), "First signer should exist");
+        assertTrue(this.isSigner(newNodeAddress), "Second signer should exist");
+
+        // Call reset
+        this.reset();
+
+        // Verify all state has been cleared
+        assertFalse(this.isBootstrapComplete(), "Bootstrap should not be complete after reset");
+        assertEq(this.networkPubkey().length, 0, "Network pubkey should be empty after reset");
+        assertEq(this.getSignersCount(), 0, "Should have 0 signers after reset");
+        assertFalse(this.isSigner(bootstrapPartyAddress), "First signer should be removed");
+        assertFalse(this.isSigner(newNodeAddress), "Second signer should be removed");
+        assertEq(this.getThreshold(), 0, "Threshold should be 0 after reset");
+
+        // Verify approved TEE versions array is empty
+        vm.expectRevert(TEELifecycle.IndexOutOfBounds.selector);
+        this.approvedTeeVersions(0);
+
+        vm.stopPrank();
+    }
+
+    function testReset_AllowsNewBootstrap() public {
+        // Complete bootstrap
+        (BootstrapResult memory bootstrapResult,,, bytes memory quote, bytes memory signature, bytes32 mrAggregated) =
+            successfulBootstrapResult();
+
+        vm.startPrank(this.owner());
+        this.approveNewTeeVersion(mrAggregated);
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
+        assertTrue(this.isBootstrapComplete(), "Bootstrap should be complete");
+
+        // Reset the contract
+        this.reset();
+        assertFalse(this.isBootstrapComplete(), "Bootstrap should not be complete after reset");
+
+        // Should be able to bootstrap again
+        this.approveNewTeeVersion(mrAggregated);
+        this.verifyBootstrapResult(bootstrapResult, quote, signature);
+        assertTrue(this.isBootstrapComplete(), "Should be able to bootstrap again after reset");
+
+        vm.stopPrank();
+    }
+
 }

package/src/test/TestDeploy.t.sol

@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {Test} from "forge-std/Test.sol";
+import {Test, Vm} from "forge-std/Test.sol";
 import {TrivialEncryption} from "../lightning-parts/TrivialEncryption.sol";
 import {ETypes} from "../Types.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import {inco} from "../Lib.sol";
 import {IncoTest} from "./IncoTest.sol";
+import {IEncryptedInput} from "../lightning-parts/interfaces/IEncryptedInput.sol";
 
 contract ReturnTwo is UUPSUpgradeable {
 
@@ -26,6 +28,7 @@ contract TestDeploy is Test, IncoTest {
         vm.expectEmit(false, false, true, false, address(inco));
         emit TrivialEncryption.TrivialEncrypt(bytes32(uint256(1)), bytes32(uint256(1)), ETypes.Bool, 0);
         inco.asEbool(true);
+        assertTrue(inco.isAcceptedVersion(2));
     }
 
     function testUpgrade() public {
@@ -35,4 +38,73 @@ contract TestDeploy is Test, IncoTest {
         assertEq(ReturnTwo(address(inco)).getTwo(), 2);
     }
 
+    function testAddAcceptedVersion() public {
+        assertFalse(inco.isAcceptedVersion(42));
+        vm.prank(owner);
+        inco.addAcceptedVersion(42);
+        assertTrue(inco.isAcceptedVersion(42));
+    }
+
+    function testAddAcceptedVersion_EmitsVersionAccepted() public {
+        vm.recordLogs();
+        vm.prank(owner);
+        inco.addAcceptedVersion(42);
+
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        bytes32 expectedTopic0 = keccak256("VersionAccepted(uint16)");
+        bool found = false;
+        for (uint256 i = 0; i < logs.length; i++) {
+            if (logs[i].topics[0] == expectedTopic0) {
+                found = true;
+                // version is indexed: must appear in topics[1], not in data
+                assertEq(logs[i].topics[1], bytes32(uint256(42)), "version should be an indexed topic");
+                assertEq(logs[i].data.length, 0, "data should be empty since version is indexed");
+                break;
+            }
+        }
+        assertTrue(found, "VersionAccepted event was not emitted");
+    }
+
+    function testAddAcceptedVersionNotOwner() public {
+        vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, alice));
+        vm.prank(alice);
+        inco.addAcceptedVersion(42);
+    }
+
+    function testRemoveAcceptedVersion() public {
+        assertFalse(inco.isAcceptedVersion(42));
+        vm.prank(owner);
+        inco.removeAcceptedVersion(42); // removing a non-existent version should be no-op
+        assertFalse(inco.isAcceptedVersion(42));
+    }
+
+    function testRemoveAcceptedVersion_EmitsVersionRemoved() public {
+        vm.prank(owner);
+        inco.addAcceptedVersion(42);
+
+        vm.recordLogs();
+        vm.prank(owner);
+        inco.removeAcceptedVersion(42);
+
+        Vm.Log[] memory logs = vm.getRecordedLogs();
+        bytes32 expectedTopic0 = keccak256("VersionRemoved(uint16)");
+        bool found = false;
+        for (uint256 i = 0; i < logs.length; i++) {
+            if (logs[i].topics[0] == expectedTopic0) {
+                found = true;
+                // version is indexed: must appear in topics[1], not in data
+                assertEq(logs[i].topics[1], bytes32(uint256(42)), "version should be an indexed topic");
+                assertEq(logs[i].data.length, 0, "data should be empty since version is indexed");
+                break;
+            }
+        }
+        assertTrue(found, "VersionRemoved event was not emitted");
+    }
+
+    function testRemoveAcceptedVersionNotOwner() public {
+        vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, alice));
+        vm.prank(alice);
+        inco.removeAcceptedVersion(42);
+    }
+
 }

package/src/test/TestFakeInfra.t.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8;
 
 import {IncoTest} from "./IncoTest.sol";
 import {e, euint256, ebool, eaddress, inco} from "../Lib.sol";
-import {SenderNotAllowedForHandle} from "../Types.sol";
+import {SenderNotAllowedForHandle, UnsupportedType, ETypes, UnexpectedType, typeToBitMask} from "../Types.sol";
 import {TEELifecycle} from "../lightning-parts/TEELifecycle.sol";
 import {Td10ReportBody, MINIMUM_QUOTE_LENGTH} from "../interfaces/automata-interfaces/Types.sol";
 
@@ -96,6 +96,14 @@ contract TestFakeInfra is IncoTest {
         assertEq(getUint256Value(c), 2);
     }
 
+    function testEDiv_DivisionByZeroReturnsMaxUint256() public {
+        euint256 a = e.asEuint256(10);
+        euint256 zero = e.asEuint256(0);
+        euint256 c = a.div(zero);
+        processAllOperations();
+        assertEq(getUint256Value(c), type(uint256).max);
+    }
+
     function testERem() public {
         euint256 a = e.asEuint256(10);
         euint256 b = e.asEuint256(4);
@@ -104,6 +112,14 @@ contract TestFakeInfra is IncoTest {
         assertEq(getUint256Value(c), 2);
     }
 
+    function testERem_RemainderByZeroReturnsLhs() public {
+        euint256 a = e.asEuint256(10);
+        euint256 zero = e.asEuint256(0);
+        euint256 c = a.rem(zero);
+        processAllOperations();
+        assertEq(getUint256Value(c), 10);
+    }
+
     function testEAnd() public {
         euint256 a = e.asEuint256(10);
         euint256 b = e.asEuint256(4);
@@ -514,11 +530,10 @@ contract TestFakeInfra is IncoTest {
         assertEq(getUint256Value(resB), 4);
     }
 
-    function testECastToEBool() public {
+    function testECastToEBoolRevert() public {
         euint256 a = e.asEuint256(1);
-        ebool b = a.asEbool();
-        processAllOperations();
-        assertEq(getBoolValue(b), true);
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, ETypes.Bool));
+        inco.eCast(euint256.unwrap(a), ETypes.Bool);
     }
 
     function testECastToFromEBool() public {
@@ -557,7 +572,7 @@ contract TestFakeInfra is IncoTest {
     function testECastAllowed() public {
         bytes32 invalidHandle = keccak256("invalid handle");
         vm.expectRevert(abi.encodeWithSelector(SenderNotAllowedForHandle.selector, invalidHandle, address(this)));
-        euint256.wrap(invalidHandle).asEbool();
+        ebool.wrap(invalidHandle).asEuint256();
     }
 
     function testUninitializedHandleIsDisallowed_Add_Lhs() public {
@@ -1104,4 +1119,15 @@ contract TestFakeInfra is IncoTest {
         assertEq(quote.length, MINIMUM_QUOTE_LENGTH);
     }
 
+    function testRandBoundedUpperBoundLargerThanRandType() public {
+        euint256 upperBound = e.asEuint256(type(uint256).max);
+        uint256 fee = inco.getFee();
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                UnexpectedType.selector, ETypes.Uint256, typeToBitMask(ETypes.AddressOrUint160OrBytes20)
+            )
+        );
+        inco.eRandBounded{value: fee}(euint256.unwrap(upperBound), ETypes.AddressOrUint160OrBytes20);
+    }
+
 }