@inco/lightning 0.10.0-devnet-3 → 0.11.0-testnet-1

package/src/libs/incoLightning_testnet_v2_889158349.sol

@@ -801,6 +801,13 @@ library e {
         inco.allow(eaddress.unwrap(a), to);
     }
 
+    /// @notice Allows an address to access an elist
+    ///  @param a The elist
+    ///  @param to The address to allow
+    function allow(elist a, address to) internal {
+        inco.allow(elist.unwrap(a), to);
+    }
+
     /// @notice Reveals an encrypted uint256
     ///  @param a The encrypted uint256
     function reveal(euint256 a) internal {
@@ -819,6 +826,12 @@ library e {
         inco.reveal(eaddress.unwrap(a));
     }
 
+    /// @notice Reveals an elist (makes all elements publicly readable without wallet authentication)
+    ///  @param a The elist
+    function reveal(elist a) internal {
+        inco.reveal(elist.unwrap(a));
+    }
+
     /// @notice Verifies a decryption attestation for a euint256
     ///  @param handle The encrypted handle
     ///  @param value The claimed decrypted value
@@ -857,6 +870,12 @@ library e {
         allow(a, address(this));
     }
 
+    /// @notice Allows this contract to access an elist
+    ///  @param a The elist
+    function allowThis(elist a) internal {
+        allow(a, address(this));
+    }
+
     /// @notice Checks if a user is allowed to access an encrypted uint256
     ///  @param user The address to check
     ///  @param a The encrypted uint256

package/src/lightning-parts/EncryptedOperations.sol

@@ -7,6 +7,8 @@ import {
     EOps,
     SenderNotAllowedForHandle,
     ETypes,
+    UnexpectedType,
+    UnsupportedType,
     isTypeSupported,
     canCastTo,
     typeToBitMask
@@ -24,15 +26,6 @@ import {Fee} from "./Fee.sol";
 /// from the operation and inputs, enabling consistent state across chains.
 abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControlList, HandleGeneration, Fee {
 
-    /// @notice Thrown when an operation receives a handle of an unexpected type.
-    /// @param actual The actual type of the handle.
-    /// @param expectedTypes A bitmask of the expected types.
-    error UnexpectedType(ETypes actual, bytes32 expectedTypes);
-
-    /// @notice Thrown when an operation receives an unsupported type.
-    /// @param actual The unsupported type.
-    error UnsupportedType(ETypes actual);
-
     /// @notice Thrown when a cast is attempted to the same type.
     /// @param t The type that was both source and target.
     error SameTypeCast(ETypes t);

package/src/lightning-parts/primitives/EListHandleMetadata.sol

@@ -24,12 +24,12 @@ contract EListHandleMetadata is IEListHandleMetadata {
     /// @notice Embeds the list length into a list handle
     /// @dev Sets bytes 27-28 of the handle to the list length.
     ///      Clears existing length bits before setting new value.
-    /// @param prehandle The 32-byte handle before length embedding
+    /// @param handle The 32-byte handle before length embedding
     /// @param len The number of elements in the list (max 65535)
     /// @return result The handle with embedded list length
-    function embedListLength(bytes32 prehandle, uint16 len) internal pure returns (bytes32 result) {
+    function embedListLength(bytes32 handle, uint16 len) internal pure returns (bytes32 result) {
         // 27 and 28 bits are used for the list length
-        result = prehandle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffffff;
+        result = handle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffffff;
         result = bytes32(uint256(result) | (uint256(len) << 24)); // append length
     }
 
@@ -44,11 +44,11 @@ contract EListHandleMetadata is IEListHandleMetadata {
     /// @notice Embeds the element type into a list handle
     /// @dev Sets byte 29 of the handle to the element type.
     ///      This indicates the encrypted type of individual elements (euint8, euint64, etc.).
-    /// @param prehandle The 32-byte handle before type embedding
+    /// @param handle The 32-byte handle before type embedding
     /// @param listType The encrypted type of list elements
     /// @return result The handle with embedded element type
-    function embedListType(bytes32 prehandle, ETypes listType) internal pure returns (bytes32 result) {
-        result = prehandle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffff;
+    function embedListType(bytes32 handle, ETypes listType) internal pure returns (bytes32 result) {
+        result = handle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffff;
         result = bytes32(uint256(result) | (uint256(listType) << 16)); // append element type
     }
 

package/src/lightning-parts/primitives/HandleGeneration.sol

@@ -7,7 +7,6 @@ import {
     EVM_HOST_CHAIN_PREFIX,
     HANDLE_INDEX,
     HANDLE_VERSION,
-    SEP_INPUT_PREHANDLE,
     SEP_INPUT_HANDLE,
     SEP_OP_RESULT
 } from "../../Types.sol";
@@ -78,14 +77,6 @@ contract HandleGeneration is IHandleGeneration, HandleMetadata {
         uint16 version,
         ETypes inputType
     ) internal view returns (bytes32 generatedHandle) {
-        // Prehandle is a legacy concept inherited by an earlier design where we had a preflight system for uploading ciphertexts to an L1 before they could be used.
-        // This is no longer the case and prehandle was mainly kept for compatibility and consistency with the intrernal design docs.
-        // To avoid calling keccak256 twice and save gas the prehandle concept will be dropped in a future PR.
-        bytes32 ctIndexHash = keccak256(
-            // We don't encode the length of the ciphertext because it's the only variable length field which should prevent collisions.
-            abi.encodePacked(SEP_INPUT_PREHANDLE, keccak256(ciphertext), HANDLE_INDEX)
-        );
-        bytes32 prehandle = embedIndexTypeVersion(ctIndexHash, inputType);
         // We must also propagate the handle metadata to the final handle
         generatedHandle = embedIndexTypeVersion(
             keccak256(
@@ -93,7 +84,9 @@ contract HandleGeneration is IHandleGeneration, HandleMetadata {
                     SEP_INPUT_HANDLE,
                     HANDLE_VERSION,
                     inputType,
-                    prehandle,
+                    uint32(ciphertext.length),
+                    ciphertext,
+                    HANDLE_INDEX,
                     EVM_HOST_CHAIN_PREFIX,
                     block.chainid, // todo cache this
                     executorAddress,

package/src/lightning-parts/primitives/HandleMetadata.sol

@@ -16,35 +16,35 @@ contract HandleMetadata {
     /// @param raw The raw uint8 value extracted from the handle.
     error InvalidTypeValue(uint8 raw);
 
-    /// @notice Embeds the handle index, encrypted type, and protocol version into a prehandle
+    /// @notice Embeds the handle index, encrypted type, and protocol version into a handle
     /// @dev Used for input handles where the index distinguishes the source.
-    ///      Clears bytes 29-31 of the prehandle, then sets:
+    ///      Clears bytes 29-31 of the handle, then sets:
     ///      - Byte 29: HANDLE_INDEX constant
     ///      - Byte 30: inputType enum value
     ///      - Byte 31: HANDLE_VERSION constant
-    /// @param prehandle The 32-byte hash before metadata embedding
+    /// @param handle The 32-byte hash before metadata embedding
     /// @param inputType The encrypted type to embed (ebool, euint8, etc.)
     /// @return result The complete handle with embedded metadata
-    function embedIndexTypeVersion(bytes32 prehandle, ETypes inputType) internal pure returns (bytes32 result) {
+    function embedIndexTypeVersion(bytes32 handle, ETypes inputType) internal pure returns (bytes32 result) {
         // Create a mask to clear the last three bytes
         bytes32 mask = bytes32(uint256(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00FFFF));
         // Clear the last three bytes of the original value
-        bytes32 clearedOriginal = prehandle & mask;
+        bytes32 clearedOriginal = handle & mask;
         // Combine the cleared original value with the new last three bytes
         result = clearedOriginal | bytes32((uint256(HANDLE_INDEX) << 16));
         result = embedTypeVersion(result, inputType);
     }
 
-    /// @notice Embeds the encrypted type and protocol version into a prehandle
+    /// @notice Embeds the encrypted type and protocol version into a handle
     /// @dev Used for operation result handles and trivial encryptions.
-    ///      Clears bytes 30-31 of the prehandle, then sets:
+    ///      Clears bytes 30-31 of the handle, then sets:
     ///      - Byte 30: handleType enum value
     ///      - Byte 31: HANDLE_VERSION constant
-    /// @param prehandle The 32-byte hash before metadata embedding
+    /// @param handle The 32-byte hash before metadata embedding
     /// @param handleType The encrypted type to embed (ebool, euint8, etc.)
     /// @return result The handle with type and version embedded
-    function embedTypeVersion(bytes32 prehandle, ETypes handleType) internal pure returns (bytes32 result) {
-        result = prehandle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000;
+    function embedTypeVersion(bytes32 handle, ETypes handleType) internal pure returns (bytes32 result) {
+        result = handle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000;
         result = bytes32(uint256(result) | (uint256(handleType) << 8)); // append type
         result = bytes32(uint256(result) | HANDLE_VERSION);
     }

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

@@ -16,7 +16,9 @@ import {
     typeToBitMask,
     EOps,
     isTypeSupported,
-    SenderNotAllowedForHandle
+    SenderNotAllowedForHandle,
+    UnexpectedType,
+    UnsupportedType
 } from "../../Types.sol";
 import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
 import {FEE} from "../Fee.sol";
@@ -77,11 +79,7 @@ contract TestHandleMetadata is
         ebool control = this.asEbool(false);
         euint256 a = this.asEuint256(42);
         ebool b = this.asEbool(true);
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)));
         this.eIfThenElse(control, euint256.unwrap(a), ebool.unwrap(b));
     }
 
@@ -286,11 +284,7 @@ contract TestHandleMetadata is
         ebool b = this.asEbool(true);
         // Error: UnexpectedType(typeOf(rhs), typeToBitMask(lhsType))
         // With lhs=Uint256, rhs=Bool: UnexpectedType(Bool, typeToBitMask(Uint256))
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)));
         this.eBitAnd(euint256.unwrap(a), ebool.unwrap(b));
     }
 
@@ -298,11 +292,7 @@ contract TestHandleMetadata is
     function testEBitOrTypeMismatch() public {
         euint256 a = this.asEuint256(42);
         ebool b = this.asEbool(true);
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)));
         this.eBitOr(euint256.unwrap(a), ebool.unwrap(b));
     }
 
@@ -310,11 +300,7 @@ contract TestHandleMetadata is
     function testEBitXorTypeMismatch() public {
         euint256 a = this.asEuint256(42);
         ebool b = this.asEbool(true);
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)));
         this.eBitXor(euint256.unwrap(a), ebool.unwrap(b));
     }
 
