@inco/lightning 0.6.8 → 0.7.0

package/src/lightning-parts/AccessControl/BaseAccessControlList.sol

@@ -8,55 +8,46 @@ import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
 import {AllowanceProof} from "../AccessControl/AdvancedAccessControl.types.sol";
 
 contract AccessControlListStorage {
-    struct ACLStorage {
+
+    struct AclStorage {
         mapping(bytes32 handle => mapping(address account => bool isAllowed)) persistedAllowedPairs;
         mapping(bytes32 handle => bool isAllowed) persistedAllowedForDecryption;
     }
 
-    bytes32 private constant ACLStorageLocation = keccak256("inco.storage.ACL");
+    bytes32 private constant ACL_STORAGE_LOCATION = keccak256("inco.storage.ACL");
 
-    function getACLStorage() internal pure returns (ACLStorage storage $) {
-        bytes32 loc = ACLStorageLocation;
+    function getAclStorage() internal pure returns (AclStorage storage $) {
+        bytes32 loc = ACL_STORAGE_LOCATION;
         assembly {
             $.slot := loc
         }
     }
+
 }
 
-abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControlListStorage, VerifierAddressGetter, EventCounter {
-    error ProofVerificationFailed(
-        address verifyingContract,
-        bytes4 callFunction,
-        bytes argData
-    );
+abstract contract BaseAccessControlList is
+    IBaseAccessControlList,
+    AccessControlListStorage,
+    VerifierAddressGetter,
+    EventCounter
+{
+
+    error ProofVerificationFailed(address verifyingContract, bytes4 callFunction, bytes argData);
 
-    event Allow(
-        bytes32 handle,
-        address account,
-        uint256 eventId
-    );
+    event Allow(bytes32 handle, address account, uint256 eventId);
 
-    event Reveal(
-        bytes32 handle,
-        uint256 eventId
-    );
+    event Reveal(bytes32 handle, uint256 eventId);
 
     /// @dev persistent
     function allow(bytes32 handle, address account) public {
-        require(
-            isAllowed(handle, msg.sender),
-            SenderNotAllowedForHandle(handle, msg.sender)
-        );
+        require(isAllowed(handle, msg.sender), SenderNotAllowedForHandle(handle, msg.sender));
         allowInternal(handle, account);
     }
 
     /// @dev Permanently allows public decryption/reencryption access to anyone for the given handle.
     function reveal(bytes32 handle) public {
-        require(
-            isAllowed(handle, msg.sender),
-            SenderNotAllowedForHandle(handle, msg.sender)
-        );
-        ACLStorage storage $ = getACLStorage();
+        require(isAllowed(handle, msg.sender), SenderNotAllowedForHandle(handle, msg.sender));
+        AclStorage storage $ = getAclStorage();
         $.persistedAllowedForDecryption[handle] = true;
         uint256 id = getNextEventId();
         emit Reveal(handle, id);
@@ -65,7 +56,7 @@ abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControl
 
     /// @dev persistent
     function allowInternal(bytes32 handle, address account) internal {
-        ACLStorage storage $ = getACLStorage();
+        AclStorage storage $ = getAclStorage();
         $.persistedAllowedPairs[handle][account] = true;
         uint256 id = getNextEventId();
         emit Allow(handle, account, id);
@@ -74,10 +65,7 @@ abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControl
 
     // todo current transient allowance is unsafe, make storage account bound + how to clean between UserOps
     function allowTransient(bytes32 handle, address account) public {
-        require(
-            isAllowed(handle, msg.sender),
-            SenderNotAllowedForHandle(handle, msg.sender)
-        );
+        require(isAllowed(handle, msg.sender), SenderNotAllowedForHandle(handle, msg.sender));
         allowTransientInternal(handle, account);
     }
 
@@ -93,10 +81,7 @@ abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControl
         }
     }
 
-    function allowedTransient(
-        bytes32 handle,
-        address account
-    ) public view returns (bool) {
+    function allowedTransient(bytes32 handle, address account) public view returns (bool) {
         bool isAllowedTransient;
         bytes32 key = keccak256(abi.encodePacked(handle, account));
         assembly {
@@ -110,11 +95,7 @@ abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControl
             let length := tload(0)
             tstore(0, 0)
             let lengthPlusOne := add(length, 1)
-            for {
-                let i := 1
-            } lt(i, lengthPlusOne) {
-                i := add(i, 1)
-            } {
+            for { let i := 1 } lt(i, lengthPlusOne) { i := add(i, 1) } {
                 let handle := tload(i)
                 tstore(i, 0)
                 tstore(handle, 0)
@@ -126,36 +107,24 @@ abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControl
         require(
             incoVerifier.isAllowedWithProof(handle, msg.sender, proof),
             ProofVerificationFailed(
-                proof.voucher.verifyingContract,
-                proof.voucher.callFunction,
-                proof.voucher.sharerArgData
+                proof.voucher.verifyingContract, proof.voucher.callFunction, proof.voucher.sharerArgData
             )
         );
         allowInternal(handle, msg.sender);
     }
 
-    function persistAllowed(
-        bytes32 handle,
-        address account
-    ) public view returns (bool) {
-        ACLStorage storage $ = getACLStorage();
+    function persistAllowed(bytes32 handle, address account) public view returns (bool) {
+        AclStorage storage $ = getAclStorage();
         return $.persistedAllowedPairs[handle][account];
     }
 
-    function isAllowed(
-        bytes32 handle,
-        address account
-    ) public view returns (bool) {
-        return
-            allowedTransient(handle, account) ||
-            persistAllowed(handle, account) ||
-            isRevealed(handle);
+    function isAllowed(bytes32 handle, address account) public view returns (bool) {
+        return allowedTransient(handle, account) || persistAllowed(handle, account) || isRevealed(handle);
     }
 
-    function isRevealed(
-        bytes32 handle
-    ) public view returns (bool) {
-        ACLStorage storage $ = getACLStorage();
+    function isRevealed(bytes32 handle) public view returns (bool) {
+        AclStorage storage $ = getAclStorage();
         return $.persistedAllowedForDecryption[handle];
     }
+
 }

package/src/lightning-parts/AccessControl/interfaces/IAdvancedAccessControl.sol

@@ -1,25 +1,18 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {
-    AllowanceProof,
-    AllowanceVoucher
-} from "../AdvancedAccessControl.types.sol";
+import {AllowanceProof, AllowanceVoucher} from "../AdvancedAccessControl.types.sol";
 
 interface IVoucherEip712Checker {
-    function allowanceVoucherDigest(
-        AllowanceVoucher memory voucher
-    ) external view returns (bytes32);
+
+    function allowanceVoucherDigest(AllowanceVoucher memory voucher) external view returns (bytes32);
+
 }
 
 interface IAdvancedAccessControl is IVoucherEip712Checker {
-    function isAllowedWithProof(
-        bytes32 handle,
-        address account,
-        AllowanceProof memory proof
-    ) external returns (bool);
-    function getActiveVouchersSessionNonce(
-        address account
-    ) external view returns (bytes32);
+
+    function isAllowedWithProof(bytes32 handle, address account, AllowanceProof memory proof) external returns (bool);
+    function getActiveVouchersSessionNonce(address account) external view returns (bytes32);
     function updateActiveVouchersSessionNonce() external;
+
 }

package/src/lightning-parts/AccessControl/interfaces/IBaseAccessControlList.sol

@@ -5,20 +5,13 @@ import {IVerifierAddressGetter} from "../../primitives/interfaces/IVerifierAddre
 import {AllowanceProof} from "../AdvancedAccessControl.types.sol";
 
 interface IBaseAccessControlList is IVerifierAddressGetter {
+
     function allow(bytes32 handle, address account) external;
     function allowTransient(bytes32 handle, address account) external;
-    function allowedTransient(
-        bytes32 handle,
-        address account
-    ) external view returns (bool);
+    function allowedTransient(bytes32 handle, address account) external view returns (bool);
     function cleanTransientStorage() external;
-    function persistAllowed(
-        bytes32 handle,
-        address account
-    ) external view returns (bool);
-    function isAllowed(
-        bytes32 handle,
-        address account
-    ) external view returns (bool);
+    function persistAllowed(bytes32 handle, address account) external view returns (bool);
+    function isAllowed(bytes32 handle, address account) external view returns (bool);
     function claimHandle(bytes32 handle, AllowanceProof memory proof) external;
+
 }

package/src/lightning-parts/AccessControl/test/TestAdvancedAccessControl.t.sol

@@ -11,6 +11,7 @@ import {ALLOWANCE_GRANTED_MAGIC_VALUE} from "../../../Types.sol";
 import {IIncoVerifier} from "../../../interfaces/IIncoVerifier.sol";
 
 contract SomeContractWithConfidentialData {
+
     using e for bytes;
     using e for euint256;
 
@@ -20,9 +21,11 @@ contract SomeContractWithConfidentialData {
         secret = ciphertext.newEuint256(msg.sender);
         secret.allow(msg.sender);
     }
+
 }
 
 contract SomeVerifier {
+
     struct SharerArg {
         bytes32 handleShared;
         address allowedAccount;
@@ -32,40 +35,43 @@ contract SomeVerifier {
         bytes2 mustBeBeef;
     }
 
-    function someCheck(
-        bytes32 handle,
-        address account,
-        bytes memory sharerArgData,
-        bytes memory requesterArgData
-    ) public pure returns (bytes32) {
+    function someCheck(bytes32 handle, address account, bytes memory sharerArgData, bytes memory requesterArgData)
+        public
+        pure
+        returns (bytes32)
+    {
         SharerArg memory sharerArg = abi.decode(sharerArgData, (SharerArg));
-        RequesterArg memory requesterArg = abi.decode(
-            requesterArgData,
-            (RequesterArg)
-        );
+        RequesterArg memory requesterArg = abi.decode(requesterArgData, (RequesterArg));
         if (
-            requesterArg.mustBeBeef == bytes2(0xbeef) &&
-            sharerArg.handleShared == handle &&
-            sharerArg.allowedAccount == account
+            requesterArg.mustBeBeef == bytes2(0xbeef) && sharerArg.handleShared == handle
+                && sharerArg.allowedAccount == account
         ) {
             return ALLOWANCE_GRANTED_MAGIC_VALUE;
         }
         return bytes32(0);
     }
+
 }
 
 contract DoesNotVerifyAnything {
+
     function someCheck(
-        bytes32 /* handle */,
-        address /* account */,
-        bytes memory /* sharerArgData */,
+        bytes32, /* handle */
+        address, /* account */
+        bytes memory, /* sharerArgData */
         bytes memory /* requesterArgData */
-    ) public pure returns (bytes32) {
+    )
+        public
+        pure
+        returns (bytes32)
+    {
         return ALLOWANCE_GRANTED_MAGIC_VALUE;
     }
+
 }
 
 contract TestAdvancedAccessControl is IncoTest {
+
     SomeContractWithConfidentialData someContract;
     bytes32 secretHandle;
     IIncoVerifier incoVerifier;
@@ -83,35 +89,21 @@ contract TestAdvancedAccessControl is IncoTest {
 
     function testAdvancedSharingWithSession() public {
         SessionVerifier sessionVerifier = new SessionVerifier("");
-        assertFalse(
-            inco.isAllowed(secretHandle, bob),
-            "bob should't be allowed on secret yet"
-        );
-        assertTrue(
-            inco.isAllowed(secretHandle, alice),
-            "alice should be allowed on secret"
-        );
+        assertFalse(inco.isAllowed(secretHandle, bob), "bob should't be allowed on secret yet");
+        assertTrue(inco.isAllowed(secretHandle, alice), "alice should be allowed on secret");
         AllowanceVoucher memory aliceSessionVoucherForBob = AllowanceVoucher({
             sessionNonce: bytes32(0),
             verifyingContract: address(sessionVerifier),
             callFunction: SessionVerifier.canUseSession.selector,
-            sharerArgData: abi.encode(
-                Session({decrypter: bob, expiresAt: block.timestamp + 1 days})
-            )
+            sharerArgData: abi.encode(Session({decrypter: bob, expiresAt: block.timestamp + 1 days}))
         });
-        AllowanceProof memory bobsProof = getBobsProof(
-            aliceSessionVoucherForBob
-        );
+        AllowanceProof memory bobsProof = getBobsProof(aliceSessionVoucherForBob);
         assertTrue(
-            incoVerifier.isAllowedWithProof(secretHandle, bob, bobsProof),
-            "bob should be allowed on secret with proof"
+            incoVerifier.isAllowedWithProof(secretHandle, bob, bobsProof), "bob should be allowed on secret with proof"
         );
         vm.prank(bob);
         inco.claimHandle(secretHandle, bobsProof);
-        assertTrue(
-            inco.persistAllowed(secretHandle, bob),
-            "bob should have claimed persistent allowance on secret"
-        );
+        assertTrue(inco.persistAllowed(secretHandle, bob), "bob should have claimed persistent allowance on secret");
     }
 
     function testVoucherSessionIdCheck() public {
@@ -137,24 +129,16 @@ contract TestAdvancedAccessControl is IncoTest {
         AllowanceProof memory invalidBobProof = getBobsProof(voucher);
         // the session nonce should be checked by inco
         vm.expectRevert(
-            abi.encodeWithSelector(
-                AdvancedAccessControl.InvalidVoucherSessionNonce.selector,
-                madeUpNonce,
-                bytes32(0)
-            )
+            abi.encodeWithSelector(AdvancedAccessControl.InvalidVoucherSessionNonce.selector, madeUpNonce, bytes32(0))
         );
         incoVerifier.isAllowedWithProof(secretHandle, bob, invalidBobProof);
         vm.prank(alice);
         incoVerifier.updateActiveVouchersSessionNonce();
-        bytes32 alicesNewNonce = incoVerifier.getActiveVouchersSessionNonce(
-            alice
-        );
+        bytes32 alicesNewNonce = incoVerifier.getActiveVouchersSessionNonce(alice);
         // previously valid voucher should now be invalid
         vm.expectRevert(
             abi.encodeWithSelector(
-                AdvancedAccessControl.InvalidVoucherSessionNonce.selector,
-                bytes32(0),
-                alicesNewNonce
+                AdvancedAccessControl.InvalidVoucherSessionNonce.selector, bytes32(0), alicesNewNonce
             )
         );
         incoVerifier.isAllowedWithProof(secretHandle, bob, bobsFirstProof);
@@ -177,59 +161,35 @@ contract TestAdvancedAccessControl is IncoTest {
             sessionNonce: bytes32(0),
             verifyingContract: address(verifier),
             callFunction: verifier.someCheck.selector,
-            sharerArgData: abi.encode(
-                SomeVerifier.SharerArg({
-                    handleShared: secretHandle,
-                    allowedAccount: bob
-                })
-            )
+            sharerArgData: abi.encode(SomeVerifier.SharerArg({handleShared: secretHandle, allowedAccount: bob}))
         });
         AllowanceProof memory bobsProof = AllowanceProof({
             sharer: alice,
             voucher: voucher,
             voucherSignature: getAliceSig(voucher),
-            requesterArgData: abi.encode(
-                SomeVerifier.RequesterArg({mustBeBeef: bytes2(0xbeef)})
-            )
+            requesterArgData: abi.encode(SomeVerifier.RequesterArg({mustBeBeef: bytes2(0xbeef)}))
         });
         assertTrue(
-            incoVerifier.isAllowedWithProof(secretHandle, bob, bobsProof),
-            "bob should be allowed on secret with proof"
+            incoVerifier.isAllowedWithProof(secretHandle, bob, bobsProof), "bob should be allowed on secret with proof"
         );
         bobsProof = AllowanceProof({
             sharer: alice,
             voucher: voucher,
             voucherSignature: getAliceSig(voucher),
-            requesterArgData: abi.encode(
-                SomeVerifier.RequesterArg({mustBeBeef: bytes2(0xbebe)})
-            )
+            requesterArgData: abi.encode(SomeVerifier.RequesterArg({mustBeBeef: bytes2(0xbebe)}))
         });
-        assertFalse(
-            incoVerifier.isAllowedWithProof(secretHandle, bob, bobsProof),
-            "all parameters should be checked"
-        );
+        assertFalse(incoVerifier.isAllowedWithProof(secretHandle, bob, bobsProof), "all parameters should be checked");
     }
 
-    function getBobsProof(
-        AllowanceVoucher memory alicesVoucher
-    ) private view returns (AllowanceProof memory) {
+    function getBobsProof(AllowanceVoucher memory alicesVoucher) private view returns (AllowanceProof memory) {
         bytes memory voucherSignature = getAliceSig(alicesVoucher);
-        return
-            AllowanceProof({
-                sharer: alice,
-                voucher: alicesVoucher,
-                voucherSignature: voucherSignature,
-                requesterArgData: ""
-            });
+        return AllowanceProof({
+            sharer: alice, voucher: alicesVoucher, voucherSignature: voucherSignature, requesterArgData: ""
+        });
     }
 
-    function getAliceSig(
-        AllowanceVoucher memory voucher
-    ) private view returns (bytes memory) {
-        return
-            getSignatureForDigest(
-                incoVerifier.allowanceVoucherDigest(voucher),
-                alicePrivKey
-            );
+    function getAliceSig(AllowanceVoucher memory voucher) private view returns (bytes memory) {
+        return getSignatureForDigest(incoVerifier.allowanceVoucherDigest(voucher), alicePrivKey);
     }
+
 }

package/src/lightning-parts/AccessControl/test/TestBaseAccessControl.t.sol

@@ -7,6 +7,7 @@ import {euint256, inco} from "../../../Lib.sol";
 import {IncoTest} from "../../../test/IncoTest.sol";
 
 contract TestBaseAccessControl is BaseAccessControlList, IncoTest {
+
     constructor() VerifierAddressGetter(address(0)) {}
 
     function testHandleZeroIsDisallowed() public view {
@@ -23,4 +24,5 @@ contract TestBaseAccessControl is BaseAccessControlList, IncoTest {
         assert(inco.isAllowed(euint256.unwrap(secret), address(this)));
         assert(inco.isAllowed(euint256.unwrap(secret), alice));
     }
+
 }

package/src/lightning-parts/DecryptionAttester.sol

@@ -9,37 +9,23 @@ import {IDecryptionAttester} from "./interfaces/IDecryptionAttester.sol";
 // todo pre charging transient decrypted values leads to a superior DevX
 
 // todo #1032 add DecryptionAttester to IncoVerifier, will include signature verifier as well and fix #874
-abstract contract DecryptionAttester is
-    IDecryptionAttester,
-    SignatureVerifier,
-    EIP712Upgradeable
-{
-    bytes32 constant DecryptionAttestationStructHash =
+abstract contract DecryptionAttester is IDecryptionAttester, SignatureVerifier, EIP712Upgradeable {
+
+    bytes32 constant DECRYPTION_ATTESTATION_STRUCT_HASH =
         keccak256("DecryptionAttestation(bytes32 handle,bytes32 value)");
 
-    function decryptionAttestationDigest(
-        DecryptionAttestation memory decryption
-    ) public view returns (bytes32) {
-        return
-            _hashTypedDataV4(
-                keccak256(
-                    abi.encode(
-                        DecryptionAttestationStructHash,
-                        decryption.handle,
-                        decryption.value
-                    )
-                )
-            );
+    function decryptionAttestationDigest(DecryptionAttestation memory decryption) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(abi.encode(DECRYPTION_ATTESTATION_STRUCT_HASH, decryption.handle, decryption.value))
+        );
     }
 
-    function isValidDecryptionAttestation(
-        DecryptionAttestation memory decryption,
-        bytes memory signature
-    ) public view returns (bool) {
-        return
-            isValidSignature(
-                decryptionAttestationDigest(decryption),
-                signature
-            );
+    function isValidDecryptionAttestation(DecryptionAttestation memory decryption, bytes[] memory signatures)
+        public
+        view
+        returns (bool)
+    {
+        return isValidSignature(decryptionAttestationDigest(decryption), signatures);
     }
+
 }

package/src/lightning-parts/EncryptedInput.sol

@@ -20,68 +20,43 @@ error ExternalHandleDoesNotMatchComputedHandle(
     address contractAddress
 );
 
-abstract contract EncryptedInput is
-    IEncryptedInput,
-    BaseAccessControlList,
-    HandleGeneration,
-    Fee
-{
+abstract contract EncryptedInput is IEncryptedInput, BaseAccessControlList, HandleGeneration, Fee {
+
     event NewInput(
-        bytes32 indexed result,
-        address indexed contractAddress,
-        address indexed user,
-        bytes ciphertext,
-        uint256 eventId
+        bytes32 indexed result, address indexed contractAddress, address indexed user, bytes ciphertext, uint256 eventId
     );
 
-    function newEuint256(
-        bytes memory input,
-        address user
-    ) external payable returns (euint256 newValue) {
+    function newEuint256(bytes memory input, address user) external payable returns (euint256 newValue) {
         return euint256.wrap(newInput(input, user, ETypes.Uint256));
     }
 
-    function newEbool(
-        bytes memory input,
-        address user
-    ) external payable returns (ebool newValue) {
+    function newEbool(bytes memory input, address user) external payable returns (ebool newValue) {
         return ebool.wrap(newInput(input, user, ETypes.Bool));
     }
 
-    function newEaddress(
-        bytes memory input,
-        address user
-    ) external payable returns (eaddress newValue) {
-        return
-            eaddress.wrap(
-            newInput(input, user, ETypes.AddressOrUint160OrBytes20)
-        );
+    function newEaddress(bytes memory input, address user) external payable returns (eaddress newValue) {
+        return eaddress.wrap(newInput(input, user, ETypes.AddressOrUint160OrBytes20));
     }
 
-    function newInput(
-        bytes memory ciphertext,
-        address user,
-        ETypes inputType
-    ) internal paying returns (bytes32 newHandle) {
+    function newInput(bytes memory ciphertext, address user, ETypes inputType)
+        internal
+        paying
+        returns (bytes32 newHandle)
+    {
         newHandle = _newInput(ciphertext, user, inputType);
     }
 
-    function newInputNotPaying(
-        bytes memory ciphertext,
-        address user,
-        ETypes inputType
-    ) internal returns (bytes32 newHandle) {
+    function newInputNotPaying(bytes memory ciphertext, address user, ETypes inputType)
+        internal
+        returns (bytes32 newHandle)
+    {
         newHandle = _newInput(ciphertext, user, inputType);
     }
 
     /// @notice Creates a new input with a prepended handle as a checksum.
     /// @param input The input that contains the handle prepended to the ciphertext.
     /// @param user The user address associated with the input.
-    function _newInput(
-        bytes memory input,
-        address user,
-        ETypes inputType
-    ) private returns (bytes32 handle) {
+    function _newInput(bytes memory input, address user, ETypes inputType) private returns (bytes32 handle) {
         // Since there is no sensible way to handle abi.decode errors (https://github.com/argotorg/solidity/issues/10381)
         // at least fail early on a conservative minimum length
         require(input.length >= 64, "Input too short, should be at least 64 bytes");
@@ -102,17 +77,13 @@ abstract contract EncryptedInput is
         // We assume that providing the same handle (which via HADU implies same plaintext, same context, and same
         // instance of encryption)
         require(!isAllowed(handle, user), HandleAlreadyExists(handle));
-        // We allow to user since this is harmless and it is convenient to use the allow mapping to track existing
-        allowInternal(handle, user);
-        allowTransientInternal(handle, msg.sender);
         uint256 id = getNextEventId();
-        emit NewInput({
-            result: handle,
-            contractAddress: msg.sender,
-            user: user,
-            ciphertext: ciphertext,
-            eventId: id
-        });
+        emit NewInput({result: handle, contractAddress: msg.sender, user: user, ciphertext: ciphertext, eventId: id});
         setDigest(abi.encodePacked(handle, id));
+        // We allow to user since this is harmless and it is convenient to use the allow mapping to track inputs.
+        // NOTE: the allow must come after emitting the new input event, since allow emits its own event.
+        allowInternal(handle, user);
+        allowTransientInternal(handle, msg.sender);
     }
+
 }