@inco/lightning 0.8.0-devnet-13 → 0.8.0-devnet-22

package/src/test/TestLib.t.sol

@@ -3,7 +3,18 @@ pragma solidity ^0.8;
 
 import {IncoTest} from "./IncoTest.sol";
 import {e, euint256, ebool, eaddress, inco} from "../Lib.sol";
-import {ETypes} from "../Types.sol";
+import {FEE} from "../lightning-parts/Fee.sol";
+import {
+    ETypes,
+    elist,
+    IndexOutOfRange,
+    InvalidRange,
+    SliceOutOfRange,
+    UnsupportedListType,
+    UnsupportedType
+} from "../Types.sol";
+import {DecryptionAttestation, ElementAttestationWithProof} from "../lightning-parts/DecryptionAttester.types.sol";
+import {AllowanceProof, AllowanceVoucher} from "../lightning-parts/AccessControl/AdvancedAccessControl.sol";
 
 /// @notice Tests for Lib.sol library functions to achieve 100% coverage
 /// @dev This file tests all the scalar variants and uncovered branches in the library
@@ -16,6 +27,34 @@ contract TestLib is IncoTest {
     using e for address;
     using e for eaddress;
     using e for bytes;
+    using e for elist;
+
+    function setUp() public virtual override {
+        super.setUp();
+        vm.deal(address(this), 100 ether);
+    }
+
+    // ============ ELIST FEE HELPERS ============
+
+    function _listRange(uint16 start, uint16 end) internal returns (elist) {
+        return inco.listRange{value: inco.getEListFee(end - start, ETypes.Uint256)}(start, end);
+    }
+
+    function _newEList(bytes32[] memory handles, ETypes listType) internal returns (elist) {
+        return inco.newEList{value: inco.getEListFee(uint16(handles.length), listType)}(handles, listType);
+    }
+
+    function _listAppend(elist list, bytes32 value) internal returns (elist) {
+        return inco.listAppend{value: inco.getEListFee(e.length(list) + 1, e.listTypeOf(list))}(list, value);
+    }
+
+    function _listConcat(elist a, elist b) internal returns (elist) {
+        return inco.listConcat{value: inco.getEListFee(e.length(a) + e.length(b), e.listTypeOf(a))}(a, b);
+    }
+
+    function _listReverse(elist list) internal returns (elist) {
+        return inco.listReverse{value: inco.getEListFee(e.length(list), e.listTypeOf(list))}(list);
+    }
 
     // ============ SANITIZE BRANCH TESTS ============
 
@@ -632,18 +671,10 @@ contract TestLib is IncoTest {
 
     // ============ CAST OPERATIONS ============
 
-    function testCastEuint256ToEboolTrue() public {
+    function testCastEuint256ToEboolRevert() public {
         euint256 a = e.asEuint256(1);
-        ebool b = e.asEbool(a);
-        processAllOperations();
-        assertEq(getBoolValue(b), true);
-    }
-
-    function testCastEuint256ToEboolFalse() public {
-        euint256 a = e.asEuint256(0);
-        ebool b = e.asEbool(a);
-        processAllOperations();
-        assertEq(getBoolValue(b), false);
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, ETypes.Bool));
+        inco.eCast(euint256.unwrap(a), ETypes.Bool);
     }
 
     function testCastEboolToEuint256True() public {
@@ -707,20 +738,37 @@ contract TestLib is IncoTest {
         assertEq(getUint256Value(b), 0);
     }
 
-    function testCastEaddressToEboolNonZero() public {
+    function testCastEaddressToEboolNonZeroRevert() public {
         eaddress a = e.asEaddress(alice);
         processAllOperations();
-        ebool b = ebool.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Bool));
-        processAllOperations();
-        assertEq(getBoolValue(b), true);
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, ETypes.Bool));
+        ebool.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Bool));
     }
 
