@inco/lightning 0.8.0-devnet-23 → 0.8.0-devnet-24

package/src/lightning-parts/EList.sol

@@ -46,7 +46,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
         elist indexed result,
         uint256 eventId
     );
-    event EListRange(uint256 indexed start, uint256 indexed end, elist indexed result, uint256 eventId);
+    event EListRange(
+        uint256 indexed start, uint256 indexed end, ETypes listType, elist indexed result, uint256 eventId
+    );
     event EListShuffle(elist indexed list, uint256 indexed counter, elist indexed result, uint256 eventId);
     event EListReverse(elist indexed list, elist indexed result, uint256 eventId);
 
@@ -128,14 +130,6 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
         return newEListFromInputs(inputs, listType, user);
     }
 
-    /// @notice Returns the element type of an encrypted list handle.
-    /// @dev Extracts the type from the handle's metadata bytes.
-    /// @param handle The list handle to inspect.
-    /// @return The ETypes enum value representing the element type.
-    function elementTypeOf(bytes32 handle) internal pure returns (ETypes) {
-        return ETypes(uint8(uint256(handle) >> 16));
-    }
-
     /// @notice Appends an encrypted value to the end of an encrypted list.
     /// @dev Returns a new list with the value appended; original list is unchanged.
     /// @param list The encrypted list to append to.
@@ -329,22 +323,22 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @dev Creates a list of euint256 values from start (inclusive) to end (exclusive).
     /// @param start The starting value (inclusive).
     /// @param end The ending value (exclusive). Must be >= start.
+    /// @param listType The type of elements in the list.
     /// @return result A new encrypted list containing the range [start, end).
-    function listRange(uint16 start, uint16 end)
+    function listRange(uint16 start, uint16 end, ETypes listType)
         external
         payable
-        payingElistFee(uint256(end - start) * typeBitSize(ETypes.Uint256))
+        payingElistFee(uint256(end - start) * typeBitSize(listType))
         returns (elist result)
     {
         require(start <= end, InvalidRange(start, end));
 
-        result = elist.wrap(
-            createListResultHandle(EOps.EListRange, ETypes.Uint256, end - start, abi.encodePacked(start, end))
-        );
+        result =
+            elist.wrap(createListResultHandle(EOps.EListRange, listType, end - start, abi.encodePacked(start, end)));
         allowTransientInternal(elist.unwrap(result), msg.sender);
         uint256 id = getNextEventId();
         setDigest(abi.encodePacked(elist.unwrap(result), id));
-        emit EListRange(start, end, result, id);
+        emit EListRange(start, end, listType, result, id);
     }
 
     /// @notice Randomly shuffles the elements of an encrypted list.

package/src/lightning-parts/EncryptedOperations.sol

@@ -33,6 +33,10 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     /// @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);
+
     uint256 internal randCounter;
     uint256 internal constant ONE = 1;
 