@@ -322,7 +308,7 @@ contract TestHandleMetadata is
     function testECastUnsupportedType() public {
         euint256 a = this.asEuint256(42);
         ETypes unsupportedType = ETypes.Uint4UNSUPPORTED;
-        vm.expectRevert(abi.encodeWithSelector(EncryptedOperations.UnsupportedType.selector, unsupportedType));
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, unsupportedType));
         this.eCast(euint256.unwrap(a), unsupportedType);
     }
 
@@ -330,7 +316,7 @@ contract TestHandleMetadata is
     function testERandBoundedUnsupportedType() public {
         euint256 bound = this.asEuint256(100);
         ETypes unsupportedType = ETypes.Uint4UNSUPPORTED;
-        vm.expectRevert(abi.encodeWithSelector(EncryptedOperations.UnsupportedType.selector, unsupportedType));
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, unsupportedType));
         this.eRandBounded{value: FEE}(euint256.unwrap(bound), unsupportedType);
     }
 
@@ -340,7 +326,7 @@ contract TestHandleMetadata is
         // Create a handle with unsupported type by manually crafting one
         bytes32 unsupportedHandle = embedIndexTypeVersion(bytes32(uint256(1)), ETypes.Uint4UNSUPPORTED);
         ebool ifFalse = this.asEbool(false);