-    function testCastEaddressToEboolZero() public {
+    function testCastEaddressToEboolZeroRevert() public {
         eaddress a = e.asEaddress(address(0));
         processAllOperations();
-        ebool b = ebool.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Bool));
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, ETypes.Bool));
+        ebool.wrap(inco.eCast(eaddress.unwrap(a), ETypes.Bool));
+    }
+
+    function testCastEboolToEboolZeroRevert() public {
+        ebool a = e.asEbool(true);
         processAllOperations();
-        assertEq(getBoolValue(b), false);
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedType.selector, ETypes.Bool));
+        ebool.wrap(inco.eCast(ebool.unwrap(a), ETypes.Bool));
+    }
+
+    function testCastEuint256ToEuint256() public {
+        euint256 a = e.asEuint256(10);
+        processAllOperations();
+        euint256.wrap(inco.eCast(euint256.unwrap(a), ETypes.Uint256));
+    }
+
+    function testCastEaddressToEaddress() public {
+        eaddress a = e.asEaddress(alice);
+        processAllOperations();
+        eaddress.wrap(inco.eCast(eaddress.unwrap(a), ETypes.AddressOrUint160OrBytes20));
     }
 
     // ============ NOT OPERATION ============
@@ -768,6 +816,602 @@ contract TestLib is IncoTest {
         assertTrue(value < 50);
     }
 
