@inco/lightning 0.4.0 → 0.5.1

package/src/lightning-parts/primitives/interfaces/IHandleGeneration.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {ETypes, EOps} from "../../../Types.sol";
+
+interface IHandleGeneration {
+    function getTrivialEncryptHandle(
+        bytes32 plaintextBytes,
+        ETypes handleType
+    ) external view returns (bytes32 generatedHandle);
+    function getInputHandle(
+        bytes memory ciphertext,
+        address user,
+        address contractAddress,
+        ETypes inputType
+    ) external view returns (bytes32 generatedHandle);
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        bytes32 lhs,
+        bytes32 rhs
+    ) external pure returns (bytes32 generatedHandle);
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        uint256 counter,
+        bytes32 upperBound
+    ) external pure returns (bytes32 generatedHandle);
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        bytes32 value
+    ) external pure returns (bytes32 generatedHandle);
+    function getOpResultHandle(
+        EOps op,
+        ETypes returnType,
+        bytes32 inputA,
+        bytes32 inputB,
+        bytes32 inputC
+    ) external pure returns (bytes32 generatedHandle);
+}

package/src/lightning-parts/primitives/interfaces/ISignatureVerifier.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+interface ISignatureVerifier {
+    function addSigner(address signerAddress) external;
+    function removeSigner(address signerAddress) external;
+    function isSigner(address signerAddress) external view returns (bool);
+    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bool);
+}

package/src/lightning-parts/primitives/interfaces/IVerifierAddressGetter.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IIncoVerifier} from "../../../interfaces/IIncoVerifier.sol";
+
+interface IVerifierAddressGetter {
+    function incoVerifier() external view returns (IIncoVerifier);
+}

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

@@ -7,7 +7,14 @@ 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, eaddress, typeToBitMask} from "../../Types.sol";
+import {
+    ETypes,
+    ebool,
+    euint256,
+    eaddress,
+    typeToBitMask
+} from "../../Types.sol";
+import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
 
 contract TestHandleMetadata is
     EIP712,
@@ -17,7 +24,7 @@ contract TestHandleMetadata is
     EncryptedOperations,
     EncryptedInput
 {
-    constructor() EIP712("", "") {}
+    constructor() EIP712("", "") VerifierAddressGetter(address(0)) {}
 
     function testTypeAssignment() public pure {
         bytes32 someHandle = bytes32(keccak256("someHandle"));
@@ -30,8 +37,12 @@ contract TestHandleMetadata is
                 ETypes.Uint256
         );
         assert(
-            typeOf(embedIndexTypeVersion(someHandle, ETypes.AddressOrUint160OrBytes20)) ==
-                ETypes.AddressOrUint160OrBytes20
+            typeOf(
+                embedIndexTypeVersion(
+                    someHandle,
+                    ETypes.AddressOrUint160OrBytes20
+                )
+            ) == ETypes.AddressOrUint160OrBytes20
         );
     }
 
@@ -40,7 +51,9 @@ contract TestHandleMetadata is
         assert(typeOf(boolHandle) == ETypes.Bool);
         bytes32 uintHandle = euint256.unwrap(this.asEuint256(42));
         assert(typeOf(uintHandle) == ETypes.Uint256);
-        bytes32 addressHandle = eaddress.unwrap(this.asEaddress(address(0xdeadbeef)));
+        bytes32 addressHandle = eaddress.unwrap(
+            this.asEaddress(address(0xdeadbeef))
+        );
         assert(typeOf(addressHandle) == ETypes.AddressOrUint160OrBytes20);
     }
 
@@ -70,7 +83,13 @@ contract TestHandleMetadata is
                 this.eIfThenElse(control, ebool.unwrap(c), ebool.unwrap(d))
             ) == ETypes.Bool
         );
