@inco/lightning 0.8.0-devnet-9 → 0.8.0-devnet-10

package/src/libs/incoLightning_testnet_v0_183408998.sol

@@ -6,8 +6,8 @@
 pragma solidity ^0.8;
 
 import { IncoLightning } from "../IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes } from "../Types.sol";
-import { DecryptionAttestation } from "../lightning-parts/DecryptionAttester.types.sol";
+import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType } from "../Types.sol";
+import { DecryptionAttestation, ElementDecryptionProof } from "../lightning-parts/DecryptionAttester.types.sol";
 
 IncoLightning constant inco = IncoLightning(0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
@@ -939,4 +939,263 @@ library e {
         }
         return abi.decode(result, (bytes32));
     }
+
+    /// @notice Returns the type of the elements contained within the list.
+    ///  @param handle EList handle to read container type from.
+    ///  @return ret Type of each element in the list.
+    function listTypeOf(elist handle) internal pure returns (ETypes ret) {
+        return ETypes(uint8(uint256(elist.unwrap(handle)) >> 16));
+    }
+
+    /// @notice Creates a new empty list. Type must be specified ahead of time and can not be changed.
+    ///  @param listType Type of each element in the list.
+    ///  @return ret A new elist handle
+    function newEList(ETypes listType) internal returns (elist ret) {
+        return inco.newEList(new bytes32[](0), listType);
+    }
+
+    /// @notice Creates a new list from existing array of handles.
+    ///  @param handles An array of handles to create a new list from
+    ///  @param listType Type of each element in the list.
+    ///  @return ret A new elist handle
+    function newEList(bytes32[] memory handles, ETypes listType) internal returns (elist ret) {
+        return inco.newEList(handles, listType);
+    }
+
+    /// @notice Takes an array of user encrypted ciphertexts and returns a new elist handle.
+    ///  @param ciphertexts An array of encrypted user inputs
+    ///  @param listType Expected type of each element in the list.
+    ///  @param user Address of the user encrypting the ciphertexts.
+    ///  @return ret A new elist handle
+    ///  @dev each ciphertext costs the inco fee
+    function newEList(bytes[] memory ciphertexts, ETypes listType, address user) internal returns (elist ret) {
+        return inco.newEList{value: inco.getFee() * ciphertexts.length}(ciphertexts, listType, user);
+    }
+
+    /// @notice Appends an ebool element at the end of a list.
+    ///  @param a An elist handle to append to.
+    ///  @param b Element value to be appended.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function append(elist a, ebool b) internal returns (elist ret) {
+        return inco.listAppend(a, ebool.unwrap(s(b)));
+    }
+
+    /// @notice Appends an euint256 element at the end of a list.
+    ///  @param a An elist handle to append to.
+    ///  @param b Element value to be appended.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function append(elist a, euint256 b) internal returns (elist ret) {
+        return inco.listAppend(a, euint256.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at some hidden index "i" (ebool variant).
+    ///  @param a EList handle to modify element in.
+    ///  @param i Hidden index position of an element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, euint256 i, ebool b) internal returns (elist ret) {
+        return inco.listSet(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at some hidden index "i" (euint256 variant).
+    ///  @param a EList handle to modify element in.
+    ///  @param i Hidden index position of an element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, euint256 i, euint256 b) internal returns (elist ret) {
+        return inco.listSet(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at plaintext index "i" (ebool variant). Reverts if out of range.
+    ///  @param a EList handle to modify element in.
+    ///  @param i Index position of element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, uint16 i, ebool b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at plaintext index "i" (euint256 variant). Reverts if out of range.
+    ///  @param a EList handle to modify element in.
+    ///  @param i Index position of element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, uint16 i, euint256 b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Return hidden element at some hidden position (ebool variant).
+    ///  @param a EList handle to get element from.
+    ///  @param i Hidden index position to get element at.
+    ///  @param defaultValue A default element value returned if index is out of range.
+    ///  @return ret A new handle for the element or the defaultValue
+    function getOr(elist a, euint256 i, ebool defaultValue) internal returns (ebool ret) {
+        return ebool.wrap(inco.listGetOr(a, euint256.unwrap(s(i)), ebool.unwrap(s(defaultValue))));
+    }
+
+    /// @notice Return hidden element at some hidden position (euint256 variant).
+    ///  @param a EList handle to get element from.
+    ///  @param i Hidden index position to get element at.
+    ///  @param defaultValue A default element value returned if index is out of range.
+    ///  @return ret A new handle for the element or the defaultValue
+    function getOr(elist a, euint256 i, euint256 defaultValue) internal returns (euint256 ret) {
+        return euint256.wrap(inco.listGetOr(a, euint256.unwrap(s(i)), euint256.unwrap(s(defaultValue))));
+    }
+
+    /// @notice Return hidden element at a known position as ebool.
+    ///  @param a EList handle to get element from.
+    ///  @param i Index position to get element at.
+    ///  @return ret Returns a handle for the element.
+    function getEbool(elist a, uint16 i) internal returns (ebool ret) {
+        return ebool.wrap(inco.listGet(a, i));
+    }
+
+    /// @notice Return hidden element at a known position as euint256.
+    ///  @param a EList handle to get element from.
+    ///  @param i Index position to get element at.
+    ///  @return ret Returns a handle for the element.
+    function getEuint256(elist a, uint16 i) internal returns (euint256 ret) {
+        return euint256.wrap(inco.listGet(a, i));
+    }
+
+    /// @notice Inserts a hidden element at a desired hidden position (ebool, hidden index).
+    ///  @param a An elist handle to insert into.
+    ///  @param i Hidden index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, euint256 i, ebool b) internal returns (elist ret) {
+        return inco.listInsert(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Inserts an ebool element at a known position. Reverts if out of range.
+    ///  @param a An elist handle to insert into.
+    ///  @param i Index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, uint16 i, ebool b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Inserts a hidden element at a desired hidden position (euint256, hidden index).
+    ///  @param a An elist handle to insert into.
+    ///  @param i Hidden index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, euint256 i, euint256 b) internal returns (elist ret) {
+        return inco.listInsert(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Inserts a euint256 element at a known position. Reverts if out of range.
+    ///  @param a An elist handle to insert into.
+    ///  @param i Index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, uint16 i, euint256 b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Concatenates two elists into one.
+    ///  @param a EList handle to be prepended
+    ///  @param b EList handle to be appended
+    ///  @return ret A new elist handle with length len(a)+len(b).
+    function concat(elist a, elist b) internal returns (elist ret) {
+        return inco.listConcat(a, b);
+    }
+
+    /// @notice Slices a list from plaintext start to plaintext end.
+    ///  @param a EList handle to be sliced
+    ///  @param start Starting index (inclusive).
+    ///  @param end End index (exclusive). Must be >= start and within bounds.
+    ///  @return ret A new sliced list with length "end-start".
+    function slice(elist a, uint16 start, uint16 end) internal returns (elist ret) {
+        require(end >= start, InvalidRange(start, end));
+        require(end <= length(a), SliceOutOfRange(start, end, length(a)));
+        require(start < length(a), SliceOutOfRange(start, end, length(a)));
+        bytes32 defaultValue;
+        if (ETypes.Uint256 == listTypeOf(a)) {
+            defaultValue = euint256.unwrap(asEuint256(0));
+        } else if (ETypes.Bool == listTypeOf(a)) {
+            defaultValue = ebool.unwrap(asEbool(false));
+        } else {
+            revert UnsupportedListType(listTypeOf(a));
+        }
+        return inco.listSlice(a, euint256.unwrap(asEuint256(start)), end - start, defaultValue);
+    }
+
+    /// @notice Slices at a hidden index with a specified length (euint256 default).
+    ///  @param a EList handle to be sliced.
+    ///  @param start Hidden starting index.
+    ///  @param len Length of the desired slice.
+    ///  @param defaultValue Default value if out of range.
+    ///  @return ret A new sliced list with length "len".
+    function sliceLen(elist a, euint256 start, uint16 len, euint256 defaultValue) internal returns (elist ret) {
+        return inco.listSlice(a, euint256.unwrap(s(start)), len, euint256.unwrap(s(defaultValue)));
+    }
+
+    /// @notice Slices at a hidden index with a specified length (ebool default).
+    ///  @param a EList handle to be sliced.
+    ///  @param start Hidden starting index.
+    ///  @param len Length of the desired slice.
+    ///  @param defaultValue Default value if out of range.
+    ///  @return ret A new sliced list with length "len".
+    function sliceLen(elist a, euint256 start, uint16 len, ebool defaultValue) internal returns (elist ret) {
+        return inco.listSlice(a, euint256.unwrap(s(start)), len, ebool.unwrap(s(defaultValue)));
+    }
+
+    /// @notice Creates a new list populated with ordered values from within range.
+    ///  @param start Start value of the range, inclusive.
+    ///  @param end End of the range, exclusive. Must be >= start.
+    ///  @return ret A new elist handle with length "end-start"
+    function range(uint16 start, uint16 end) internal returns (elist ret) {
+        return inco.listRange(start, end);
+    }
+
+    /// @notice Deterministically shuffles elements within a list.
+    ///  @dev costs the inco fee
+    ///  @param a elist handle to be shuffled
+    ///  @return ret A new elist handle with elements shuffled
+    function shuffle(elist a) internal returns (elist ret) {
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, a));
+        return elist.wrap(result);
+    }
+
+    /// @notice A convenience function equivalent to range() followed by shuffle().
+    ///  @dev costs the inco fee
+    ///  @param start Start value of the range, inclusive.
+    ///  @param end End of the range, exclusive. Must be >= start.
+    ///  @return ret A new elist handle in random order with length "end-start".
+    function shuffledRange(uint16 start, uint16 end) internal returns (elist ret) {
+        elist rangeList = inco.listRange(start, end);
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, rangeList));
+        return elist.wrap(result);
+    }
+
+    /// @notice Reverses the order of elements in a list.
+    ///  @param a Elist handle to be reversed
+    ///  @return ret A new elist handle with elements in reverse order
+    function reverse(elist a) internal returns (elist ret) {
+        return inco.listReverse(a);
+    }
+
+    /// @notice Returns the length of the list in plaintext. Pure function, no gas cost.
+    ///  @param a EList handle to read the length from
+    ///  @return len The length of the list
+    function length(elist a) internal pure returns (uint16 len) {
+        return inco.lengthOf(elist.unwrap(a));
+    }
+
+    ///  @notice  verifyEListDecryption verifies elist decryption attestation and commitment proof. Each element can be either a pre-computed hash or a commitment-value pair.
+    ///  @param elistHandle The elist handle that was decrypted
+    ///  @param proofElements Array of proof elements. Each can provide either pairHash directly, or commitment+value to compute the pairHash
+    ///  @param proof The expected proof that should match keccak256 of all concatenated pair hashes
+    ///  @param signatures Array of signatures from attesters
+    ///  @return bool True if verification succeeds
+    ///  @dev For privacy, publish only pairHash. For transparency, publish commitment+value. Can mix both in the same array.
+    function verifyEListDecryption(elist elistHandle, ElementDecryptionProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
+        return inco.incoVerifier().isValidEListDecryptionAttestation(elist.unwrap(elistHandle), proofElements, proof, signatures);
+    }
 }

