@inco/lightning 0.6.8 → 0.7.0

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

@@ -5,22 +5,23 @@ import {Test} from "forge-std/Test.sol";
 import {Fee, FEE} from "../Fee.sol";
 
 contract FeeTester is Fee {
+
     function costOneFee() public payable paying {
         // do nothing
     }
 
-    function costMultipleVariableFees(
-        uint256 nbOfFees
-    ) public payable payingMultiple(nbOfFees) {
+    function costMultipleVariableFees(uint256 nbOfFees) public payable payingMultiple(nbOfFees) {
         // do nothing
     }
 
     function costMultipleFixedFees() public payable payingMultiple(3) {
         // do nothing
     }
+
 }
 
 contract TestFee is Test {
+
     FeeTester feeTester;
 
     function setUp() public {
@@ -89,13 +90,12 @@ contract TestFee is Test {
         // should fail if not enough fee (unless expectedValue is 0)
         if (expectedValue > 0) {
             vm.expectRevert(Fee.FeeNotPaid.selector);
-            feeTester.costMultipleVariableFees{value: expectedValue - 1}(
-                nbOfFees
-            );
+            feeTester.costMultipleVariableFees{value: expectedValue - 1}(nbOfFees);
         }
 
         // should fail if too much fee
         vm.expectRevert(Fee.FeeNotPaid.selector);
         feeTester.costMultipleVariableFees{value: expectedValue + 1}(nbOfFees);
     }
+
 }

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

@@ -7,13 +7,7 @@ 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";
 import {FEE} from "../Fee.sol";
 
@@ -25,25 +19,16 @@ contract TestHandleMetadata is
     EncryptedOperations,
     EncryptedInput
 {
+
     constructor() EIP712("", "") VerifierAddressGetter(address(0)) {}
 
     function testTypeAssignment() public pure {
         bytes32 someHandle = bytes32(keccak256("someHandle"));
+        assert(typeOf(embedIndexTypeVersion(someHandle, ETypes.Bool)) == ETypes.Bool);
+        assert(typeOf(embedIndexTypeVersion(someHandle, ETypes.Uint256)) == ETypes.Uint256);
         assert(
-            typeOf(embedIndexTypeVersion(someHandle, ETypes.Bool)) ==
-                ETypes.Bool
-        );
-        assert(
-            typeOf(embedIndexTypeVersion(someHandle, ETypes.Uint256)) ==
-                ETypes.Uint256
-        );
-        assert(
-            typeOf(
-                embedIndexTypeVersion(
-                    someHandle,
-                    ETypes.AddressOrUint160OrBytes20
-                )
-            ) == ETypes.AddressOrUint160OrBytes20
+            typeOf(embedIndexTypeVersion(someHandle, ETypes.AddressOrUint160OrBytes20))
+                == ETypes.AddressOrUint160OrBytes20
         );
     }
 
@@ -52,9 +37,7 @@ 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,27 +53,9 @@ contract TestHandleMetadata is
         assert(typeOf(euint256.unwrap(this.eAdd(a, b))) == ETypes.Uint256);
         assert(typeOf(euint256.unwrap(this.eSub(a, b))) == ETypes.Uint256);
         assert(typeOf(ebool.unwrap(this.eGe(a, b))) == ETypes.Bool);
-        assert(
-            typeOf(
-                this.eIfThenElse(
-                    control,
-                    euint256.unwrap(a),
-                    euint256.unwrap(b)
-                )
-            ) == ETypes.Uint256
-        );
-        assert(
-            typeOf(
-                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(this.eIfThenElse(control, euint256.unwrap(a), euint256.unwrap(b))) == ETypes.Uint256);
+        assert(typeOf(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);
     }
 
     function testEIfThenElseChecksTypeCoherence() public {
@@ -99,9 +64,7 @@ contract TestHandleMetadata is
         ebool b = this.asEbool(true);
         vm.expectRevert(
             abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector,
-                ETypes.Bool,
-                typeToBitMask(ETypes.Uint256)
+                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
             )
         );
         this.eIfThenElse(control, euint256.unwrap(a), ebool.unwrap(b));
@@ -110,24 +73,12 @@ contract TestHandleMetadata is
     function testEncryptedInputHandleType() public {
         address self = address(this);
         bytes32 ciphertext = keccak256(abi.encodePacked("ciphertext"));
-        euint256 a = this.newEuint256{value: FEE}(
-            getCiphertextInput(ciphertext, self, self, ETypes.Uint256),
-            self
-        );
+        euint256 a = this.newEuint256{value: FEE}(getCiphertextInput(ciphertext, self, self, ETypes.Uint256), self);
         assert(typeOf(euint256.unwrap(a)) == ETypes.Uint256);
-        ebool b = this.newEbool{value: FEE}(
-            getCiphertextInput(ciphertext, self, self, ETypes.Bool),
-            address(this)
-        );
+        ebool b = this.newEbool{value: FEE}(getCiphertextInput(ciphertext, self, self, ETypes.Bool), address(this));
         assert(typeOf(ebool.unwrap(b)) == ETypes.Bool);
         eaddress c = this.newEaddress{value: FEE}(
-            getCiphertextInput(
-                ciphertext,
-                self,
-                self,
-                ETypes.AddressOrUint160OrBytes20
-            ),
-            address(this)
+            getCiphertextInput(ciphertext, self, self, ETypes.AddressOrUint160OrBytes20), address(this)
         );
         assert(typeOf(eaddress.unwrap(c)) == ETypes.AddressOrUint160OrBytes20);
     }
@@ -135,21 +86,15 @@ contract TestHandleMetadata is
     /// @notice Helper to create an input with a handle prepended to the ciphertext.
     /// @param word A single word to be used as the ciphertext.
     /// @param user The user address associated with the input.
-    function getCiphertextInput(
-        bytes32 word,
-        address user,
-        address contractAddress,
-        ETypes inputType
-    ) public view returns (bytes memory input) {
+    function getCiphertextInput(bytes32 word, address user, address contractAddress, ETypes inputType)
+        public
+        view
+        returns (bytes memory input)
+    {
         // We need a single word here to get correct encoding
         bytes memory ciphertext = abi.encode(word);
-        bytes32 handle = getInputHandle(
-            ciphertext,
-            address(this),
-            user,
-            contractAddress,
-            inputType
-        );
+        bytes32 handle = getInputHandle(ciphertext, address(this), user, contractAddress, inputType);
         input = abi.encode(handle, ciphertext);
     }
+
 }

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

@@ -1,12 +1,8 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {Test} from "forge-std/Test.sol";
-import {EncryptedInput} from "../EncryptedInput.sol";
-import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
 import {FEE, Fee} from "../Fee.sol";
 import {IncoTest} from "../../test/IncoTest.sol";
-import {console} from "forge-std/console.sol";
 import {inco} from "../../Lib.sol";
 
 contract TestInputsFee is IncoTest {
@@ -14,45 +10,28 @@ contract TestInputsFee is IncoTest {
     function testPayOnInputs() public {
         // should fail if no fee
         vm.expectRevert(Fee.FeeNotPaid.selector);
-        inco.newEuint256{value: 0}(
-            fakePrepareEuint256Ciphertext(12, address(0), address(this)),
-            address(0)
-        );
+        inco.newEuint256{value: 0}(fakePrepareEuint256Ciphertext(12, address(0), address(this)), address(0));
 
         // should fail if not enough fee
         vm.expectRevert(Fee.FeeNotPaid.selector);
-        inco.newEuint256{value: FEE - 1}(
-            fakePrepareEuint256Ciphertext(12, address(0), address(this)),
-            address(0)
-        );
+        inco.newEuint256{value: FEE - 1}(fakePrepareEuint256Ciphertext(12, address(0), address(this)), address(0));
 
         // should fail if too much fee
         vm.expectRevert(Fee.FeeNotPaid.selector);
-        inco.newEuint256{value: FEE + 1}(
-            fakePrepareEuint256Ciphertext(12, address(0), address(this)),
-            address(0)
-        );
+        inco.newEuint256{value: FEE + 1}(fakePrepareEuint256Ciphertext(12, address(0), address(this)), address(0));
 
         // should work with exact fee
-        inco.newEuint256{value: FEE}(
-            fakePrepareEuint256Ciphertext(12, address(0), address(this)),
-            address(0)
-        );
+        inco.newEuint256{value: FEE}(fakePrepareEuint256Ciphertext(12, address(0), address(this)), address(0));
     }
 
     function testPayForNewEbool() public {
         // should work with exact fee
-        inco.newEbool{value: FEE}(
-            fakePrepareEboolCiphertext(true, address(0), address(this)),
-            address(0)
-        );
+        inco.newEbool{value: FEE}(fakePrepareEboolCiphertext(true, address(0), address(this)), address(0));
     }
 
     function testPayForNewEaddress() public {
         // should work with exact fee
-        inco.newEaddress{value: FEE}(
-            fakePrepareEaddressCiphertext(address(0), address(0), address(this)),
-            address(0)
-        );
+        inco.newEaddress{value: FEE}(fakePrepareEaddressCiphertext(address(0), address(0), address(this)), address(0));
     }
+
 }

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

@@ -11,73 +11,41 @@ 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 {
+
+    function burnFullCurrentBalance(DecryptionAttestation memory decryption, bytes[] memory signatures) public {
         euint256 currentBalance = confidentialBalanceOf(msg.sender);
-        require(
-            inco.incoVerifier().isValidDecryptionAttestation(
-                decryption,
-                signature
-            ),
-            "Invalid Signature"
-        );
-        require(
-            euint256.unwrap(currentBalance) == decryption.handle,
-            "Handle mismatch"
-        );
+        require(inco.incoVerifier().isValidDecryptionAttestation(decryption, signatures), "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();
         vm.deal(address(token), 100 ether);
-        token.confidentialTransfer(
-            alice,
-            fakePrepareEuint256Ciphertext(
-                10 * GWEI,
-                address(this),
-                address(token)
-            ),
-            ""
-        );
+        token.confidentialTransfer(alice, fakePrepareEuint256Ciphertext(10 * GWEI, address(this), address(token)), "");
         processAllOperations(); // saves Alice's balance
-        bytes32 aliceCurrentBalanceHandle = euint256.unwrap(
-            token.confidentialBalanceOf(alice)
-        );
+        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
-                })
-            );
+        (DecryptionAttestation memory decryption, bytes[] memory signatures) =
+            getDecryptionAttestation(alice, HandleWithProof({handle: aliceCurrentBalanceHandle, proof: emptyProof}));
         vm.prank(alice);
 
         // the decryption attestation is passed to the token burn method
-        token.burnFullCurrentBalance(decryption, signature);
+        token.burnFullCurrentBalance(decryption, signatures);
 
         processAllOperations();
 
-        remappedEuint256 remappedFinalAliceBalance = token
-            .confidentialBalanceOf(alice);
-        bytes32 finalAliceBalance = remappedEuint256.unwrap(
-            remappedFinalAliceBalance
-        ); // compilation trick
+        remappedEuint256 remappedFinalAliceBalance = token.confidentialBalanceOf(alice);
+        bytes32 finalAliceBalance = remappedEuint256.unwrap(remappedFinalAliceBalance); // compilation trick
 
-        assertEq(
-            uint256(get(finalAliceBalance)),
-            0,
-            "Alice should have burned all her tokens"
-        );
+        assertEq(uint256(get(finalAliceBalance)), 0, "Alice should have burned all her tokens");
     }
+
 }