-        assert(typeOf(ebool.unwrap(this.eEq(eaddress.unwrap(addr1), eaddress.unwrap(addr2)))) == ETypes.Bool);
+        assert(
+            typeOf(
+                ebool.unwrap(
+                    this.eEq(eaddress.unwrap(addr1), eaddress.unwrap(addr2))
+                )
+            ) == ETypes.Bool
+        );
     }
 
     function testEIfThenElseChecksTypeCoherence() public {

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

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoTest} from "../../test/IncoTest.sol";
+import {DemoToken} from "@inco/confidential-token-demo/src/DemoToken.sol";
+import {DecryptionAttestation} from "../DecryptionAttester.types.sol";
+import {GWEI} from "@inco/shared/src/TypeUtils.sol";
+import {euint256} from "@inco/lightning/src/Lib.sol"; // import via remapping or compiler fails
+import {AllowanceProof} from "../AccessControl/AdvancedAccessControl.sol";
+import {inco} from "../../Lib.sol";
+import {euint256 as remappedEuint256} from "@inco/lightning/src/Lib.sol";
+
+contract TokenBurnCurrentBalance is DemoToken {
+    function burnFullCurrentBalance(
+        DecryptionAttestation memory decryption,
+        bytes memory signature
+    ) public {
+        euint256 currentBalance = confidentialBalanceOf(msg.sender);
+        require(
+            inco.incoVerifier().isValidDecryptionAttestation(
+                decryption,
+                signature
+            ),
+            "Invalid Signature"
+        );
+        require(
+            euint256.unwrap(currentBalance) == decryption.handle,
+            "Handle mismatch"
+        );
+        publicBurn(msg.sender, uint256(decryption.value));
+    }
+}
+
+contract TestDecryptionAttestationInSynchronousFlow is IncoTest {
+    AllowanceProof emptyProof; // no proof needed when requester has the handle in persisted allowed pairs
+    function testSynchronousBurning() public {
+        TokenBurnCurrentBalance token = new TokenBurnCurrentBalance();
+        token.confidentialTransfer(
+            alice,
+            fakePrepareEuint256Ciphertext(10 * GWEI),
+            ""
+        );
+        processAllOperations(); // saves Alice's balance
+        bytes32 aliceCurrentBalanceHandle = euint256.unwrap(
+            token.confidentialBalanceOf(alice)
+        );
+        // simulates Alice requesting for a decryption attestation of Ge op on her balance and the amount
+        // she intends to burn, therefore proving to the token contract that the operation will succeed
+        (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        ) = getDecryptionAttestation(
+                alice,
+                HandleWithProof({
+                    handle: aliceCurrentBalanceHandle,
+                    proof: emptyProof
+                })
+            );
+        vm.prank(alice);
+
+        // the decryption attestation is passed to the token burn method
+        token.burnFullCurrentBalance(decryption, signature);
+
+        processAllOperations();
+
+        remappedEuint256 remappedFinalAliceBalance = token
+            .confidentialBalanceOf(alice);
+        bytes32 finalAliceBalance = remappedEuint256.unwrap(
+            remappedFinalAliceBalance
+        ); // compilation trick
+
+        assertEq(
+            uint256(get(finalAliceBalance)),
+            0,
+            "Alice should have burned all her tokens"
+        );
+    }
+}