package/src/libs/incoLightning_testnet_v2_889158349.sol

@@ -6,8 +6,8 @@
 pragma solidity ^0.8;
 
 import { IncoLightning } from "../IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes } from "../Types.sol";
-import { DecryptionAttestation } from "../lightning-parts/DecryptionAttester.types.sol";
+import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType } from "../Types.sol";
+import { DecryptionAttestation, ElementDecryptionProof } from "../lightning-parts/DecryptionAttester.types.sol";
 
 IncoLightning constant inco = IncoLightning(0x168FDc3Ae19A5d5b03614578C58974FF30FCBe92);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
@@ -939,4 +939,263 @@ library e {
         }
         return abi.decode(result, (bytes32));
     }
+
+    /// @notice Returns the type of the elements contained within the list.
+    ///  @param handle EList handle to read container type from.
+    ///  @return ret Type of each element in the list.
+    function listTypeOf(elist handle) internal pure returns (ETypes ret) {
+        return ETypes(uint8(uint256(elist.unwrap(handle)) >> 16));
+    }
+
+    /// @notice Creates a new empty list. Type must be specified ahead of time and can not be changed.
+    ///  @param listType Type of each element in the list.
+    ///  @return ret A new elist handle
+    function newEList(ETypes listType) internal returns (elist ret) {
+        return inco.newEList(new bytes32[](0), listType);
+    }
+
+    /// @notice Creates a new list from existing array of handles.
+    ///  @param handles An array of handles to create a new list from
+    ///  @param listType Type of each element in the list.
+    ///  @return ret A new elist handle
+    function newEList(bytes32[] memory handles, ETypes listType) internal returns (elist ret) {
+        return inco.newEList(handles, listType);
+    }
+
+    /// @notice Takes an array of user encrypted ciphertexts and returns a new elist handle.
+    ///  @param ciphertexts An array of encrypted user inputs
+    ///  @param listType Expected type of each element in the list.
+    ///  @param user Address of the user encrypting the ciphertexts.
+    ///  @return ret A new elist handle
+    ///  @dev each ciphertext costs the inco fee
+    function newEList(bytes[] memory ciphertexts, ETypes listType, address user) internal returns (elist ret) {
+        return inco.newEList{value: inco.getFee() * ciphertexts.length}(ciphertexts, listType, user);
+    }
+
+    /// @notice Appends an ebool element at the end of a list.
+    ///  @param a An elist handle to append to.
+    ///  @param b Element value to be appended.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function append(elist a, ebool b) internal returns (elist ret) {
+        return inco.listAppend(a, ebool.unwrap(s(b)));
+    }
+
+    /// @notice Appends an euint256 element at the end of a list.
+    ///  @param a An elist handle to append to.
+    ///  @param b Element value to be appended.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function append(elist a, euint256 b) internal returns (elist ret) {
+        return inco.listAppend(a, euint256.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at some hidden index "i" (ebool variant).
+    ///  @param a EList handle to modify element in.
+    ///  @param i Hidden index position of an element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, euint256 i, ebool b) internal returns (elist ret) {
+        return inco.listSet(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at some hidden index "i" (euint256 variant).
+    ///  @param a EList handle to modify element in.
+    ///  @param i Hidden index position of an element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, euint256 i, euint256 b) internal returns (elist ret) {
+        return inco.listSet(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at plaintext index "i" (ebool variant). Reverts if out of range.
+    ///  @param a EList handle to modify element in.
+    ///  @param i Index position of element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, uint16 i, ebool b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Replaces an element at plaintext index "i" (euint256 variant). Reverts if out of range.
+    ///  @param a EList handle to modify element in.
+    ///  @param i Index position of element to modify.
+    ///  @param b Element value to be changed.
+    ///  @return ret A new elist handle
+    function set(elist a, uint16 i, euint256 b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Return hidden element at some hidden position (ebool variant).
+    ///  @param a EList handle to get element from.
+    ///  @param i Hidden index position to get element at.
+    ///  @param defaultValue A default element value returned if index is out of range.
+    ///  @return ret A new handle for the element or the defaultValue
+    function getOr(elist a, euint256 i, ebool defaultValue) internal returns (ebool ret) {
+        return ebool.wrap(inco.listGetOr(a, euint256.unwrap(s(i)), ebool.unwrap(s(defaultValue))));
+    }
+
+    /// @notice Return hidden element at some hidden position (euint256 variant).
+    ///  @param a EList handle to get element from.
+    ///  @param i Hidden index position to get element at.
+    ///  @param defaultValue A default element value returned if index is out of range.
+    ///  @return ret A new handle for the element or the defaultValue
+    function getOr(elist a, euint256 i, euint256 defaultValue) internal returns (euint256 ret) {
+        return euint256.wrap(inco.listGetOr(a, euint256.unwrap(s(i)), euint256.unwrap(s(defaultValue))));
+    }
+
+    /// @notice Return hidden element at a known position as ebool.
+    ///  @param a EList handle to get element from.
+    ///  @param i Index position to get element at.
+    ///  @return ret Returns a handle for the element.
+    function getEbool(elist a, uint16 i) internal returns (ebool ret) {
+        return ebool.wrap(inco.listGet(a, i));
+    }
+
+    /// @notice Return hidden element at a known position as euint256.
+    ///  @param a EList handle to get element from.
+    ///  @param i Index position to get element at.
+    ///  @return ret Returns a handle for the element.
+    function getEuint256(elist a, uint16 i) internal returns (euint256 ret) {
+        return euint256.wrap(inco.listGet(a, i));
+    }
+
+    /// @notice Inserts a hidden element at a desired hidden position (ebool, hidden index).
+    ///  @param a An elist handle to insert into.
+    ///  @param i Hidden index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, euint256 i, ebool b) internal returns (elist ret) {
+        return inco.listInsert(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Inserts an ebool element at a known position. Reverts if out of range.
+    ///  @param a An elist handle to insert into.
+    ///  @param i Index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, uint16 i, ebool b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+    }
+
+    /// @notice Inserts a hidden element at a desired hidden position (euint256, hidden index).
+    ///  @param a An elist handle to insert into.
+    ///  @param i Hidden index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, euint256 i, euint256 b) internal returns (elist ret) {
+        return inco.listInsert(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Inserts a euint256 element at a known position. Reverts if out of range.
+    ///  @param a An elist handle to insert into.
+    ///  @param i Index position to insert at.
+    ///  @param b Element value to be inserted.
+    ///  @return ret A new elist handle with length len(a)+1.
+    function insert(elist a, uint16 i, euint256 b) internal returns (elist ret) {
+        require(i < length(a), IndexOutOfRange(i, length(a)));
+        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+    }
+
+    /// @notice Concatenates two elists into one.
+    ///  @param a EList handle to be prepended
+    ///  @param b EList handle to be appended
+    ///  @return ret A new elist handle with length len(a)+len(b).
+    function concat(elist a, elist b) internal returns (elist ret) {
+        return inco.listConcat(a, b);
+    }
+
+    /// @notice Slices a list from plaintext start to plaintext end.
+    ///  @param a EList handle to be sliced
+    ///  @param start Starting index (inclusive).
+    ///  @param end End index (exclusive). Must be >= start and within bounds.
+    ///  @return ret A new sliced list with length "end-start".
+    function slice(elist a, uint16 start, uint16 end) internal returns (elist ret) {
+        require(end >= start, InvalidRange(start, end));
+        require(end <= length(a), SliceOutOfRange(start, end, length(a)));
+        require(start < length(a), SliceOutOfRange(start, end, length(a)));
+        bytes32 defaultValue;
+        if (ETypes.Uint256 == listTypeOf(a)) {
+            defaultValue = euint256.unwrap(asEuint256(0));
+        } else if (ETypes.Bool == listTypeOf(a)) {
+            defaultValue = ebool.unwrap(asEbool(false));
+        } else {
+            revert UnsupportedListType(listTypeOf(a));
+        }
+        return inco.listSlice(a, euint256.unwrap(asEuint256(start)), end - start, defaultValue);
+    }
+
+    /// @notice Slices at a hidden index with a specified length (euint256 default).
+    ///  @param a EList handle to be sliced.
+    ///  @param start Hidden starting index.
+    ///  @param len Length of the desired slice.
+    ///  @param defaultValue Default value if out of range.
+    ///  @return ret A new sliced list with length "len".
+    function sliceLen(elist a, euint256 start, uint16 len, euint256 defaultValue) internal returns (elist ret) {
+        return inco.listSlice(a, euint256.unwrap(s(start)), len, euint256.unwrap(s(defaultValue)));
+    }
+
+    /// @notice Slices at a hidden index with a specified length (ebool default).
+    ///  @param a EList handle to be sliced.
+    ///  @param start Hidden starting index.
+    ///  @param len Length of the desired slice.
+    ///  @param defaultValue Default value if out of range.
+    ///  @return ret A new sliced list with length "len".
+    function sliceLen(elist a, euint256 start, uint16 len, ebool defaultValue) internal returns (elist ret) {
+        return inco.listSlice(a, euint256.unwrap(s(start)), len, ebool.unwrap(s(defaultValue)));
+    }
+
+    /// @notice Creates a new list populated with ordered values from within range.
+    ///  @param start Start value of the range, inclusive.
+    ///  @param end End of the range, exclusive. Must be >= start.
+    ///  @return ret A new elist handle with length "end-start"
+    function range(uint16 start, uint16 end) internal returns (elist ret) {
+        return inco.listRange(start, end);
+    }
+
+    /// @notice Deterministically shuffles elements within a list.
+    ///  @dev costs the inco fee
+    ///  @param a elist handle to be shuffled
+    ///  @return ret A new elist handle with elements shuffled
+    function shuffle(elist a) internal returns (elist ret) {
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, a));
+        return elist.wrap(result);
+    }
+
+    /// @notice A convenience function equivalent to range() followed by shuffle().
+    ///  @dev costs the inco fee
+    ///  @param start Start value of the range, inclusive.
+    ///  @param end End of the range, exclusive. Must be >= start.
+    ///  @return ret A new elist handle in random order with length "end-start".
+    function shuffledRange(uint16 start, uint16 end) internal returns (elist ret) {
+        elist rangeList = inco.listRange(start, end);
+        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, rangeList));
+        return elist.wrap(result);
+    }
+
+    /// @notice Reverses the order of elements in a list.
+    ///  @param a Elist handle to be reversed
+    ///  @return ret A new elist handle with elements in reverse order
+    function reverse(elist a) internal returns (elist ret) {
+        return inco.listReverse(a);
+    }
+
+    /// @notice Returns the length of the list in plaintext. Pure function, no gas cost.
+    ///  @param a EList handle to read the length from
+    ///  @return len The length of the list
+    function length(elist a) internal pure returns (uint16 len) {
+        return inco.lengthOf(elist.unwrap(a));
+    }
+
+    ///  @notice  verifyEListDecryption verifies elist decryption attestation and commitment proof. Each element can be either a pre-computed hash or a commitment-value pair.
+    ///  @param elistHandle The elist handle that was decrypted
+    ///  @param proofElements Array of proof elements. Each can provide either pairHash directly, or commitment+value to compute the pairHash
+    ///  @param proof The expected proof that should match keccak256 of all concatenated pair hashes
+    ///  @param signatures Array of signatures from attesters
+    ///  @return bool True if verification succeeds
+    ///  @dev For privacy, publish only pairHash. For transparency, publish commitment+value. Can mix both in the same array.
+    function verifyEListDecryption(elist elistHandle, ElementDecryptionProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
+        return inco.incoVerifier().isValidEListDecryptionAttestation(elist.unwrap(elistHandle), proofElements, proof, signatures);
+    }
 }

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

@@ -2,9 +2,10 @@
 pragma solidity ^0.8;
 
 import {IVerifierAddressGetter} from "../../primitives/interfaces/IVerifierAddressGetter.sol";
+import {IEventCounter} from "../../primitives/interfaces/IEventCounter.sol";
 import {AllowanceProof} from "../AdvancedAccessControl.types.sol";
 
-interface IBaseAccessControlList is IVerifierAddressGetter {
+interface IBaseAccessControlList is IVerifierAddressGetter, IEventCounter {
 
     function allow(bytes32 handle, address account) external;
     function allowTransient(bytes32 handle, address account) external;

package/src/lightning-parts/DecryptionAttester.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {DecryptionAttestation} from "./DecryptionAttester.types.sol";
+import {DecryptionAttestation, ElementDecryptionProof} from "./DecryptionAttester.types.sol";
 import {EIP712Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
 import {SignatureVerifier} from "./primitives/SignatureVerifier.sol";
 import {IDecryptionAttester} from "./interfaces/IDecryptionAttester.sol";
@@ -33,7 +33,7 @@ abstract contract DecryptionAttester is IDecryptionAttester, SignatureVerifier,
     /// @param decryption The decryption attestation to validate.
     /// @param signatures Array of signatures from covalidators.
     /// @return True if the attestation has valid signatures from the required covalidators.
-    function isValidDecryptionAttestation(DecryptionAttestation memory decryption, bytes[] memory signatures)
+    function isValidDecryptionAttestation(DecryptionAttestation memory decryption, bytes[] calldata signatures)
         public
         view
         returns (bool)
@@ -41,4 +41,40 @@ abstract contract DecryptionAttester is IDecryptionAttester, SignatureVerifier,
         return isValidSignature(decryptionAttestationDigest(decryption), signatures);
     }
 
+    /// @notice Validates an elist decryption attestation with commitment proof against covalidator signatures.
+    /// @dev Verifies that the attestation was signed by the required threshold of covalidators and validates the proof construction.
+    ///      Each element can be either a pre-computed hash or a commitment-value pair.
+    /// @param elistHandle The elist handle that was decrypted
+    /// @param proofElements Array of proved values. Each can provide either pairHash directly, or commitment+value to compute the pairHash
+    /// @param proof The expected proof that should match keccak256 of all concatenated pair hashes
+    /// @param signatures Array of signatures from covalidators
+    /// @return bool True if the attestation has valid signatures and proof verification succeeds
+    function isValidEListDecryptionAttestation(
+        bytes32 elistHandle,
+        ElementDecryptionProof[] calldata proofElements,
+        bytes32 proof,
+        bytes[] calldata signatures
+    ) public view override returns (bool) {
+        DecryptionAttestation memory attestation = DecryptionAttestation({handle: elistHandle, value: proof});
+
+        // Verify the provided proof by reconstructing it from the provided value-commitment pairs and/or hashes.
+        bytes32[] memory elementHashes = new bytes32[](proofElements.length);
+        for (uint256 i = 0; i < proofElements.length; i++) {
+            // Use pre-computed hash if provided, otherwise compute from commitment and value
+            if (proofElements[i].pairHash != bytes32(0)) {
+                elementHashes[i] = proofElements[i].pairHash;
+            } else {
+                elementHashes[i] = keccak256(abi.encodePacked(proofElements[i].commitment, proofElements[i].value));
+            }
+        }
+
+        // Single allocation: encode all hashes at once
+        bytes32 computedProof = keccak256(abi.encodePacked(elementHashes));
+        if (computedProof != proof) {
+            return false;
+        }
+
+        return isValidDecryptionAttestation(attestation, signatures);
+    }
+
 }

package/src/lightning-parts/DecryptionAttester.types.sol

@@ -5,3 +5,17 @@ struct DecryptionAttestation {
     bytes32 handle;
     bytes32 value; // encoded bool or uint256 // todo switch this to bytes
 }
+
+/**
+ * @notice Represents a decrypted elist value that can be either a pre-computed hash or a commitment-value pair
+ * @param pairHash Pre-computed keccak256(abi.encodePacked(commitment, value)). If non-zero, this is used directly
+ * @param commitment Commitment value. Only used if pairHash is zero
+ * @param value Decrypted value (encoded as uint256 in Solidity). Only used if pairHash is zero
+ * @dev If pairHash is provided (non-zero), commitment and value are ignored. Otherwise, hash is computed as
+ *      keccak256(abi.encodePacked(commitment, value)) using Solidity's packed ABI encoding
+ */
+struct ElementDecryptionProof {
+    bytes32 pairHash;
+    bytes32 commitment;
+    uint256 value;
+}