@@ -176,11 +180,11 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     /// @param rhs The right-hand side encrypted operand (must be same type as lhs).
     /// @return result The encrypted bitwise AND result.
     function eBitAnd(bytes32 lhs, bytes32 rhs) external returns (bytes32 result) {
+        checkInput(lhs, SUPPORTED_TYPES_MASK);
+        checkInput(rhs, SUPPORTED_TYPES_MASK);
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
-        checkInput(lhs, typeToBitMask(lhsType));
-        checkInput(rhs, typeToBitMask(rhsType));
-        require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
+        require(lhsType == rhsType, UnexpectedType(rhsType, typeToBitMask(lhsType)));
         uint256 id = getNextEventId();
         result = createResultHandle(EOps.BitAnd, lhsType, abi.encodePacked(lhs, rhs));
         emit EBitAnd(lhs, rhs, result, id);
@@ -192,11 +196,11 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     /// @param rhs The right-hand side encrypted operand (must be same type as lhs).
     /// @return result The encrypted bitwise OR result.
     function eBitOr(bytes32 lhs, bytes32 rhs) external returns (bytes32 result) {
+        checkInput(lhs, SUPPORTED_TYPES_MASK);
+        checkInput(rhs, SUPPORTED_TYPES_MASK);
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
-        checkInput(lhs, typeToBitMask(lhsType));
-        checkInput(rhs, typeToBitMask(rhsType));
-        require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
+        require(lhsType == rhsType, UnexpectedType(rhsType, typeToBitMask(lhsType)));
         uint256 id = getNextEventId();
         result = createResultHandle(EOps.BitOr, lhsType, abi.encodePacked(lhs, rhs));
         emit EBitOr(lhs, rhs, result, id);
@@ -208,11 +212,11 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     /// @param rhs The right-hand side encrypted operand (must be same type as lhs).
     /// @return result The encrypted bitwise XOR result.
     function eBitXor(bytes32 lhs, bytes32 rhs) external returns (bytes32 result) {
+        checkInput(lhs, SUPPORTED_TYPES_MASK);
+        checkInput(rhs, SUPPORTED_TYPES_MASK);
         ETypes lhsType = typeOf(lhs);
         ETypes rhsType = typeOf(rhs);
-        checkInput(lhs, typeToBitMask(lhsType));
-        checkInput(rhs, typeToBitMask(rhsType));
-        require(lhsType == rhsType, UnexpectedType(lhsType, typeToBitMask(rhsType)));
+        require(lhsType == rhsType, UnexpectedType(rhsType, typeToBitMask(lhsType)));
         uint256 id = getNextEventId();
         result = createResultHandle(EOps.BitXor, lhsType, abi.encodePacked(lhs, rhs));
         emit EBitXor(lhs, rhs, result, id);
@@ -279,6 +283,9 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     function eEq(bytes32 lhs, bytes32 rhs) external returns (ebool result) {
         checkInput(lhs, SUPPORTED_TYPES_MASK);
         checkInput(rhs, SUPPORTED_TYPES_MASK);
+        ETypes lhsType = typeOf(lhs);
+        ETypes rhsType = typeOf(rhs);
+        require(lhsType == rhsType, UnexpectedType(rhsType, typeToBitMask(lhsType)));
 
         result = ebool.wrap(createResultHandle(EOps.Eq, ETypes.Bool, abi.encodePacked(lhs, rhs)));
         uint256 id = getNextEventId();
@@ -294,6 +301,9 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     function eNe(bytes32 lhs, bytes32 rhs) external returns (ebool result) {
         checkInput(lhs, SUPPORTED_TYPES_MASK);
         checkInput(rhs, SUPPORTED_TYPES_MASK);
+        ETypes lhsType = typeOf(lhs);
+        ETypes rhsType = typeOf(rhs);
+        require(lhsType == rhsType, UnexpectedType(rhsType, typeToBitMask(lhsType)));
 
         result = ebool.wrap(createResultHandle(EOps.Ne, ETypes.Bool, abi.encodePacked(lhs, rhs)));
         uint256 id = getNextEventId();
@@ -390,16 +400,17 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
         setDigest(abi.encodePacked(result, id));
     }
 
-    /// @notice Casts an encrypted value to a different encrypted type.
+    /// @notice Casts an encrypted value to a different encrypted type. Same-type casting is not allowed.
     /// @dev Supports casting to euint256 and eaddress. Casting to ebool is not supported, only from ebool to a larger type.
+    ///      Reverts with SameTypeCast if the source type matches the target type.
     /// @param ct The encrypted value to cast.
     /// @param toType The target type to cast to.
     /// @return result The casted encrypted value.
     function eCast(bytes32 ct, ETypes toType) external returns (bytes32 result) {
         checkInput(ct, SUPPORTED_TYPES_MASK);
         require(canCastTo(toType), UnsupportedType(toType));
+        require(typeOf(ct) != toType, SameTypeCast(toType));
         result = createResultHandle(EOps.Cast, toType, abi.encodePacked(ct));
-        allowTransientInternal(result, msg.sender);
         uint256 id = getNextEventId();
         emit ECast(ct, uint8(toType), result, id);
         setDigest(abi.encodePacked(result, id));
@@ -445,7 +456,6 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
         ETypes returnType = checkEIfThenElseInputs(control, ifTrue, ifFalse);
         result =
             createResultHandle(EOps.IfThenElse, returnType, abi.encodePacked(ebool.unwrap(control), ifTrue, ifFalse));
-        allowTransientInternal(result, msg.sender);
         uint256 id = getNextEventId();
         emit EIfThenElse(control, ifTrue, ifFalse, result, id);
         setDigest(abi.encodePacked(result, id));

package/src/lightning-parts/TEELifecycle.sol

@@ -155,7 +155,7 @@ abstract contract TEELifecycle is
         UpgradeResult calldata upgradeResult,
         bytes calldata quote,
         bytes calldata signature
-    ) public {
+    ) public onlyOwner {
         StorageForTeeLifecycle storage $ = getTeeLifecycleStorage();
 
         require(isBootstrapComplete(), BootstrapNotComplete());

package/src/lightning-parts/interfaces/IEList.sol

@@ -29,7 +29,7 @@ interface IEList is IEncryptedOperations, IEncryptedInput, IEListHandleMetadata
         payable
         returns (elist result);
 
-    function listRange(uint16 start, uint16 end) external payable returns (elist result);
+    function listRange(uint16 start, uint16 end, ETypes listType) external payable returns (elist result);
 
     function listShuffle(elist list) external payable returns (elist result);
 

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

@@ -17,6 +17,10 @@ import {IEListHandleMetadata} from "./interfaces/IEListHandleMetadata.sol";
 ///      This allows efficient extraction of list metadata without external calls.
 contract EListHandleMetadata is IEListHandleMetadata {
 
+    /// @notice Thrown when a handle contains an element type value outside the valid ETypes enum range.
+    /// @param raw The raw uint8 value extracted from the handle.
+    error InvalidListTypeValue(uint8 raw);
+
     /// @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.
@@ -51,10 +55,13 @@ contract EListHandleMetadata is IEListHandleMetadata {
     /// @notice Extracts the element type from a list handle
     /// @dev Reads byte 29 of the handle and casts to ETypes enum.
     ///      This is the type of individual elements, not the list container type.
+    ///      Reverts with InvalidListTypeValue if the raw byte exceeds the valid ETypes range.
     /// @param handle The encrypted list handle to inspect
-    /// @return The encrypted type of list elements (euint8, euint64, etc.)
+    /// @return The encrypted type of list elements (ebool, euint160, euint256, etc.)
     function listTypeOf(bytes32 handle) internal pure returns (ETypes) {
-        return ETypes(uint8(uint256(handle) >> 16));
+        uint8 raw = uint8(uint256(handle) >> 16);
+        require(raw <= uint8(type(ETypes).max), InvalidListTypeValue(raw));
+        return ETypes(raw);
     }
 
 }

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

@@ -12,6 +12,10 @@ import {HANDLE_VERSION, HANDLE_INDEX, ETypes} from "../../Types.sol";
 ///      - Byte 31: Handle version
 contract HandleMetadata {
 
+    /// @notice Thrown when a handle contains a type value outside the valid ETypes enum range.
+    /// @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
     /// @dev Used for input handles where the index distinguishes the source.
     ///      Clears bytes 29-31 of the prehandle, then sets:
@@ -46,11 +50,14 @@ contract HandleMetadata {
     }
 
     /// @notice Extracts the encrypted type from a handle
-    /// @dev Reads byte 30 of the handle and casts to ETypes enum
+    /// @dev Reads byte 30 of the handle and casts to ETypes enum.
+    ///      Reverts with InvalidTypeValue if the raw byte exceeds the valid ETypes range.
     /// @param handle The encrypted value handle to inspect
-    /// @return The encrypted type (ebool, euint8, euint16, etc.)
+    /// @return The encrypted type (ebool, euint160, euint256, etc.)
     function typeOf(bytes32 handle) internal pure returns (ETypes) {
-        return ETypes(uint8(uint256(handle) >> 8));
+        uint8 raw = uint8(uint256(handle) >> 8);
+        require(raw <= uint8(type(ETypes).max), InvalidTypeValue(raw));
+        return ETypes(raw);
     }
 
 }

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

@@ -30,8 +30,8 @@ contract TestEList is IncoTest {
         vm.deal(address(feeTester), 100 ether);
     }
 
-    function _listRange(uint16 start, uint16 end) internal returns (elist) {
-        return inco.listRange{value: uint256(end - start) * typeBitSize(ETypes.Uint256) * BIT_FEE}(start, end);
+    function _listRange(uint16 start, uint16 end, ETypes listType) internal returns (elist) {
+        return inco.listRange{value: uint256(end - start) * typeBitSize(listType) * BIT_FEE}(start, end, listType);
     }
 
     function _listAppend(elist list, bytes32 value) internal returns (elist) {
@@ -101,7 +101,7 @@ contract TestEList is IncoTest {
     }
 
     function testListAppend_SucceedsAtMaxLength() public {
-        elist almostMaxList = _listRange(0, MAX_LIST_LENGTH - 1);
+        elist almostMaxList = _listRange(0, MAX_LIST_LENGTH - 1, ETypes.Uint256);
 
         bytes32 validHandle = inco.listGet(almostMaxList, 0);
 
@@ -110,7 +110,7 @@ contract TestEList is IncoTest {
     }
 
     function testListInsert_SucceedsAtMaxLength() public {
-        elist almostMaxList = _listRange(0, MAX_LIST_LENGTH - 1);
+        elist almostMaxList = _listRange(0, MAX_LIST_LENGTH - 1, ETypes.Uint256);
 
         // Get valid handles from the list (listGet returns handles with transient permissions)
         bytes32 validIndex = inco.listGet(almostMaxList, 0);
@@ -123,8 +123,8 @@ contract TestEList is IncoTest {
     function testListConcat_SucceedsAtMaxLength() public {
         uint16 half = MAX_LIST_LENGTH / 2;
         uint16 otherHalf = MAX_LIST_LENGTH - half;
-        elist list1 = _listRange(0, half);
-        elist list2 = _listRange(0, otherHalf);
+        elist list1 = _listRange(0, half, ETypes.Uint256);
+        elist list2 = _listRange(0, otherHalf, ETypes.Uint256);
 
         // Should succeed
         elist combined = _listConcat(list1, list2);
@@ -132,7 +132,7 @@ contract TestEList is IncoTest {
     }
 
     function testListRange_SucceedsAtMaxLength() public {
-        elist maxList = _listRange(0, MAX_LIST_LENGTH);
+        elist maxList = _listRange(0, MAX_LIST_LENGTH, ETypes.Uint256);
         assert(elist.unwrap(maxList) != bytes32(0));
     }
 
@@ -141,7 +141,7 @@ contract TestEList is IncoTest {
     // Operations use uint16 arithmetic which auto-reverts on overflow in Solidity 0.8+.
 
     function testListAppend_RevertsOnOverflow() public {
-        elist maxList = _listRange(0, MAX_LIST_LENGTH);
+        elist maxList = _listRange(0, MAX_LIST_LENGTH, ETypes.Uint256);
 
         bytes32 validHandle = inco.listGet(maxList, 0);
 
@@ -153,7 +153,7 @@ contract TestEList is IncoTest {
     }
 
     function testListInsert_RevertsOnOverflow() public {
-        elist maxList = _listRange(0, MAX_LIST_LENGTH);
+        elist maxList = _listRange(0, MAX_LIST_LENGTH, ETypes.Uint256);
 
         bytes32 validIndex = inco.listGet(maxList, 0);
         bytes32 validValue = inco.listGet(maxList, 1);
@@ -168,8 +168,8 @@ contract TestEList is IncoTest {
 
     function testListConcat_RevertsOnOverflow() public {
         uint16 half = MAX_LIST_LENGTH / 2 + 1;
-        elist list1 = _listRange(0, half);
-        elist list2 = _listRange(0, half);
+        elist list1 = _listRange(0, half, ETypes.Uint256);
+        elist list2 = _listRange(0, half, ETypes.Uint256);
 
         // Concatenating should revert with arithmetic overflow
         uint256 bitsPerList = uint256(half) * typeBitSize(ETypes.Uint256);
@@ -202,7 +202,7 @@ contract TestEList is IncoTest {
     }
 
     function testNewEListFromHandles() public {
-        elist sourceList = _listRange(0, 3);
+        elist sourceList = _listRange(0, 3, ETypes.Uint256);
 
         // Extract handles from the source list
         bytes32[] memory handles = new bytes32[](3);

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

@@ -284,35 +284,35 @@ contract TestHandleMetadata is
     function testEBitAndTypeMismatch() public {
         euint256 a = this.asEuint256(42);
         ebool b = this.asEbool(true);
-        // Error: UnexpectedType(lhsType, typeToBitMask(rhsType))
-        // With lhs=Uint256, rhs=Bool: UnexpectedType(Uint256, typeToBitMask(Bool))
+        // Error: UnexpectedType(typeOf(rhs), typeToBitMask(lhsType))
+        // With lhs=Uint256, rhs=Bool: UnexpectedType(Bool, typeToBitMask(Uint256))
         vm.expectRevert(
             abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Uint256, typeToBitMask(ETypes.Bool)
+                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
             )
         );
         this.eBitAnd(euint256.unwrap(a), ebool.unwrap(b));
     }
 
-    /// @notice Test eBitOr with mismatched types (line 134)
+    /// @notice Test eBitOr with mismatched types
     function testEBitOrTypeMismatch() public {
         euint256 a = this.asEuint256(42);
         ebool b = this.asEbool(true);
         vm.expectRevert(
             abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Uint256, typeToBitMask(ETypes.Bool)
+                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
             )
         );
         this.eBitOr(euint256.unwrap(a), ebool.unwrap(b));
     }
 
-    /// @notice Test eBitXor with mismatched types (line 146)
+    /// @notice Test eBitXor with mismatched types
     function testEBitXorTypeMismatch() public {
         euint256 a = this.asEuint256(42);
         ebool b = this.asEbool(true);
         vm.expectRevert(
             abi.encodeWithSelector(
-                EncryptedOperations.UnexpectedType.selector, ETypes.Uint256, typeToBitMask(ETypes.Bool)
+                EncryptedOperations.UnexpectedType.selector, ETypes.Bool, typeToBitMask(ETypes.Uint256)
             )
         );
         this.eBitXor(euint256.unwrap(a), ebool.unwrap(b));

package/src/test/EListTester.sol

@@ -130,8 +130,9 @@ contract ElistTester is IncoUtils {
         return list;
     }
 
-    function listRange(uint16 start, uint16 end) public payable returns (elist) {
-        newRangeList = inco.listRange{value: uint256(end - start) * typeBitSize(ETypes.Uint256) * BIT_FEE}(start, end);
+    function listRange(uint16 start, uint16 end, ETypes listType) public payable returns (elist) {
+        newRangeList =
+            inco.listRange{value: uint256(end - start) * typeBitSize(listType) * BIT_FEE}(start, end, listType);
         inco.allow(elist.unwrap(newRangeList), address(this));
         inco.allow(elist.unwrap(newRangeList), address(msg.sender));
         return newRangeList;

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

@@ -256,6 +256,7 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
 
     function testVerifyUpgradeResult_BootstrapNotComplete() public {
         UpgradeResult memory upgradeResult = UpgradeResult({networkPubkey: testNetworkPubkey});
+        vm.prank(this.owner());
         vm.expectRevert(TEELifecycle.BootstrapNotComplete.selector);
         this.verifyUpgradeResult(testMrAggregated, upgradeResult, hex"", hex"");
     }
@@ -271,6 +272,7 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
 
         // Try upgrade with wrong network pubkey
         UpgradeResult memory upgradeResult = UpgradeResult({networkPubkey: hex"deadbeef"});
+        vm.prank(this.owner());
         vm.expectRevert(TEELifecycle.InvalidNetworkPubkey.selector);
         this.verifyUpgradeResult(mrAggregated, upgradeResult, quote, signature);
     }
@@ -287,6 +289,7 @@ contract TEELifecycleMockTest is MockRemoteAttestation, TEELifecycle {
         // Try upgrade with unapproved MR_AGGREGATED
         bytes32 unapprovedMr = bytes32(uint256(1234));
         UpgradeResult memory upgradeResult = UpgradeResult({networkPubkey: testNetworkPubkey});
+        vm.prank(this.owner());
         vm.expectRevert(TEELifecycle.TEEVersionNotFound.selector);
         this.verifyUpgradeResult(unapprovedMr, upgradeResult, quote, signature);
     }