package/src/periphery/SessionVerifier.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {
+    SESSION_VERIFIER_NAME,
+    SESSION_VERIFIER_MAJOR_VERSION,
+    SESSION_VERIFIER_MINOR_VERSION,
+    SESSION_VERIFIER_PATCH_VERSION
+} from "../version/SessionVerifierConfig.sol";
+import {Version} from "../version/Version.sol";
+import {ALLOWANCE_GRANTED_MAGIC_VALUE} from "../Types.sol";
+
+/// @notice a Session grants a temporary access to a decrypter to all data held by the sharer
+/// @dev abi encode this struct in the sharerArgData field of the voucher
+struct Session {
+    address decrypter;
+    uint256 expiresAt;
+}
+
+/// @notice Inco access sharing verifier mainly meant for browser dapp sessions, grants access to all data held by
+/// the sharer to one decrypter for a limited time.
+/// @dev define the selector of canUseSession in the voucher to use this verifier
+contract SessionVerifier is UUPSUpgradeable, OwnableUpgradeable, Version {
+    constructor(
+        bytes32 salt
+    )
+        Version(
+            SESSION_VERIFIER_MAJOR_VERSION,
+            SESSION_VERIFIER_MINOR_VERSION,
+            SESSION_VERIFIER_PATCH_VERSION,
+            salt,
+            SESSION_VERIFIER_NAME
+        )
+    {}
+
+    // todo add text mention of what is being signed
+    function canUseSession(
+        bytes32 /* handle */,
+        address account,
+        bytes memory sharerArgData,
+        bytes memory /* requesterArgData */
+    ) external view returns (bytes32) {
+        Session memory session = abi.decode(sharerArgData, (Session));
+        if (
+            session.expiresAt >= block.timestamp && session.decrypter == account
+        ) {
+            return ALLOWANCE_GRANTED_MAGIC_VALUE;
+        }
+        return bytes32(0);
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(msg.sender == owner());
+    }
+
+    function initialize(address owner) public initializer {
+        __Ownable_init(owner);
+    }
+
+    fallback() external {} // must be included for createX deploy
+}

package/src/test/AddTwo.sol

@@ -1,11 +1,15 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {IncoLightning} from "../IncoLightning.sol";
 import {euint256} from "../Types.sol";
+import {IncoLightning} from "../IncoLightning.sol";
+
+// import {console} from "forge-std/console.sol";
 