-        vm.expectRevert(abi.encodeWithSelector(EncryptedOperations.UnsupportedType.selector, ETypes.Uint4UNSUPPORTED));
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, ETypes.Uint4UNSUPPORTED));
         this.eIfThenElse(control, unsupportedHandle, ebool.unwrap(ifFalse));
     }
 
@@ -351,11 +337,7 @@ contract TestHandleMetadata is
         ebool ifFalse = this.asEbool(false);
         // ifTrue is Uint256, ifFalse is Bool - type mismatch should trigger checkInput failure
         // Error is UnexpectedType(ifFalse type=Bool, required type mask for Uint256)
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)));
         this.eIfThenElse(control, euint256.unwrap(ifTrue), ebool.unwrap(ifFalse));
     }
 
@@ -379,7 +361,7 @@ contract TestHandleMetadata is
     // ============ Fuzz Tests for HandleMetadata ============
 
     /// @dev Fuzz test for type embedding round-trip: typeOf(embedTypeVersion(h, t)) == t
-    function testFuzzTypeEmbeddingRoundTrip(bytes32 prehandle, uint8 typeIndex) public pure {
+    function testFuzzTypeEmbeddingRoundTrip(bytes32 handle, uint8 typeIndex) public pure {
         // Constrain to supported types (0=Bool, 7=AddressOrUint160OrBytes20, 8=Uint256)
         ETypes inputType;
         uint8 typeSelector = typeIndex % 3;
@@ -391,14 +373,14 @@ contract TestHandleMetadata is
             inputType = ETypes.Uint256;
         }
 
-        bytes32 embeddedHandle = embedTypeVersion(prehandle, inputType);
+        bytes32 embeddedHandle = embedTypeVersion(handle, inputType);
         ETypes extractedType = typeOf(embeddedHandle);
 
         assert(extractedType == inputType);
     }
 
     /// @dev Fuzz test for embedIndexTypeVersion round-trip