+    // ============ VERIFY DECRYPTION TESTS ============
+
+    function testVerifyDecryption_Euint256_ValidAttestation() public {
+        // Create an encrypted value
+        euint256 encrypted = e.asEuint256(12345);
+        processAllOperations();
+
+        // Get a valid decryption attestation
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: euint256.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        // Verify the decryption
+        bool isValid = e.verifyDecryption(encrypted, uint256(attestation.value), signatures);
+        assertTrue(isValid, "Valid attestation should return true");
+    }
+
+    function testVerifyDecryption_Euint256_InvalidValue() public {
+        // Create an encrypted value
+        euint256 encrypted = e.asEuint256(12345);
+        processAllOperations();
+
+        // Get a valid decryption attestation
+        (, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: euint256.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        // Try to verify with wrong value
+        bool isValid = e.verifyDecryption(encrypted, 99999, signatures);
+        assertFalse(isValid, "Invalid value should return false");
+    }
+
+    function testVerifyDecryption_Euint256_InvalidSignatures() public {
+        // Create an encrypted value
+        euint256 encrypted = e.asEuint256(12345);
+        processAllOperations();
+
+        // Create empty/invalid signatures
+        bytes[] memory invalidSignatures = new bytes[](0);
+
+        // Verify with invalid signatures should return false
+        bool isValid = e.verifyDecryption(encrypted, 12345, invalidSignatures);
+        assertFalse(isValid, "Invalid signatures should return false");
+    }
+
+    function testVerifyDecryption_Ebool_ValidAttestation_True() public {
+        // Create an encrypted bool (true)
+        ebool encrypted = e.asEbool(true);
+        processAllOperations();
+
+        // Get a valid decryption attestation
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        // Verify the decryption
+        bool decryptedValue = uint256(attestation.value) != 0;
+        bool isValid = e.verifyDecryption(encrypted, decryptedValue, signatures);
+        assertTrue(isValid, "Valid attestation for true should return true");
+    }
+
+    function testVerifyDecryption_Ebool_ValidAttestation_False() public {
+        // Create an encrypted bool (false)
+        ebool encrypted = e.asEbool(false);
+        processAllOperations();
+
+        // Get a valid decryption attestation
+        (DecryptionAttestation memory attestation, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        // Verify the decryption
+        bool decryptedValue = uint256(attestation.value) != 0;
+        bool isValid = e.verifyDecryption(encrypted, decryptedValue, signatures);
+        assertTrue(isValid, "Valid attestation for false should return true");
+    }
+
+    function testVerifyDecryption_Ebool_InvalidValue() public {
+        // Create an encrypted bool (true)
+        ebool encrypted = e.asEbool(true);
+        processAllOperations();
+
+        // Get a valid decryption attestation for true
+        (, bytes[] memory signatures) = getDecryptionAttestation(
+            address(this), HandleWithProof({handle: ebool.unwrap(encrypted), proof: _emptyAllowanceProof()})
+        );
+
+        // Try to verify with wrong value (false instead of true)
+        bool isValid = e.verifyDecryption(encrypted, false, signatures);
+        assertFalse(isValid, "Invalid bool value should return false");
+    }
+
+    /// @dev Creates an empty AllowanceProof (no proof required when sharer is address(0))
+    function _emptyAllowanceProof() internal pure returns (AllowanceProof memory) {
+        return AllowanceProof({
+            sharer: address(0),
+            voucher: AllowanceVoucher({
+                sessionNonce: bytes32(0), verifyingContract: address(0), callFunction: bytes4(0), sharerArgData: ""
+            }),
+            voucherSignature: "",
+            requesterArgData: ""
+        });
+    }
+
+    // ============ ELIST PURE FUNCTION TESTS ============
+    // Note: Most EList functions in Lib.sol are thin wrappers around inco.* calls.
+
+    function testEList_ListTypeOf_Uint256() public {
+        elist list = _listRange(0, 5);
+
+        // Test listTypeOf - this is a pure function that extracts type from handle
+        ETypes listType = e.listTypeOf(list);
+        assertEq(uint8(listType), uint8(ETypes.Uint256), "Range creates Uint256 list");
+    }
+
+    function testEList_Length_Empty() public {
+        elist list = inco.newEList(new bytes32[](0), ETypes.Uint256); // empty list, fee = 0
+
+        // Test length function
+        uint16 len = e.length(list);
+        assertEq(len, 0, "Empty list should have length 0");
+    }
+
+    function testEList_Length_NonEmpty() public {
+        elist list = _listRange(0, 5);
+
+        // Test length function
+        uint16 len = e.length(list);
+        assertEq(len, 5, "Range(0,5) should have length 5");
+    }
+
+    function testEList_Length_AfterAppend() public {
+        elist list = _listRange(0, 3);
+
+        // Get a handle to append
+        bytes32 valueHandle = inco.listGet(list, 0);
+
+        elist newList = _listAppend(list, valueHandle);
+
+        assertEq(e.length(newList), 4, "After append, length should be 4");
+    }
+
+    function testEList_Length_AfterConcat() public {
+        elist list1 = _listRange(0, 3);
+        elist list2 = _listRange(10, 15);
+
+        elist combined = _listConcat(list1, list2);
+
+        assertEq(e.length(combined), 8, "Combined list should have length 8");
+    }
+
+    function testEList_Length_AfterReverse() public {
+        // Create a list
+        elist list = _listRange(0, 7);
+
+        // Reverse using inco directly
+        elist reversed = _listReverse(list);
+
+        // Verify length unchanged
+        assertEq(e.length(reversed), 7, "Reversed list should have same length");
+    }
+
+    LibEListHelper elistHelper;
+
+    function _setupEListHelper() internal {
+        if (address(elistHelper) == address(0)) {
+            elistHelper = new LibEListHelper();
+            vm.deal(address(elistHelper), 10 ether);
+        }
+    }
+
+    function _allowHelperForList(elist list) internal {
+        inco.allow(elist.unwrap(list), address(elistHelper));
+        // Also allow individual elements
+        uint16 len = e.length(list);
+        for (uint16 i = 0; i < len; i++) {
+            bytes32 handle = inco.listGet(list, i);
+            inco.allow(handle, address(elistHelper));
+        }
+    }
+
+    function testEListWrapper_NewEListEmpty() public {
+        _setupEListHelper();
+        elist list = elistHelper.callNewEListEmpty(ETypes.Uint256);
+        assertEq(e.length(list), 0);
+    }
+
+    function testEListWrapper_NewEListFromHandles() public {
+        _setupEListHelper();
+
+        elist rangeList = _listRange(0, 3);
+        bytes32[] memory handles = new bytes32[](3);
+        handles[0] = inco.listGet(rangeList, 0);
+        handles[1] = inco.listGet(rangeList, 1);
+        handles[2] = inco.listGet(rangeList, 2);
+        // Grant permissions
+        inco.allow(handles[0], address(elistHelper));
+        inco.allow(handles[1], address(elistHelper));
+        inco.allow(handles[2], address(elistHelper));
+
+        elist list = elistHelper.callNewEListFromHandles(handles, ETypes.Uint256);
+        assertEq(e.length(list), 3);
+    }
+
+    function testEListWrapper_NewEListFromCiphertexts() public {
+        _setupEListHelper();
+
+        // Create ciphertexts for the list
+        bytes[] memory ciphertexts = new bytes[](3);
+        ciphertexts[0] = fakePrepareEuint256Ciphertext(10, address(elistHelper), address(elistHelper));
+        ciphertexts[1] = fakePrepareEuint256Ciphertext(20, address(elistHelper), address(elistHelper));
+        ciphertexts[2] = fakePrepareEuint256Ciphertext(30, address(elistHelper), address(elistHelper));
+
+        // Calculate fee: uses elist bit fee
+        uint256 fee = inco.getEListFee(uint16(ciphertexts.length), ETypes.Uint256);
+
+        // Create the list from ciphertexts
+        elist list =
+            elistHelper.callNewEListFromCiphertexts{value: fee}(ciphertexts, ETypes.Uint256, address(elistHelper));
+
+        // Verify the list was created with correct length
+        assertEq(e.length(list), 3);
+    }
+
+    function testEListWrapper_AppendEuint256() public {
+        _setupEListHelper();
+        // Create a list and get a handle
+        elist list = _listRange(0, 3);
+        bytes32 valueHandle = inco.listGet(list, 0);
+        euint256 value = euint256.wrap(valueHandle);
+        // Grant permissions
+        _allowHelperForList(list);
+
+        elist newList = elistHelper.callAppendEuint256(list, value);
+        assertEq(e.length(newList), 4);
+    }
+
+    function testEListWrapper_AppendEbool() public {
+        _setupEListHelper();
+        // Create a list and get a handle
+        elist list = _listRange(0, 3);
+        bytes32 valueHandle = inco.listGet(list, 0);
+        ebool value = ebool.wrap(valueHandle);
+        // Grant permissions
+        _allowHelperForList(list);
+
+        elist newList = elistHelper.callAppendEbool(list, value);
+        assertEq(e.length(newList), 4);
+    }
+
+    function testEListWrapper_SetHiddenIndexEuint256() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        euint256 idx = euint256.wrap(inco.listGet(list, 0)); // Use element as index
+        euint256 value = euint256.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callSetHiddenIndexEuint256(list, idx, value);
+        assertEq(e.length(newList), 3);
+    }
+
+    function testEListWrapper_SetHiddenIndexEbool() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        euint256 idx = euint256.wrap(inco.listGet(list, 0));
+        ebool value = ebool.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callSetHiddenIndexEbool(list, idx, value);
+        assertEq(e.length(newList), 3);
+    }
+
+    function testEListWrapper_SetPlaintextIndexEuint256() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        euint256 value = euint256.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callSetPlaintextIndexEuint256(list, 0, value);
+        assertEq(e.length(newList), 3);
+    }
+
+    function testEListWrapper_SetPlaintextIndexEbool() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        ebool value = ebool.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callSetPlaintextIndexEbool(list, 0, value);
+        assertEq(e.length(newList), 3);
+    }
+
+    function testEListWrapper_GetOrEuint256() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5);
+        _allowHelperForList(list);
+        euint256 idx = euint256.wrap(inco.listGet(list, 1));
+        euint256 defaultValue = euint256.wrap(inco.listGet(list, 0));
+
+        euint256 result = elistHelper.callGetOrEuint256(list, idx, defaultValue);
+        assertTrue(euint256.unwrap(result) != bytes32(0));
+    }
+
+    function testEListWrapper_GetOrEbool() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5);
+        _allowHelperForList(list);
+        euint256 idx = euint256.wrap(inco.listGet(list, 1));
+        ebool defaultValue = ebool.wrap(inco.listGet(list, 0));
+
+        ebool result = elistHelper.callGetOrEbool(list, idx, defaultValue);
+        assertTrue(ebool.unwrap(result) != bytes32(0));
+    }
+
+    function testEListWrapper_GetEuint256() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5);
+        _allowHelperForList(list);
+
+        euint256 result = elistHelper.callGetEuint256(list, 2);
+        assertTrue(euint256.unwrap(result) != bytes32(0));
+    }
+
+    function testEListWrapper_GetEbool() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5);
+        _allowHelperForList(list);
+
+        ebool result = elistHelper.callGetEbool(list, 2);
+        assertTrue(ebool.unwrap(result) != bytes32(0));
+    }
+
+    function testEListWrapper_InsertHiddenIndexEuint256() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        euint256 idx = euint256.wrap(inco.listGet(list, 0));
+        euint256 value = euint256.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callInsertHiddenIndexEuint256(list, idx, value);
+        assertEq(e.length(newList), 4);
+    }
+
+    function testEListWrapper_InsertHiddenIndexEbool() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        euint256 idx = euint256.wrap(inco.listGet(list, 0));
+        ebool value = ebool.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callInsertHiddenIndexEbool(list, idx, value);
+        assertEq(e.length(newList), 4);
+    }
+
+    function testEListWrapper_InsertPlaintextIndexEuint256() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        euint256 value = euint256.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callInsertPlaintextIndexEuint256(list, 1, value);
+        assertEq(e.length(newList), 4);
+    }
+
+    function testEListWrapper_InsertPlaintextIndexEbool() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        ebool value = ebool.wrap(inco.listGet(list, 1));
+
+        elist newList = elistHelper.callInsertPlaintextIndexEbool(list, 1, value);
+        assertEq(e.length(newList), 4);
+    }
+
+    function testEListWrapper_Concat() public {
+        _setupEListHelper();
+        elist list1 = _listRange(0, 3);
+        elist list2 = _listRange(10, 13);
+        _allowHelperForList(list1);
+        _allowHelperForList(list2);
+
+        elist combined = elistHelper.callConcat(list1, list2);
+        assertEq(e.length(combined), 6);
+    }
+
+    function testEListWrapper_Slice() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 10);
+        _allowHelperForList(list);
+
+        elist sliced = elistHelper.callSlice(list, 2, 7);
+        assertEq(e.length(sliced), 5);
+    }
+
+    function testEListWrapper_SliceLenEuint256() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 10);
+        _allowHelperForList(list);
+        euint256 start = euint256.wrap(inco.listGet(list, 1));
+        euint256 defaultValue = euint256.wrap(inco.listGet(list, 0));
+
+        elist sliced = elistHelper.callSliceLenEuint256(list, start, 3, defaultValue);
+        assertEq(e.length(sliced), 3);
+    }
+
+    function testEListWrapper_SliceLenEbool() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 10);
+        _allowHelperForList(list);
+        euint256 start = euint256.wrap(inco.listGet(list, 1));
+        ebool defaultValue = ebool.wrap(inco.listGet(list, 0));
+
+        elist sliced = elistHelper.callSliceLenEbool(list, start, 3, defaultValue);
+        assertEq(e.length(sliced), 3);
+    }
+
+    function testEListWrapper_Range() public {
+        _setupEListHelper();
+        elist list = elistHelper.callRange(5, 15);
+        assertEq(e.length(list), 10);
+    }
+
+    function testEListWrapper_Reverse() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5);
+        _allowHelperForList(list);
+
+        elist reversed = elistHelper.callReverse(list);
+        assertEq(e.length(reversed), 5);
+    }
+
+    function testEListWrapper_Shuffle() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5);
+        _allowHelperForList(list);
+
+        elist shuffled = elistHelper.callShuffle(list);
+        assertEq(e.length(shuffled), 5);
+    }
+
+    function testEListWrapper_ShuffledRange() public {
+        _setupEListHelper();
+        elist list = elistHelper.callShuffledRange(0, 10);
+        assertEq(e.length(list), 10);
+    }
+
+    function testEListWrapper_Length() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 7);
+        assertEq(elistHelper.callLength(list), 7);
+    }
+
+    function testEListWrapper_ListTypeOf() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5);
+        assertEq(uint8(elistHelper.callListTypeOf(list)), uint8(ETypes.Uint256));
+    }
+
+    // ============ ELIST REQUIRE/REVERT TESTS ============
+
+    function testEListWrapper_SetPlaintextIndexEuint256_RevertsOnOutOfRange() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3); // length 3, valid indices 0-2
+        _allowHelperForList(list);
+        euint256 value = euint256.wrap(inco.listGet(list, 0));
+
+        // Index 3 is out of range for a list of length 3
+        vm.expectRevert(abi.encodeWithSelector(IndexOutOfRange.selector, 3, 3));
+        elistHelper.callSetPlaintextIndexEuint256(list, 3, value);
+    }
+
+    function testEListWrapper_SetPlaintextIndexEbool_RevertsOnOutOfRange() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        ebool value = ebool.wrap(inco.listGet(list, 0));
+
+        vm.expectRevert(abi.encodeWithSelector(IndexOutOfRange.selector, 5, 3));
+        elistHelper.callSetPlaintextIndexEbool(list, 5, value);
+    }
+
+    function testEListWrapper_InsertPlaintextIndexEbool_RevertsOnOutOfRange() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        ebool value = ebool.wrap(inco.listGet(list, 0));
+
+        vm.expectRevert(abi.encodeWithSelector(IndexOutOfRange.selector, 10, 3));
+        elistHelper.callInsertPlaintextIndexEbool(list, 10, value);
+    }
+
+    function testEListWrapper_InsertPlaintextIndexEuint256_RevertsOnOutOfRange() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 3);
+        _allowHelperForList(list);
+        euint256 value = euint256.wrap(inco.listGet(list, 0));
+
+        vm.expectRevert(abi.encodeWithSelector(IndexOutOfRange.selector, 3, 3));
+        elistHelper.callInsertPlaintextIndexEuint256(list, 3, value);
+    }
+
+    function testEListWrapper_Slice_RevertsOnInvalidRange() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 10);
+        _allowHelperForList(list);
+
+        // end < start is invalid
+        vm.expectRevert(abi.encodeWithSelector(InvalidRange.selector, 5, 3));
+        elistHelper.callSlice(list, 5, 3);
+    }
+
+    function testEListWrapper_Slice_RevertsOnEndOutOfRange() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5); // length 5
+        _allowHelperForList(list);
+
+        // end > length is out of range
+        vm.expectRevert(abi.encodeWithSelector(SliceOutOfRange.selector, 2, 10, 5));
+        elistHelper.callSlice(list, 2, 10);
+    }
+
+    function testEListWrapper_Slice_RevertsOnStartOutOfRange() public {
+        _setupEListHelper();
+        elist list = _listRange(0, 5); // length 5
+        _allowHelperForList(list);
+
+        // start >= length is out of range
+        vm.expectRevert(abi.encodeWithSelector(SliceOutOfRange.selector, 5, 5, 5));
+        elistHelper.callSlice(list, 5, 5);
+    }
+
+    function testEListWrapper_Slice_WorksWithEboolList() public {
+        _setupEListHelper();
+
+        ebool val1 = e.asEbool(true);
+        ebool val2 = e.asEbool(false);
+        ebool val3 = e.asEbool(true);
+        processAllOperations();
+
+        bytes32[] memory handles = new bytes32[](3);
+        handles[0] = ebool.unwrap(val1);
+        handles[1] = ebool.unwrap(val2);
+        handles[2] = ebool.unwrap(val3);
+        inco.allow(handles[0], address(elistHelper));
+        inco.allow(handles[1], address(elistHelper));
+        inco.allow(handles[2], address(elistHelper));
+
+        elist boolList = _newEList(handles, ETypes.Bool);
+        _allowHelperForList(boolList);
+
+        // Slice should work and use ebool default value branch
+        elist sliced = elistHelper.callSlice(boolList, 0, 2);
+        assertEq(e.length(sliced), 2);
+    }
+
+    function testEListWrapper_Slice_RevertsOnUnsupportedListType() public {
+        _setupEListHelper();
+
+        eaddress addr1 = e.asEaddress(address(0x1));
+        eaddress addr2 = e.asEaddress(address(0x2));
+        eaddress addr3 = e.asEaddress(address(0x3));
+        processAllOperations();
+
+        bytes32[] memory handles = new bytes32[](3);
+        handles[0] = eaddress.unwrap(addr1);
+        handles[1] = eaddress.unwrap(addr2);
+        handles[2] = eaddress.unwrap(addr3);
+        inco.allow(handles[0], address(elistHelper));
+        inco.allow(handles[1], address(elistHelper));
+        inco.allow(handles[2], address(elistHelper));
+
+        elist unsupportedList = _newEList(handles, ETypes.AddressOrUint160OrBytes20);
+        _allowHelperForList(unsupportedList);
+
+        // Slice should revert with UnsupportedListType
+        vm.expectRevert(abi.encodeWithSelector(UnsupportedListType.selector, ETypes.AddressOrUint160OrBytes20));
+        elistHelper.callSlice(unsupportedList, 0, 2);
+    }
+
+    // ============ VERIFY ELIST DECRYPTION TEST ============
+
+    function testEListWrapper_VerifyEListDecryption() public {
+        _setupEListHelper();
+
+        elist list = _listRange(0, 3);
+
+        // Create empty proof elements (for basic verification test)
+        ElementAttestationWithProof[] memory proofElements = new ElementAttestationWithProof[](0);
+        bytes32 proof = bytes32(0);
+        bytes[] memory signatures = new bytes[](0);
+
+        // This should return false with empty/invalid data
+        bool result = elistHelper.callVerifyEListDecryption(list, proofElements, proof, signatures);
+        assertFalse(result, "Empty proof should fail verification");
+    }
+
 }
 
 /// @notice Helper contract for testing msg.sender variants
