@inco/lightning 0.6.8 → 0.6.9

package/src/test/OpsTest.sol

@@ -0,0 +1,429 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoLightning} from "../IncoLightning.sol";
+import {euint256, ebool, eaddress, ETypes} from "../Types.sol";
+import {Fee} from "../lightning-parts/Fee.sol";
+
+contract OpsTest is Fee {
+
+    IncoLightning inco;
+
+    constructor(IncoLightning _inco) {
+        inco = _inco;
+    }
+
+    // ============ ARITHMETIC OPERATIONS ============
+
+    function testAdd(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eAdd(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testAddScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eAdd(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testSub(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eSub(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testSubScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eSub(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testMul(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eMul(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testMulScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eMul(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testDiv(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eDiv(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testDivScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eDiv(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRem(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eRem(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRemScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eRem(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    // ============ BITWISE OPERATIONS ============
+
+    function testAnd(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = euint256.wrap(inco.eBitAnd(euint256.unwrap(a), euint256.unwrap(b)));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testAndScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = euint256.wrap(inco.eBitAnd(euint256.unwrap(a), euint256.unwrap(inco.asEuint256(b))));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testAndBool(ebool a, ebool b) external returns (ebool) {
+        ebool result = ebool.wrap(inco.eBitAnd(ebool.unwrap(a), ebool.unwrap(b)));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testAndBoolScalar(ebool a, bool b) external returns (ebool) {
+        ebool result = ebool.wrap(inco.eBitAnd(ebool.unwrap(a), ebool.unwrap(inco.asEbool(b))));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testOr(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = euint256.wrap(inco.eBitOr(euint256.unwrap(a), euint256.unwrap(b)));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testOrScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = euint256.wrap(inco.eBitOr(euint256.unwrap(a), euint256.unwrap(inco.asEuint256(b))));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testOrBool(ebool a, ebool b) external returns (ebool) {
+        ebool result = ebool.wrap(inco.eBitOr(ebool.unwrap(a), ebool.unwrap(b)));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testOrBoolScalar(ebool a, bool b) external returns (ebool) {
+        ebool result = ebool.wrap(inco.eBitOr(ebool.unwrap(a), ebool.unwrap(inco.asEbool(b))));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testXor(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = euint256.wrap(inco.eBitXor(euint256.unwrap(a), euint256.unwrap(b)));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testXorScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = euint256.wrap(inco.eBitXor(euint256.unwrap(a), euint256.unwrap(inco.asEuint256(b))));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testXorBool(ebool a, ebool b) external returns (ebool) {
+        ebool result = ebool.wrap(inco.eBitXor(ebool.unwrap(a), ebool.unwrap(b)));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testXorBoolScalar(ebool a, bool b) external returns (ebool) {
+        ebool result = ebool.wrap(inco.eBitXor(ebool.unwrap(a), ebool.unwrap(inco.asEbool(b))));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testShl(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eShl(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testShlScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eShl(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testShr(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eShr(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testShrScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eShr(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRotl(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eRotl(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRotlScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eRotl(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRotr(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eRotr(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRotrScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eRotr(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    // ============ COMPARISON OPERATIONS ============
+
+    function testEq(euint256 a, euint256 b) external returns (ebool) {
+        ebool result = inco.eEq(euint256.unwrap(a), euint256.unwrap(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testEqScalar(euint256 a, uint256 b) external returns (ebool) {
+        ebool result = inco.eEq(euint256.unwrap(a), euint256.unwrap(inco.asEuint256(b)));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testEqAddress(eaddress a, eaddress b) external returns (ebool) {
+        ebool result = inco.eEq(eaddress.unwrap(a), eaddress.unwrap(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testEqAddressScalar(eaddress a, address b) external returns (ebool) {
+        ebool result = inco.eEq(eaddress.unwrap(a), eaddress.unwrap(inco.asEaddress(b)));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testNe(euint256 a, euint256 b) external returns (ebool) {
+        ebool result = inco.eNe(euint256.unwrap(a), euint256.unwrap(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testNeScalar(euint256 a, uint256 b) external returns (ebool) {
+        ebool result = inco.eNe(euint256.unwrap(a), euint256.unwrap(inco.asEuint256(b)));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testNeAddress(eaddress a, eaddress b) external returns (ebool) {
+        ebool result = inco.eNe(eaddress.unwrap(a), eaddress.unwrap(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testNeAddressScalar(eaddress a, address b) external returns (ebool) {
+        ebool result = inco.eNe(eaddress.unwrap(a), eaddress.unwrap(inco.asEaddress(b)));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testGe(euint256 a, euint256 b) external returns (ebool) {
+        ebool result = inco.eGe(a, b);
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testGeScalar(euint256 a, uint256 b) external returns (ebool) {
+        ebool result = inco.eGe(a, inco.asEuint256(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testGt(euint256 a, euint256 b) external returns (ebool) {
+        ebool result = inco.eGt(a, b);
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testGtScalar(euint256 a, uint256 b) external returns (ebool) {
+        ebool result = inco.eGt(a, inco.asEuint256(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testLe(euint256 a, euint256 b) external returns (ebool) {
+        ebool result = inco.eLe(a, b);
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testLeScalar(euint256 a, uint256 b) external returns (ebool) {
+        ebool result = inco.eLe(a, inco.asEuint256(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testLt(euint256 a, euint256 b) external returns (ebool) {
+        ebool result = inco.eLt(a, b);
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testLtScalar(euint256 a, uint256 b) external returns (ebool) {
+        ebool result = inco.eLt(a, inco.asEuint256(b));
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testMin(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eMin(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testMinScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eMin(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testMax(euint256 a, euint256 b) external returns (euint256) {
+        euint256 result = inco.eMax(a, b);
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testMaxScalar(euint256 a, uint256 b) external returns (euint256) {
+        euint256 result = inco.eMax(a, inco.asEuint256(b));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    // ============ LOGICAL OPERATIONS ============
+
+    function testNot(ebool a) external returns (ebool) {
+        ebool result = inco.eNot(a);
+        inco.allow(ebool.unwrap(result), address(this));
+        inco.allow(ebool.unwrap(result), msg.sender);
+        return result;
+    }
+
+    // ============ RANDOM NUMBER GENERATION ============
+
+    function testRand() external payable returns (euint256) {
+        euint256 result = euint256.wrap(inco.eRand{value: getFee()}(ETypes.Uint256));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRandBounded(uint256 upperBound) external payable returns (euint256) {
+        euint256 result = euint256.wrap(
+            inco.eRandBounded{value: getFee()}(euint256.unwrap(inco.asEuint256(upperBound)), ETypes.Uint256)
+        );
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    function testRandBoundedEncrypted(euint256 upperBound) external payable returns (euint256) {
+        euint256 result = euint256.wrap(inco.eRandBounded{value: getFee()}(euint256.unwrap(upperBound), ETypes.Uint256));
+        inco.allow(euint256.unwrap(result), address(this));
+        inco.allow(euint256.unwrap(result), msg.sender);
+        return result;
+    }
+
+    // ============ ENCRYPTED INPUT CREATION ============
+
+    function testNewEuint256(bytes memory ciphertext, address user) external payable returns (euint256) {
+        euint256 encryptedUint256 = inco.newEuint256{value: getFee()}(ciphertext, user);
+        inco.allow(euint256.unwrap(encryptedUint256), address(this));
+        inco.allow(euint256.unwrap(encryptedUint256), user);
+        return encryptedUint256;
+    }
+
+    function testNewEbool(bytes memory ciphertext, address user) external payable returns (ebool) {
+        ebool encryptedBool = inco.newEbool{value: getFee()}(ciphertext, user);
+        inco.allow(ebool.unwrap(encryptedBool), address(this));
+        inco.allow(ebool.unwrap(encryptedBool), user);
+        return encryptedBool;
+    }
+
+    function testNewEaddress(bytes memory ciphertext, address user) external payable returns (eaddress) {
+        eaddress encryptedAddress = inco.newEaddress{value: getFee()}(ciphertext, user);
+        inco.allow(eaddress.unwrap(encryptedAddress), address(this));
+        inco.allow(eaddress.unwrap(encryptedAddress), user);
+        return encryptedAddress;
+    }
+
+}

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

@@ -5,92 +5,65 @@ 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"04ff5c6dd72ad7583288b84ee2598e081fe0bc6ef543c342e925a5dfcff9afb2444d25454d7d5dcfadc9ed99477c245efa93caf58d7f58143300d81cc948e7bdf5";
     // 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);
 
-        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 +71,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 +137,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 +146,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);
     }
+
 }