+// To implement such a contract, we would normally import e form Lib.sol. For test purposes, we take inco as
+// a constructor argument instead, so we can test it from other deployment addresses.
 contract AddTwo {
-    IncoLightning immutable inco;
+    IncoLightning inco;
 
     constructor(IncoLightning _inco) {
         inco = _inco;
@@ -14,48 +18,29 @@ contract AddTwo {
     // Stores the result of the last callback.
     uint256 public lastResult;
 
-    function addTwo(euint256 a) external returns (euint256) {
-        uint256 two = 2;
-        return inco.eAdd(a, inco.asEuint256(two));
-    }
-
-    function addTwoScalar(euint256 a) external returns (euint256) {
-        uint256 two = 2;
-        return inco.eAdd(a, inco.asEuint256(two));
+    function addTwo(euint256 a) public returns (euint256) {
+        euint256 two = inco.asEuint256(2);
+        return inco.eAdd(a, two);
     }
 
     // To generate a different handle with the same result, instead of adding 2 we add 1 + 1
-    function addTwoAlt(euint256 a) external returns (euint256) {
-        uint256 one = 1;
-        return inco.eAdd(a, inco.eAdd(inco.asEuint256(one), inco.asEuint256(one)));
+    function addTwoAlt(euint256 a) public returns (euint256) {
+        euint256 one = inco.asEuint256(1);
+        return inco.eAdd(a, inco.eAdd(one, one));
     }
 
     function addTwoEOA(
         bytes memory uint256EInput
-    ) external returns (uint256, euint256, euint256) {
+    ) external returns (euint256 result, euint256 resultRevealed) {
         euint256 value = inco.newEuint256(uint256EInput, msg.sender);
-        euint256 result = this.addTwo(value);
+        result = addTwo(value);
+
         inco.allow(euint256.unwrap(result), address(this));
         inco.allow(euint256.unwrap(result), msg.sender);
 
-        // Used to test attested reveal functionality. Note that msg.sender is not allowed, instead we call .reveal() that gives permission to anyone.
-        euint256 resultRevealed = this.addTwoAlt(value);
+        // Used to test attested reveal functionality.
+        // Note that msg.sender is not allowed, instead we call .reveal() that gives permission to anyone.
+        resultRevealed = addTwoAlt(value);
         inco.reveal(euint256.unwrap(resultRevealed));
-
-        uint256 requestId = inco.requestDecryption(
-            this.callback.selector,
-            block.timestamp + 2 hours,
-            euint256.unwrap(result),
-            ""
-        );
-        return (requestId, result, resultRevealed);
-    }
-
-    function callback(
-        uint256 /* requestId */,
-        uint256 result,
-        bytes memory /* data */
-    ) external {
-        lastResult = result;
     }
 }

package/src/test/FakeIncoInfra/FakeDecryptionAttester.sol

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {FakeIncoInfraBase} from "./FakeIncoInfraBase.sol";
+import {inco} from "../../Lib.sol";
+import {DecryptionAttestation} from "../../lightning-parts/DecryptionAttester.types.sol";
+import {AllowanceProof} from "../../lightning-parts/AccessControl/AdvancedAccessControl.sol";
+import {SenderNotAllowedForHandle, EOps, ETypes} from "../../Types.sol";
+import {FakeComputeServer} from "./FakeComputeServer.sol";
+
+/// @notice simulates the TEE / covalidator offchain API for decryption attestations requests
+/// The signing and checking of the decryption request is out of scope of this simulation, it is assumed that when
+/// called in tests, it emulates the act of a requester emitting a decryption request
+/// One can request decryption attestations on one handle, or on a handle not existing onchain resulting from an
+/// operation on existing handles, or on a mix of existing handles and plaintexts values (which get trivial encrypted)
+/// as long as the handles are allowed for the requester
+contract FakeDecryptionAttester is FakeIncoInfraBase, FakeComputeServer {
+    struct HandleWithProof {
+        bytes32 handle;
+        AllowanceProof proof; // sharer == address(0) means no proof
+    }
+
+    // The following 4 functions mimic expected behavior of the TEE / covalidator over offchain API
+
+    /// @notice request decryption attestation for an existing handle
+    function getDecryptionAttestation(
+        address requester,
+        HandleWithProof memory handle
+    )
+        internal
+        returns (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        )
+    {
+        checkAccessControl(requester, handle);
+        (decryption, signature) = _getDecryptionAttestation(
+            handle.handle,
+            get(handle.handle)
+        );
+    }
+
+    // The following 3 functions are for requesting decryption over a handle resulting of an operation
+    // only binary ops are supported for now (2 params)
+
+    /// @notice request decryption attestation for a binary operation on 2 existing handles
+    function getDecryptionAttestation(
+        address requester,
+        HandleWithProof memory lhs,
+        HandleWithProof memory rhs,
+        EOps op
+    )
+        internal
+        returns (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        )
+    {
+        checkAccessControl(requester, lhs);
+        checkAccessControl(requester, rhs);
+        bytes32 result = computeBinaryOp(get(lhs.handle), get(rhs.handle), op);
+        (decryption, signature) = _getDecryptionAttestation(
+            lhs.handle,
+            rhs.handle,
+            result,
+            op
+        );
+    }
+
+    /// @notice request decryption attestation for a binary operation on a handle and a plaintext value (lhs)
+    function getDecryptionAttestation(
+        address requester,
+        uint256 lhs,
+        HandleWithProof memory rhs,
+        EOps op
+    )
+        internal
+        returns (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        )
+    {
+        checkAccessControl(requester, rhs);
+        bytes32 lhsHandle = inco.getTrivialEncryptHandle(
+            bytes32(lhs),
+            ETypes.Uint256
+        );
+        bytes32 result = computeBinaryOp(bytes32(lhs), get(rhs.handle), op);
+        (decryption, signature) = _getDecryptionAttestation(
+            lhsHandle,
+            rhs.handle,
+            result,
+            op
+        );
+    }
+
+    /// @notice request decryption attestation for a binary operation on a handle and a plaintext value (rhs)
+    function getDecryptionAttestation(
+        address requester,
+        HandleWithProof memory lhs,
+        uint256 rhs,
+        EOps op
+    )
+        internal
+        returns (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        )
+    {
+        checkAccessControl(requester, lhs);
+        bytes32 rhsHandle = inco.getTrivialEncryptHandle(
+            bytes32(rhs),
+            ETypes.Uint256
+        );
+
+        bytes32 result = computeBinaryOp(get(lhs.handle), bytes32(rhs), op);
+        (decryption, signature) = _getDecryptionAttestation(
+            lhs.handle,
+            rhsHandle,
+            result,
+            op
+        );
+    }
+
+    /// Private methods ///
+
+    function checkAccessControl(
+        address requester,
+        HandleWithProof memory handle
+    ) private {
+        if (handle.proof.sharer == address(0)) {
+            require(
+                inco.isAllowed(handle.handle, requester),
+                SenderNotAllowedForHandle(handle.handle, requester)
+            );
+        } else {
+            require(
+                inco.incoVerifier().isAllowedWithProof(
+                    handle.handle,
+                    requester,
+                    handle.proof
+                ),
+                SenderNotAllowedForHandle(handle.handle, requester)
+            );
+        }
+    }
+
+    function _getDecryptionAttestation(
+        bytes32 handle,
+        bytes32 value
+    )
+        private
+        view
+        returns (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        )
+    {
+        decryption = DecryptionAttestation({handle: handle, value: value});
+        signature = signDecryption(decryption);
+    }
+
+    function signDecryption(
+        DecryptionAttestation memory decryption
+    ) private view returns (bytes memory signature) {
+        // todo change this to don't call inco and call verifier directly
+        bytes32 digest = inco.incoVerifier().decryptionAttestationDigest(
+            decryption
+        );
+        signature = getSignatureForDigest(digest, teePrivKey);
+    }
+
+    function _getDecryptionAttestation(
+        bytes32 lhsHandle,
+        bytes32 rhsHandle,
+        bytes32 encodedResult,
+        EOps op
+    )
+        private
+        view
+        returns (
+            DecryptionAttestation memory decryption,
+            bytes memory signature
+        )
+    {
+        ETypes resultType = opToResultType(op);
+        decryption = DecryptionAttestation({
+            handle: inco.getOpResultHandle(
+                op,
+                resultType,
+                lhsHandle,
+                rhsHandle
+            ),
+            value: encodedResult
+        });
+        signature = signDecryption(decryption);
+    }
+}

package/src/test/FakeIncoInfra/FakeIncoInfraBase.sol

@@ -3,9 +3,7 @@ pragma solidity ^0.8;
 
 import {ebool, euint256, ETypes} from "../../Types.sol";
 import {inco} from "../../Lib.sol";
-import {Vm} from "forge-std/Test.sol";
 import {TestUtils} from "@inco/shared/src/TestUtils.sol";
-import {DecryptionResult} from "../../lightning-parts/DecryptionHandler.sol";
 import {KVStore} from "./KVStore.sol";
 
 /// @notice simulates what inco does offchain but over plaintexts
@@ -19,19 +17,6 @@ contract FakeIncoInfraBase is TestUtils, KVStore {
         (teePrivKey, teePubkeyAddress) = getLabeledKeyPair("tee");
     }
 
-    function handleDecryptionRequest(
-        uint256 requestId,
-        bytes32 handle
-    ) internal {
-        DecryptionResult memory result = DecryptionResult({
-            abiEncodedResult: get(handle),
-            requestId: requestId,
-            handle: handle
-        });
-        vm.prank(teePubkeyAddress);
-        inco.fulfillRequest(result, "");
-    }
-
     function fakePrepareEuint256Ciphertext(
         uint256 value
     ) internal pure returns (bytes memory ciphertext) {

package/src/test/FakeIncoInfra/FakeQuoteVerifier.sol

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {IPCCSRouter} from "@automata-network/dcap-attestation/interfaces/IPCCSRouter.sol";
-import {Header} from "@automata-network/dcap-attestation/types/CommonStruct.sol";
-import {IQuoteVerifier} from "automata-dcap-attestation/interfaces/IQuoteVerifier.sol";
+import {IPCCSRouter} from "../../interfaces/automata-interfaces/IPCCSRouter.sol";
+import {Header} from "../../interfaces/automata-interfaces/Types.sol";
+import {IQuoteVerifier} from "../../interfaces/automata-interfaces/IQuoteVerifier.sol";
 
 // This contract is used to test the IncoLightning contract. It is a simple implementation of the QuoteVerifier interface.
 // It is used to test the IncoLightning contract without relying on the real QuoteVerifier contract.
@@ -18,12 +18,16 @@ contract FakeQuoteVerifier is IQuoteVerifier {
         return 4;
     }
 
-    function verifyQuote(Header calldata, bytes calldata quote) external pure returns (bool, bytes memory) {
+    function verifyQuote(
+        Header calldata,
+        bytes calldata quote
+    ) external pure returns (bool, bytes memory) {
         return (true, quote);
     }
 
-    function verifyZkOutput(bytes calldata quote) external pure returns (bool, bytes memory) {
+    function verifyZkOutput(
+        bytes calldata quote
+    ) external pure returns (bool, bytes memory) {
         return (true, quote);
     }
-
 }

package/src/test/FakeIncoInfra/MockOpHandler.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8;
 import {Vm} from "forge-std/Test.sol";
 import {inco} from "../../Lib.sol";
 import {ebool, euint256, ETypes, EOps} from "../../Types.sol";
-import {DecryptionRequested} from "../../lightning-parts/DecryptionHandler.sol";
 import {FakeComputeServer} from "./FakeComputeServer.sol";
 import {FakeIncoInfraBase} from "./FakeIncoInfraBase.sol";
 import {asBytes32} from "@inco/shared/src/TypeUtils.sol";
@@ -71,12 +70,6 @@ contract MockOpHandler is FakeIncoInfraBase, FakeComputeServer {
                 (ETypes, bytes, uint256)
             );
             handleEInput(result, inputType, ciphertext);
-        } else if (op == EOps.DecryptionRequested) {
-            uint256 requestId = uint256(log.topics[1]);
-            bytes32 handle = log.topics[2];
-            // other fields ignored for now
-            // todo cheats to trigger decryption later
-            handleDecryptionRequest(requestId, handle);
         }
     }
 

package/src/test/FakeIncoInfra/MockRemoteAttestation.sol

@@ -2,10 +2,11 @@
 pragma solidity ^0.8;
 
 import {TestUtils} from "@inco/shared/src/TestUtils.sol";
-import {TEELifecycle} from "@inco/lightning/src/lightning-parts/TEELifecycle.sol";
-
-import {HEADER_LENGTH, MINIMUM_QUOTE_LENGTH, TDX_TEE} from "@automata-network/dcap-attestation/types/Constants.sol";
-import {BootstrapResult} from "@inco/lightning/src/lightning-parts/TEELifecycle.types.sol";
+import {
+    HEADER_LENGTH,
+    MINIMUM_QUOTE_LENGTH,
+    TDX_TEE
+} from "../../interfaces/automata-interfaces/Types.sol";
 
 contract MockRemoteAttestation is TestUtils {
     function createQuote(
@@ -31,7 +32,18 @@ contract MockRemoteAttestation is TestUtils {
         bytes memory prefix = new bytes(HEADER_LENGTH + 136 - 8);
         bytes memory middle = new bytes(520 - 184);
         bytes memory reportDataSuffix = new bytes(44);
-        bytes memory suffix = new bytes(MINIMUM_QUOTE_LENGTH - HEADER_LENGTH - 584);
-        quote = abi.encodePacked(version, tdxTEEType, prefix, mrtd, middle, abi.encodePacked(signer), reportDataSuffix, suffix);
+        bytes memory suffix = new bytes(
+            MINIMUM_QUOTE_LENGTH - HEADER_LENGTH - 584
+        );
+        quote = abi.encodePacked(
+            version,
+            tdxTEEType,
+            prefix,
+            mrtd,
+            middle,
+            abi.encodePacked(signer),
+            reportDataSuffix,
+            suffix
+        );
     }
-}
+}