-    function testFuzzEmbedIndexTypeVersionRoundTrip(bytes32 prehandle, uint8 typeIndex) public pure {
+    function testFuzzEmbedIndexTypeVersionRoundTrip(bytes32 handle, uint8 typeIndex) public pure {
         // Constrain to supported types
         ETypes inputType;
         uint8 typeSelector = typeIndex % 3;
@@ -410,14 +392,14 @@ contract TestHandleMetadata is
             inputType = ETypes.Uint256;
         }
 
-        bytes32 embeddedHandle = embedIndexTypeVersion(prehandle, inputType);
+        bytes32 embeddedHandle = embedIndexTypeVersion(handle, inputType);
         ETypes extractedType = typeOf(embeddedHandle);
 
         assert(extractedType == inputType);
     }
 
     /// @dev Fuzz test that typeOf correctly extracts type from handles with valid embedded types
-    function testFuzzTypeOfExtraction(bytes32 prehandle, uint8 typeIndex) public pure {
+    function testFuzzTypeOfExtraction(bytes32 handle, uint8 typeIndex) public pure {
         // First embed a valid type, then verify extraction
         ETypes inputType;
         uint8 typeSelector = typeIndex % 3;
@@ -429,7 +411,7 @@ contract TestHandleMetadata is
             inputType = ETypes.Uint256;
         }
 
-        bytes32 handle = embedTypeVersion(prehandle, inputType);
+        bytes32 handle = embedTypeVersion(handle, inputType);
 
         // Extract the type from the handle
         ETypes extractedType = typeOf(handle);
@@ -444,7 +426,7 @@ contract TestHandleMetadata is
     }
 
     /// @dev Fuzz test that embedding preserves upper bits of handle