@@ -792,3 +1436,180 @@ contract LibTestHelper {
     }
 
 }
+
+/// @notice Helper contract for testing e.* EList wrapper functions
+/// @dev Uses inco.* to create handles, then calls e.* wrappers with non-zero handles
+contract LibEListHelper {
+
+    using e for euint256;
+    using e for ebool;
+    using e for elist;
+
+    elist public storedList;
+    euint256 public storedEuint256;
+    ebool public storedEbool;
+
+    // ============ newEList wrappers ============
+
+    function callNewEListEmpty(ETypes listType) external returns (elist) {
+        storedList = e.newEList(listType);
+        return storedList;
+    }
+
+    function callNewEListFromHandles(bytes32[] memory handles, ETypes listType) external returns (elist) {
+        storedList = e.newEList(handles, listType);
+        return storedList;
+    }
+
+    function callNewEListFromCiphertexts(bytes[] memory ciphertexts, ETypes listType, address user)
+        external
+        payable
+        returns (elist)
+    {
+        storedList = e.newEList(ciphertexts, listType, user);
+        return storedList;
+    }
+
+    // ============ append wrappers ============
+
+    function callAppendEuint256(elist list, euint256 value) external returns (elist) {
+        storedList = e.append(list, value);
+        return storedList;
+    }
+
+    function callAppendEbool(elist list, ebool value) external returns (elist) {
+        storedList = e.append(list, value);
+        return storedList;
+    }
+
+    // ============ set wrappers ============
+
+    function callSetHiddenIndexEuint256(elist list, euint256 idx, euint256 value) external returns (elist) {
+        storedList = e.set(list, idx, value);
+        return storedList;
+    }
+
+    function callSetHiddenIndexEbool(elist list, euint256 idx, ebool value) external returns (elist) {
+        storedList = e.set(list, idx, value);
+        return storedList;
+    }
+
+    function callSetPlaintextIndexEuint256(elist list, uint16 idx, euint256 value) external returns (elist) {
+        storedList = e.set(list, idx, value);
+        return storedList;
+    }
+
+    function callSetPlaintextIndexEbool(elist list, uint16 idx, ebool value) external returns (elist) {
+        storedList = e.set(list, idx, value);
+        return storedList;
+    }
+
+    // ============ getOr wrappers ============
+
+    function callGetOrEuint256(elist list, euint256 idx, euint256 defaultValue) external returns (euint256) {
+        storedEuint256 = e.getOr(list, idx, defaultValue);
+        return storedEuint256;
+    }
+
+    function callGetOrEbool(elist list, euint256 idx, ebool defaultValue) external returns (ebool) {
+        storedEbool = e.getOr(list, idx, defaultValue);
+        return storedEbool;
+    }
+
+    // ============ get wrappers ============
+
+    function callGetEuint256(elist list, uint16 idx) external returns (euint256) {
+        storedEuint256 = e.getEuint256(list, idx);
+        return storedEuint256;
+    }
+
+    function callGetEbool(elist list, uint16 idx) external returns (ebool) {
+        storedEbool = e.getEbool(list, idx);
+        return storedEbool;
+    }
+
+    // ============ insert wrappers ============
+
+    function callInsertHiddenIndexEuint256(elist list, euint256 idx, euint256 value) external returns (elist) {
+        storedList = e.insert(list, idx, value);
+        return storedList;
+    }
+
+    function callInsertHiddenIndexEbool(elist list, euint256 idx, ebool value) external returns (elist) {
+        storedList = e.insert(list, idx, value);
+        return storedList;
+    }
+
+    function callInsertPlaintextIndexEuint256(elist list, uint16 idx, euint256 value) external returns (elist) {
+        storedList = e.insert(list, idx, value);
+        return storedList;
+    }
+
+    function callInsertPlaintextIndexEbool(elist list, uint16 idx, ebool value) external returns (elist) {
+        storedList = e.insert(list, idx, value);
+        return storedList;
+    }
+
+    // ============ other list operations ============
+
+    function callConcat(elist list1, elist list2) external returns (elist) {
+        storedList = e.concat(list1, list2);
+        return storedList;
+    }
+
+    function callSlice(elist list, uint16 start, uint16 end) external returns (elist) {
+        storedList = e.slice(list, start, end);
+        return storedList;
+    }
+
+    function callSliceLenEuint256(elist list, euint256 start, uint16 len, euint256 defaultValue)
+        external
+        returns (elist)
+    {
+        storedList = e.sliceLen(list, start, len, defaultValue);
+        return storedList;
+    }
+
+    function callSliceLenEbool(elist list, euint256 start, uint16 len, ebool defaultValue) external returns (elist) {
+        storedList = e.sliceLen(list, start, len, defaultValue);
+        return storedList;
+    }
+
+    function callRange(uint16 start, uint16 end) external returns (elist) {
+        storedList = e.range(start, end);
+        return storedList;
+    }
+
+    function callShuffle(elist list) external returns (elist) {
+        storedList = e.shuffle(list);
+        return storedList;
+    }
+
+    function callShuffledRange(uint16 start, uint16 end) external returns (elist) {
+        storedList = e.shuffledRange(start, end);
+        return storedList;
+    }
+
+    function callReverse(elist list) external returns (elist) {
+        storedList = e.reverse(list);
+        return storedList;
+    }
+
+    function callLength(elist list) external pure returns (uint16) {
+        return e.length(list);
+    }
+
+    function callListTypeOf(elist list) external pure returns (ETypes) {
+        return e.listTypeOf(list);
+    }
+
+    function callVerifyEListDecryption(
+        elist elistHandle,
+        ElementAttestationWithProof[] memory proofElements,
+        bytes32 proof,
+        bytes[] memory signatures
+    ) external view returns (bool) {
+        return e.verifyEListDecryption(elistHandle, proofElements, proof, signatures);
+    }
+
+}