-    function testFuzzEmbeddingPreservesUpperBits(bytes32 prehandle, uint8 typeIndex) public pure {
+    function testFuzzEmbeddingPreservesUpperBits(bytes32 handle, uint8 typeIndex) public pure {
         ETypes inputType;
         uint8 typeSelector = typeIndex % 3;
         if (typeSelector == 0) {
@@ -455,16 +437,16 @@ contract TestHandleMetadata is
             inputType = ETypes.Uint256;
         }
 
-        bytes32 embeddedHandle = embedTypeVersion(prehandle, inputType);
+        bytes32 embeddedHandle = embedTypeVersion(handle, inputType);
 
         // Verify upper 30 bytes (240 bits) are preserved
         // Mask out the lower 2 bytes (16 bits) for comparison
         bytes32 upperMask = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000;
-        assert((prehandle & upperMask) == (embeddedHandle & upperMask));
+        assert((handle & upperMask) == (embeddedHandle & upperMask));
     }
 
     /// @dev Fuzz test that embedIndexTypeVersion clears index byte correctly
-    function testFuzzEmbedIndexClearsCorrectly(bytes32 prehandle, uint8 typeIndex) public pure {
+    function testFuzzEmbedIndexClearsCorrectly(bytes32 handle, uint8 typeIndex) public pure {
         ETypes inputType;
         uint8 typeSelector = typeIndex % 3;
         if (typeSelector == 0) {
@@ -475,7 +457,7 @@ contract TestHandleMetadata is
             inputType = ETypes.Uint256;
         }
 
-        bytes32 embeddedHandle = embedIndexTypeVersion(prehandle, inputType);
+        bytes32 embeddedHandle = embedIndexTypeVersion(handle, inputType);
 
         // Extract index byte (bits 16-23) - should be HANDLE_INDEX (0)
         uint8 indexByte = uint8(uint256(embeddedHandle) >> 16);

package/src/test/IncoTest.sol

@@ -60,9 +60,8 @@ contract IncoTest is MockOpHandler, DeployUtils, FakeDecryptionAttester, MockRem
         (IIncoLightning proxy,) = deployIncoLightningUsingConfig({
             deployer: testDeployer,
             owner: owner,
-            // The highest precedent deployment
-            // We select the pepper that will be used that will be generated in the lib.sol (usually "testnet"), but currently "alphanet" has higher major version
-            pepper: "devnet",
+            // The highest precedent deployment pepper
+            pepper: "testnet",
             quoteVerifier: new FakeQuoteVerifier()
         });
         vm.stopPrank();

package/src/test/TestLib.t.sol

@@ -644,6 +644,27 @@ contract TestLib is IncoTest {
         assertTrue(inco.persistAllowed(eaddress.unwrap(a), address(this)));
     }
 
+    function testAllowElist() public {
+        elist list = _listRange(0, 3, ETypes.Uint256);
+        assertFalse(inco.persistAllowed(elist.unwrap(list), alice));
+        e.allow(list, alice);
+        assertTrue(inco.persistAllowed(elist.unwrap(list), alice));
+    }
+
+    function testRevealElist() public {
+        elist list = _listRange(0, 3, ETypes.Uint256);
+        assertFalse(inco.isRevealed(elist.unwrap(list)));
+        e.reveal(list);
+        assertTrue(inco.isRevealed(elist.unwrap(list)));
+    }
+
+    function testAllowThisElist() public {
+        elist list = _listRange(0, 3, ETypes.Uint256);
+        assertFalse(inco.persistAllowed(elist.unwrap(list), address(this)));
+        e.allowThis(list);
+        assertTrue(inco.persistAllowed(elist.unwrap(list), address(this)));
+    }
+
     function testIsAllowed() public {
         euint256 a = e.asEuint256(42);
         processAllOperations();
@@ -1558,6 +1579,36 @@ contract TestLib is IncoTest {
         assertFalse(result, "Empty proof should fail verification");
     }
 
+    // ============ ELIST ALLOW / REVEAL / ALLOWTHIS WRAPPER TESTS ============
+
+    function testEListWrapper_Allow() public {
+        _setupEListHelper();
+        elist list = elistHelper.callRange(0, 3);
+
+        assertFalse(inco.persistAllowed(elist.unwrap(list), alice));
+        elistHelper.callAllowElist(list, alice);
+        assertTrue(inco.persistAllowed(elist.unwrap(list), alice));
+    }
+
+    function testEListWrapper_Reveal() public {
+        _setupEListHelper();
+        elist list = elistHelper.callRange(0, 3);
+
+        assertFalse(inco.isRevealed(elist.unwrap(list)));
+        elistHelper.callRevealElist(list);
+        assertTrue(inco.isRevealed(elist.unwrap(list)));
+    }
+
+    function testEListWrapper_AllowThis() public {
+        _setupEListHelper();
+        // elistHelper must create the list so it has transient access, which is required to call allow
+        elist list = elistHelper.callRange(0, 3);
+
+        assertFalse(inco.persistAllowed(elist.unwrap(list), address(elistHelper)));
+        elistHelper.callAllowThisElist(list);
+        assertTrue(inco.persistAllowed(elist.unwrap(list), address(elistHelper)));
+    }
+
 }
 
 /// @notice Helper contract for testing msg.sender variants
@@ -1758,4 +1809,18 @@ contract LibEListHelper {
         return e.verifyEListDecryption(elistHandle, proofElements, proof, signatures);
     }
 
+    // ============ allow / reveal / allowThis wrappers ============
+
+    function callAllowElist(elist list, address to) external {
+        e.allow(list, to);
+    }
+
+    function callRevealElist(elist list) external {
+        e.reveal(list);
+    }
+
+    function callAllowThisElist(elist list) external {
+        e.allowThis(list);
+    }
+
 }

package/src/version/IncoLightningConfig.sol

@@ -7,7 +7,7 @@ pragma solidity ^0.8;
 // UPDATE the CHANGELOG on new versions
 
 string constant CONTRACT_NAME = "incoLightning";
-uint8 constant MAJOR_VERSION = 10;
+uint8 constant MAJOR_VERSION = 11;
 uint8 constant MINOR_VERSION = 0;
 // whenever a new version is deployed, we need to pump this up
 // otherwise make test_upgrade will fail