@inco/lightning-preview 0.8.0-devnet-8 → 0.8.0-devnet-10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inco/lightning-preview",
-  "version": "0.8.0-devnet-8",
+  "version": "0.8.0-devnet-10",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "files": [
     "src/",

package/src/IIncoLightningPreview.sol

@@ -1,7 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {IIncoLightning} from "@inco/lightning/src/interfaces/IIncoLightning.sol";
-import {IEList} from "./lightning-parts/IEList.sol";
-
-interface IIncoLightningPreview is IIncoLightning, IEList {}

package/src/IncoLightningPreview.sol

@@ -1,98 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {IncoLightning} from "@inco/lightning/src/IncoLightning.sol";
-import {
-    CONTRACT_NAME,
-    MAJOR_VERSION,
-    MINOR_VERSION,
-    PATCH_VERSION
-} from "@inco/lightning/src/version/IncoLightningConfig.sol";
-import {Version} from "@inco/lightning/src/version/Version.sol";
-import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
-import {EList} from "./lightning-parts/EList.sol";
-import {VerifierAddressGetter} from "@inco/lightning/src/lightning-parts/primitives/VerifierAddressGetter.sol";
-
-/// @title IncoLightningPreview
-/// @notice Extended version of IncoLightning with preview/experimental features
-/// @dev This contract extends the core IncoLightning functionality with additional features
-///      that are still in preview/experimental stage. It uses a diamond-like delegation pattern:
-///
-///      Architecture:
-///      - Inherits EList for encrypted list operations (preview feature)
-///      - Delegates all other calls to the core IncoLightning contract via fallback
-///      - Shares the same version and salt as the base IncoLightning for consistency
-///
-///      Call flow:
-///      1. If the function exists in IncoLightningPreview or EList, it's executed directly
-///      2. Otherwise, the fallback delegatecalls to IncoLightning for core functionality
-///
-///      This pattern allows adding new features without modifying the audited core contract.
-contract IncoLightningPreview is EList, UUPSUpgradeable, Version, OwnableUpgradeable {
-
-    /// @notice Reference to the core IncoLightning contract for delegation
-    IncoLightning private immutable LIGHTNING;
-
-    /// @notice Initializes the preview contract with references to core infrastructure
-    /// @dev Uses address type instead of IncoLightning to avoid remapping issues during deployment.
-    ///      Inherits the same version/salt as the base contract with "Preview" suffix appended.
-    /// @param _lightningAddress The deployed IncoLightning contract address
-    /// @param _verifierAddress The IncoVerifier contract address for attestation validation
-    constructor(address _lightningAddress, address _verifierAddress)
-        VerifierAddressGetter(_verifierAddress)
-        Version(
-            MAJOR_VERSION,
-            MINOR_VERSION,
-            PATCH_VERSION,
-            IncoLightning(_lightningAddress).salt(),
-            string(abi.encodePacked(CONTRACT_NAME, "Preview"))
-        )
-    {
-        LIGHTNING = IncoLightning(_lightningAddress);
-    }
-
-    /// @notice Indicates this contract includes experimental preview features
-    /// @dev Can be used by clients to detect if preview features are available
-    /// @return Always returns true for IncoLightningPreview
-    function includesPreviewFeatures() public pure returns (bool) {
-        return true;
-    }
-
-    /// @notice Authorizes contract upgrades (restricted to owner only)
-    /// @dev Required by UUPSUpgradeable. Only the contract owner can authorize upgrades.
-    function _authorizeUpgrade(address) internal view override {
-        require(msg.sender == owner());
-    }
-
-    /// @notice Initializes the proxy with an owner address
-    /// @dev Must be called immediately after proxy deployment. Can only be called once.
-    /// @param owner The address that will own this contract and can authorize upgrades
-    function initialize(address owner) public initializer {
-        __Ownable_init(owner);
-        _setAcceptedVersion(2, true);
-    }
-
-    /// @notice Delegates unhandled calls to the core IncoLightning contract
-    /// @dev Uses assembly delegatecall for gas efficiency and to properly forward all data.
-    ///      Any function not defined in IncoLightningPreview or its parents will be
-    ///      executed on IncoLightning in the context of this contract's storage.
-    fallback() external {
-        // get facet from function selector
-        address logic = address(LIGHTNING);
-        // Execute external calls using delegatecall on core and return any value.
-        assembly {
-            // copy function selector and any arguments
-            calldatacopy(0, 0, calldatasize())
-            // execute function call using the facet
-            let result := delegatecall(gas(), logic, 0, calldatasize(), 0, 0)
-            // get any return value
-            returndatacopy(0, 0, returndatasize())
-            // return any return value or error back to the caller
-            switch result
-            case 0 { revert(0, returndatasize()) }
-            default { return(0, returndatasize()) }
-        }
-    }
-
-}

package/src/Preview.Lib.sol

@@ -1,316 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {IIncoLightningPreview} from "./IIncoLightningPreview.sol";
-import {inco, ebool, euint256, e} from "@inco/lightning/src/Lib.sol";
-import {ETypes} from "@inco/lightning/src/Types.sol";
-import {elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType} from "./TypesPreview.sol";
-
-// forge-lint: disable-next-line(screaming-snake-case-const)
-IIncoLightningPreview constant incoPreview = IIncoLightningPreview(address(inco));
-
-/// @title Inco Lightning Preview Library
-/// @author Inco
-/// @notice You can use this library to try out experimental features before they get released
-/// @dev If some library functions should be in preview, declare an ePreview lib here
-/// @custom:experimental This library contains experimental features, and API may change or support can be dropped. Use at your own risk.
-library ePreview {
-
-    /**
-     * @notice  Returns the type of the elements contained within the list. This is a pure function that does not require any gas to call.
-     * @param handle EList handle to read contrainer 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 and returns a new elist handle. Type must be specified ahead of time and can not be changed.
-     * @param listType Type of each element in the list. This can not be changed
-     * @return ret A new elist handle
-     */
-    function newEList(ETypes listType) internal returns (elist ret) {
-        return incoPreview.newEList(new bytes32[](0), listType);
-    }
-
-    /**
-     * @notice  Creates a new list from existing array of handles and returns a new elist handle. Type must be specified ahead of time and can not be changed. The handle's type must match the type of the list inner type, otherwise it will revert.
-     * @param handles An array of handles to create a new list from
-     * @param listType Type of each element in the list. This can not be changed and must match the type of each handle in the array.
-     * @return ret A new elist handle
-     */
-    function newEList(bytes32[] memory handles, ETypes listType) internal returns (elist ret) {
-        return incoPreview.newEList(handles, listType);
-    }
-
-    /**
-     * @notice  Takes an array of user encrypted ciphertexts and returns a new elist handle. Expected type must be specified ahead of time and can not be changed. The ciphertext's type must match the type of the list inner type, otherwise it will revert.
-     * @param ciphertexts An array of encrypted user inputs to create a new list from
-     * @param listType Expected type of each element in the list. This can not be changed and must match the type of each ciphertext in the array.
-     * @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 incoPreview.newEList{value: inco.getFee() * ciphertexts.length}(ciphertexts, listType, user);
-    }
-
-    /**
-     * @notice  Appends an element of type ETypes.Bool at the end of a list, returning a new modified list handle.
-     * @param a An elist handle to append to. Must contain values of type ETypes.Bool.
-     * @param b Element value to be appended to the list. Must match the elist's inner type ETypes.Bool.
-     * @return ret A new elist handle. The new list will have a length of len(a)+1.
-     */
-    function append(elist a, ebool b) internal returns (elist ret) {
-        return incoPreview.listAppend(a, ebool.unwrap(e.s(b)));
-    }
-
-    /**
-     * @notice  Appends an element of type ETypes.Uint256 at the end of a list, returning a new modified list handle.
-     * @param a An elist handle to append to. Must contain values of type ETypes.Uint256.
-     * @param b Element value to be appended to the list. Must match the elist's inner type ETypes.Uint256.
-     * @return ret A new elist handle. The new list will have a length of len(a)+1.
-     */
-    function append(elist a, euint256 b) internal returns (elist ret) {
-        return incoPreview.listAppend(a, euint256.unwrap(e.s(b)));
-    }
-
-    /**
-     * @notice  Replaces an element at some hidden index "i" and returns a new modified list.
-     * @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 if the index is within range. Will return the original list if the index is out of range. Must match the elist's inner type of type ETypes.Bool
-     * @return ret A new elist handle
-     */
-    function set(elist a, euint256 i, ebool b) internal returns (elist ret) {
-        return incoPreview.listSet(a, euint256.unwrap(e.s(i)), ebool.unwrap(e.s(b)));
-    }
-
-    /**
-     * @notice  Replaces an element at some hidden index "i" and returns a new modified list.
-     * @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 if the index is within range. Will return the original list if the index is out of range. Must match the elist's inner type of type ETypes.Uint256
-     * @return ret A new elist handle
-     */
-    function set(elist a, euint256 i, euint256 b) internal returns (elist ret) {
-        return incoPreview.listSet(a, euint256.unwrap(e.s(i)), euint256.unwrap(e.s(b)));
-    }
-
-    /**
-     * @notice  Replaces an element at index "i" and returns a new modified list.
-     * @param a EList handle to modify element in.
-     * @param i Index position of element to modify.
-     * @param b Element value to be changed if the index is within range. Will revert if the index is out of range. Must match the elist's inner type of type ETypes.Bool
-     * @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 incoPreview.listSet(a, euint256.unwrap(e.asEuint256(uint256(i))), ebool.unwrap(e.s(b)));
-    }
-    /**
-     * @notice  Replaces an element at index "i" and returns a new modified list.
-     * @param a EList handle to modify element in.
-     * @param i Index position of element to modify.
-     * @param b Element value to be changed if the index is within range. Will revert if the index is out of range. Must match the elist's inner type of type ETypes.Bool
-     * @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 incoPreview.listSet(a, euint256.unwrap(e.asEuint256(uint256(i))), euint256.unwrap(e.s(b)));
-    }
-
-    /**
-     * @notice  Return hidden element at some hidden position. Returns a handle to the hidden element if the index is within range, otherwise returns the default value.
-     * @param a EList handle to get element from.
-     * @param i Hidden index position to get element at.
-     * @param defaultValue A default element value to be returned if index is out of range. Must match the elist's inner type of type ETypes.Bool.
-     * @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(incoPreview.listGetOr(a, euint256.unwrap(e.s(i)), ebool.unwrap(e.s(defaultValue))));
-    }
-    /**
-     * @notice  Return hidden element at some hidden position. Returns a handle to the hidden element if the index is within range, otherwise returns the default value.
-     * @param a EList handle to get element from.
-     * @param i Hidden index position to get element at.
-     * @param defaultValue A default element value to be returned if index is out of range. Must match the elist's inner type of type ETypes.Uint256.
-     * @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(incoPreview.listGetOr(a, euint256.unwrap(e.s(i)), euint256.unwrap(e.s(defaultValue))));
-    }
-    /**
-     * @notice  Return hidden element at a known position. Returns a handle to the hidden ETypes.Bool element if the index is within range, otherwise reverts.
-     * @param a EList handle to get element from.
-     * @param i Index position to get element at.
-     * @return ret Returns a handle for the element of type ETypes.Bool.
-     */
-
-    function getEbool(elist a, uint16 i) internal returns (ebool ret) {
-        return ebool.wrap(incoPreview.listGet(a, i));
-    }
-    /**
-     * @notice  Return hidden element at a known position. Returns a handle to the hidden ETypes.Uint256 element if the index is within range, otherwise reverts.
-     * @param a EList handle to get element from.
-     * @param i Index position to get element at.
-     * @return ret Returns a handle for the element of type ETypes.Uint256.
-     */
-
-    function getEuint256(elist a, uint16 i) internal returns (euint256 ret) {
-        return euint256.wrap(incoPreview.listGet(a, i));
-    }
-
-    /**
-     * @notice  Inserts a hidden element at a desired hidden position, returns a new modified list.
-     * @param a An elist handle to insert into.
-     * @param i Hidden index position to insert at. If the index is out of range, the element will be appended to the end of the list.
-     * @param b Element value to be inserted to the list. Must match the elist's inner type of type ETypes.Bool.
-     * @return ret A new elist handle. The new list will have a length of len(a)+1.
-     */
-    function insert(elist a, euint256 i, ebool b) internal returns (elist ret) {
-        return incoPreview.listInsert(a, euint256.unwrap(e.s(i)), ebool.unwrap(e.s(b)));
-    }
-    /**
-     * @notice  Inserts a hidden element at a desired position, returns a new modified list.
-     * @param a An elist handle to insert into.
-     * @param i Index position to insert at. If the index is out of range, it will revert.
-     * @param b Element value to be inserted to the list. Must match the elist's inner type of type ETypes.Bool.
-     * @return ret A new elist handle. The new list will have a length of len(a)+1.
-     */
-
-    function insert(elist a, uint16 i, ebool b) internal returns (elist ret) {
-        require(i < length(a), IndexOutOfRange(i, length(a)));
-        return incoPreview.listInsert(a, euint256.unwrap(e.asEuint256(uint256(i))), ebool.unwrap(e.s(b)));
-    }
-    /**
-     * @notice  Inserts a hidden element at a desired hidden position, returns a new modified list.
-     * @param a An elist handle to insert into.
-     * @param i Hidden index position to insert at. If the index is out of range, the element will be appended to the end of the list.
-     * @param b Element value to be inserted to the list. Must match the elist's inner type of type ETypes.Uint256.
-     * @return ret A new elist handle. The new list will have a length of len(a)+1.
-     */
-
-    function insert(elist a, euint256 i, euint256 b) internal returns (elist ret) {
-        return incoPreview.listInsert(a, euint256.unwrap(e.s(i)), euint256.unwrap(e.s(b)));
-    }
-    /**
-     * @notice  Inserts a hidden element at a desired position, returns a new modified list.
-     * @param a An elist handle to insert into.
-     * @param i Index position to insert at. If the index is out of range, it will revert.
-     * @param b Element value to be inserted to the list. Must match the elist's inner type of type ETypes.Uint256.
-     * @return ret A new elist handle. The new list will have a length of len(a)+1.
-     */
-
-    function insert(elist a, uint16 i, euint256 b) internal returns (elist ret) {
-        require(i < length(a), IndexOutOfRange(i, length(a)));
-        return incoPreview.listInsert(a, euint256.unwrap(e.asEuint256(uint256(i))), euint256.unwrap(e.s(b)));
-    }
-
-    /**
-     * @notice  Concatenates two elists into one, returns a new concatenated elist. Both lists must have the same inner type. The length of the new list will be length(list1)+length(list2)
-     * @param a EList handle to be prepended
-     * @param b EList handle to be appended
-     * @return ret A new elist handle containing elements from both A and B with length of len(list1)+len(list2).
-     */
-    function concat(elist a, elist b) internal returns (elist ret) {
-        return incoPreview.listConcat(a, b);
-    }
-
-    /**
-     * @notice  Takes in start and end positions both in plaintext. Returns a new sliced list of length “end-start”. If start or end are out of bounds, it will revert. The end index must be greater or equal the start index.
-     * @param a EList handle to be sliced
-     * @param start Starting index of the slice, in plaintext. Start is inclusive, meaning if start is 0, the first element will be included in the new slice.
-     * @param end End index of the slice, in plaintext. End is exclusive and must be greater or equal start and within the bounds of the list length.
-     * @return ret A new sliced list with a new length of “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(e.asEuint256(0));
-        } else if (ETypes.Bool == listTypeOf(a)) {
-            defaultValue = ebool.unwrap(e.asEbool(false));
-        } else {
-            revert UnsupportedListType(listTypeOf(a));
-        }
-        return incoPreview.listSlice(a, euint256.unwrap(e.asEuint256(start)), end - start, defaultValue);
-    }
-    /**
-     * @notice  sliceLen() is a variant of slice() but allows to slice at some hidden index specifying a length instead of end position. Returns a new sliced list of length of “len”.
-     * @param a EList handle to be sliced, must be of type ETypes.Uint256.
-     * @param start Hidden starting index of the slice. Start is inclusive, meaning if start is 0, the first element will be included in the new slice. If start is out of bounds, all elements in the returned slice will be the default element.
-     * @param len Length of the desired slice. If the length is out of bounds, remaining elements will be filled with the provided default value.
-     * @param defaultValue Default value to fill the remaining elements of the slice if out of range.
-     * @return ret a new sliced list with a new length of "len".
-     */
-
-    function sliceLen(elist a, euint256 start, uint16 len, euint256 defaultValue) internal returns (elist ret) {
-        return incoPreview.listSlice(a, euint256.unwrap(e.s(start)), len, euint256.unwrap(e.s(defaultValue)));
-    }
-    /**
-     * @notice  sliceLen() is a variant of slice() but allows to slice at some hidden index specifying a length instead of end position. Returns a new sliced list of length of “len”.
-     * @param a EList handle to be sliced. List type must be of type ETypes.EBool.
-     * @param start Hidden starting index of the slice. Start is inclusive, meaning if start is 0, the first element will be included in the new slice.
-     * @param len Length of the desired slice. If the length is out of bounds, remaining elements will be filled with the provided default value.
-     * @param defaultValue Default value to fill the remaining elements of the slice if out of range.
-     * @return ret a new sliced list with a new length of "len".
-     */
-
-    function sliceLen(elist a, euint256 start, uint16 len, ebool defaultValue) internal returns (elist ret) {
-        return incoPreview.listSlice(a, euint256.unwrap(e.s(start)), len, ebool.unwrap(e.s(defaultValue)));
-    }
-
-    /**
-     * @notice  Creates a new list (or a “set”) and populates it with ordered values from within range. The length of the new list will be equal to “end-start”.
-     * @param start Start value of the range, inclusive.
-     * @param end End of the range, exclusive. Must be greater or equal start.
-     * @return ret A new elist handle containing a range of unique elements with the length of “end-start”
-     */
-    function range(uint16 start, uint16 end) internal returns (elist ret) {
-        return incoPreview.listRange(start, end);
-    }
-
-    /**
-     * @notice  Deterministically shuffles elements within a list, returning a new shuffled list with the same length.
-     * @param a elist handle to be shuffled
-     * @return ret A new elist handle with elements shuffled where each element is equally likely to be in any position in the new list.
-     */
-    function shuffle(elist a) internal returns (elist ret) {
-        return incoPreview.listShuffle{value: inco.getFee()}(a);
-    }
-
-    /**
-     * @notice  A convenience function equivalent to range() followed by shuffle(). It returns an elist containing the elements from start to end in a random order.
-     * @param start Start value of the range, inclusive.
-     * @param end End of the range, exclusive. Must be greater or equal start.
-     * @return ret A new elist handle containing a range of unique elements with the length of “end-start” in a random order.
-     */
-    function shuffledRange(uint16 start, uint16 end) internal returns (elist ret) {
-        return incoPreview.listShuffle{value: inco.getFee()}(incoPreview.listRange(start, end));
-    }
-
-    /**
-     * @notice  Reverses the order of elements in a list, first element becomes last, and so on.
-     * @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 incoPreview.listReverse(a);
-    }
-
-    /**
-     * @notice  Returns the length of the list in plaintext. It’s a pure function that doesn’t require any gas to call.
-     * @param a EList handle to read the length from
-     * @return len The length of the list in plaintext
-     */
-    function length(elist a) internal pure returns (uint16 len) {
-        return incoPreview.lengthOf(elist.unwrap(a));
-    }
-
-}

package/src/PreviewDeployUtils.sol

@@ -1,75 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {IncoLightningPreview} from "./IncoLightningPreview.sol";
-import {IIncoLightningPreview} from "./IIncoLightningPreview.sol";
-import {DeployUtils} from "@inco/lightning/src/DeployUtils.sol";
-import {IncoLightning} from "@inco/lightning/src/IncoLightning.sol";
-import {IIncoLightning} from "@inco/lightning/src/interfaces/IIncoLightning.sol";
-import {IIncoVerifier} from "@inco/lightning/src/interfaces/IIncoVerifier.sol";
-import {IQuoteVerifier} from "@inco/lightning/src/interfaces/automata-interfaces/IQuoteVerifier.sol";
-import {console} from "forge-std/console.sol";
-
-/// @title PreviewDeployUtils
-/// @notice Deployment utilities for IncoLightningPreview and its dependencies
-/// @dev Extends DeployUtils to add preview-specific deployment functions.
-///      Uses CreateX for deterministic cross-chain deployments with computed addresses.
-///
-///      Deployment order:
-///      1. Deploy IncoLightning implementation (base contract)
-///      2. Deploy IncoLightningPreview implementation (extends base with preview features)
-///      3. Deploy proxy pointing to preview implementation
-///      4. Deploy IncoVerifier with reference to the proxy
-contract PreviewDeployUtils is DeployUtils {
-
-    /// @notice Deploys IncoLightningPreview with all required infrastructure
-    /// @dev Creates the implementation contracts and proxy in a single transaction.
-    ///      The verifier address is computed from salt for use before deployment.
-    /// @param lightningSalt Salt for deterministic deployment of lightning contracts
-    /// @param verifierSalt Salt for deterministic deployment of the verifier
-    /// @param deployer Address that will own the deployed proxy
-    /// @return lightningPreview The deployed proxy contract cast to IIncoLightningPreview
-    function deployLightningPreview(bytes32 lightningSalt, bytes32 verifierSalt, address deployer)
-        internal
-        returns (IIncoLightningPreview lightningPreview)
-    {
-        address verifierAddress = computeAddressFromSalt(verifierSalt);
-        IncoLightning lightningImplem = new IncoLightning(lightningSalt, IIncoVerifier(verifierAddress));
-        IncoLightningPreview lightningPreviewImplem =
-            new IncoLightningPreview(address(lightningImplem), address(lightningImplem.incoVerifier()));
-        lightningPreview = IIncoLightningPreview(
-            deployProxy({
-                salt: lightningSalt,
-                implem: address(lightningPreviewImplem),
-                initCall: abi.encodeWithSelector(
-                    IIncoLightning.initialize.selector,
-                    deployer // owner
-                )
-            })
-        );
-    }
-
-    /// @notice Full deployment of IncoLightningPreview using configuration-based salts
-    /// @dev Computes salts from deployer and pepper, then deploys both lightning preview
-    ///      and verifier contracts. Logs the deployment configuration for verification.
-    /// @param deployer Address that will own both deployed proxies
-    /// @param pepper String used to generate unique deployment salts
-    /// @param quoteVerifier The Automata quote verifier for TEE attestation validation
-    /// @return lightningPreviewProxy The deployed IncoLightningPreview proxy
-    /// @return verifierProxy The deployed IncoVerifier proxy
-    function deployIncoLightningPreviewUsingConfig(address deployer, string memory pepper, IQuoteVerifier quoteVerifier)
-        internal
-        returns (IIncoLightningPreview lightningPreviewProxy, IIncoVerifier verifierProxy)
-    {
-        (bytes32 lightningSalt, bytes32 verifierSalt) = getIncoSalts(deployer, pepper);
-        console.log(
-            "Deploying Inco with preview features with deployerAddress: %s, lightning salt: %s",
-            vm.toString(deployer),
-            vm.toString(lightningSalt)
-        );
-        lightningPreviewProxy = deployLightningPreview(lightningSalt, verifierSalt, deployer);
-        verifierProxy =
-            deployVerifier(verifierSalt, IIncoLightning(address(lightningPreviewProxy)), deployer, quoteVerifier);
-    }
-
-}

package/src/TypesPreview.sol

@@ -1,18 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {ETypes} from "@inco/lightning/src/Types.sol";
-
-type elist is bytes32;
-
-error IndexOutOfRange(uint16 i, uint16 len);
-error SliceOutOfRange(uint16 start, uint16 end, uint16 len);
-error ZeroLength();
-error InvalidRange(uint16 start, uint16 end);
-error ListTypeMismatch(ETypes lhs, ETypes rhs);
-error UnsupportedListType(ETypes listType);
-error UnsupportedType(ETypes actual);
-
-function isEList(ETypes t) pure returns (bool) {
-    return t == ETypes.List;
-}

package/src/lightning-parts/EList.sol

@@ -1,322 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {ETypes, EOps, typeToBitMask, isTypeSupported} from "@inco/lightning/src/Types.sol";
-import {IndexOutOfRange} from "../TypesPreview.sol";
-import {AccessControlListStorage} from "@inco/lightning/src/lightning-parts/AccessControl/BaseAccessControlList.sol";
-import {EncryptedOperations} from "@inco/lightning/src/lightning-parts/EncryptedOperations.sol";
-import {EncryptedInput} from "@inco/lightning/src/lightning-parts/EncryptedInput.sol";
-import {EListHandleGeneration} from "./primitives/EListHandleGeneration.sol";
-import {IEList} from "./IEList.sol";
-import {elist, ListTypeMismatch, InvalidRange} from "../TypesPreview.sol";
-
-/// @title EList
-/// @notice Provides operations for encrypted lists (elist) - ordered collections of encrypted values.
-/// @dev Encrypted lists are immutable; all operations return new list handles rather than modifying in place.
-/// Lists are homogeneous - all elements must be of the same encrypted type. Operations are processed
-/// by the covalidator off-chain. This is a preview feature and may change in future versions.
-abstract contract EList is
-    AccessControlListStorage,
-    EListHandleGeneration,
-    EncryptedOperations,
-    EncryptedInput,
-    IEList
-{
-
-    event NewEList(bytes32 indexed result, ETypes listType, bytes32[] handles, uint256 eventId);
-    event EListAppend(elist indexed list, bytes32 indexed value, elist indexed result, uint256 eventId);
-    event EListGet(elist indexed list, uint16 indexed index, bytes32 indexed result, uint256 eventId);
-    event EListGetOr(
-        elist indexed list, bytes32 index, bytes32 indexed defaultValue, bytes32 indexed result, uint256 eventId
-    );
-    event EListSet(elist list, bytes32 indexed index, bytes32 indexed value, elist indexed result, uint256 eventId);
-    event EListInsert(elist list, bytes32 indexed index, bytes32 indexed value, elist indexed result, uint256 eventId);
-    event EListConcat(elist indexed list1, elist indexed list2, elist indexed result, uint256 eventId);
-    event EListSlice(
-        elist list,
-        bytes32 indexed start,
-        uint16 length,
-        bytes32 indexed defaultValue,
-        elist indexed result,
-        uint256 eventId
-    );
-    event EListRange(uint256 indexed start, uint256 indexed end, 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);
-
-    /// @notice Creates a new encrypted list from client-encrypted inputs.
-    /// @dev Internal function that processes multiple encrypted inputs without individual payment.
-    /// Payment should be handled by the caller for the batch.
-    /// @param inputs Array of encrypted inputs with prepended handles.
-    /// @param listType The type of elements in the list.
-    /// @param user The user address that encrypted the values.
-    /// @return newList The new encrypted list handle.
-    function newEListFromInputs(bytes[] calldata inputs, ETypes listType, address user)
-        internal
-        returns (elist newList)
-    {
-        require(isTypeSupported(listType), UnsupportedType(listType));
-
-        // TODO: Add a new event to create new elist from inputs, can be done as an upgrade to optimize for gas and castore.
-        bytes32[] memory handles = new bytes32[](inputs.length);
-        for (uint256 i = 0; i < inputs.length; i++) {
-            // we check payment for multiple inputs ahead of this func
-            handles[i] = newInputNotPaying(inputs[i], user, listType);
-        }
-        return newEListFromHandles(handles, listType);
-    }
-
-    /// @notice Creates a new encrypted list from existing encrypted handles.
-    /// @dev Validates that all handles are of the expected type and caller has access.
-    /// @param handles Array of encrypted value handles to include in the list.
-    /// @param listType The type of elements in the list (must match handle types).
-    /// @return newList The new encrypted list handle.
-    function newEListFromHandles(bytes32[] memory handles, ETypes listType) internal returns (elist newList) {
-        require(isTypeSupported(listType), UnsupportedType(listType));
-        for (uint256 i = 0; i < handles.length; i++) {
-            checkInput(handles[i], typeToBitMask(listType));
-        }
-
-        bytes32 newHandle = createListInputHandle(handles, listType);
-
-        allowTransientInternal(newHandle, msg.sender);
-
-        emit NewEList(newHandle, listType, handles, getNewEventId());
-
-        return elist.wrap(newHandle);
-    }
-
-    /// @notice Creates a new encrypted list from existing encrypted handles.
-    /// @dev External wrapper for newEListFromHandles.
-    /// @param handles Array of encrypted value handles to include in the list.
-    /// @param listType The type of elements in the list.
-    /// @return newList The new encrypted list handle.
-    function newEList(bytes32[] memory handles, ETypes listType) external returns (elist newList) {
-        return newEListFromHandles(handles, listType);
-    }
-
-    /// @notice Creates a new encrypted list from client-encrypted inputs.
-    /// @dev This is a paid operation. Payment scales with the number of inputs.
-    /// @param inputs Array of encrypted inputs with prepended handles.
-    /// @param listType The type of elements in the list.
-    /// @param user The user address that encrypted the values.
-    /// @return newList The new encrypted list handle.
-    function newEList(bytes[] calldata inputs, ETypes listType, address user)
-        external
-        payable
-        payingMultiple(inputs.length)
-        returns (elist newList)
-    {
-        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.
-    /// @param value The encrypted value to append (must match list element type).
-    /// @return result A new encrypted list with the value appended.
-    function listAppend(elist list, bytes32 value) external returns (elist result) {
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-        checkInput(value, typeToBitMask(listTypeOf(elist.unwrap(list))));
-
-        result = elist.wrap(
-            createListResultHandle(
-                EOps.EListAppend,
-                listTypeOf(elist.unwrap(list)),
-                lengthOf(elist.unwrap(list)) + 1,
-                abi.encodePacked(elist.unwrap(list), value)
-            )
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListAppend(list, value, result, getNewEventId());
-    }
-
-    /// @notice Retrieves an encrypted element at a specific index.
-    /// @dev Reverts if the index is out of range. For safe access with a default, use listGetOr.
-    /// @param list The encrypted list to access.
-    /// @param i The index to retrieve (0-based).
-    /// @return result The encrypted element at the specified index.
-    function listGet(elist list, uint16 i) external returns (bytes32 result) {
-        require(i < lengthOf(elist.unwrap(list)), IndexOutOfRange(i, lengthOf(elist.unwrap(list))));
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-
-        result =
-            createResultHandle(EOps.EListGet, listTypeOf(elist.unwrap(list)), abi.encodePacked(elist.unwrap(list), i));
-        emit EListGet(list, i, result, getNewEventId());
-    }
-
-    /// @notice Retrieves an encrypted element at an encrypted index, with a default value for out-of-range access.
-    /// @dev Returns the default value if the index is out of range. Index must be euint256.
-    /// @param list The encrypted list to access.
-    /// @param index The encrypted index to retrieve.
-    /// @param defaultValue The encrypted value to return if index is out of range.
-    /// @return result The encrypted element at the index, or defaultValue if out of range.
-    function listGetOr(elist list, bytes32 index, bytes32 defaultValue) external returns (bytes32 result) {
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-        checkInput(defaultValue, typeToBitMask(listTypeOf(elist.unwrap(list))));
-        checkInput(index, typeToBitMask(ETypes.Uint256)); //Currently we only support euint256 for index
-
-        result = createResultHandle(
-            EOps.EListGetOr, listTypeOf(elist.unwrap(list)), abi.encodePacked(elist.unwrap(list), index, defaultValue)
-        );
-        emit EListGetOr(list, index, defaultValue, result, getNewEventId());
-    }
-
-    /// @notice Sets an encrypted element at an encrypted index.
-    /// @dev Returns a new list with the element replaced; original list is unchanged.
-    /// Index must be euint256. Out-of-range behavior is handled by the covalidator.
-    /// @param list The encrypted list to modify.
-    /// @param index The encrypted index to set.
-    /// @param value The new encrypted value (must match list element type).
-    /// @return result A new encrypted list with the element replaced.
-    function listSet(elist list, bytes32 index, bytes32 value) external returns (elist result) {
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-        checkInput(index, typeToBitMask(ETypes.Uint256)); //Currently we only support euint256 for index
-        checkInput(value, typeToBitMask(listTypeOf(elist.unwrap(list))));
-
-        result = elist.wrap(
-            createListResultHandle(
-                EOps.EListSet,
-                listTypeOf(elist.unwrap(list)),
-                lengthOf(elist.unwrap(list)),
-                abi.encodePacked(elist.unwrap(list), index, value)
-            )
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListSet(list, index, value, result, getNewEventId());
-    }
-
-    /// @notice Inserts an encrypted element at an encrypted index, shifting subsequent elements.
-    /// @dev Returns a new list with one additional element. Index must be euint256.
-    /// @param list The encrypted list to modify.
-    /// @param index The encrypted index at which to insert.
-    /// @param value The encrypted value to insert (must match list element type).
-    /// @return result A new encrypted list with the element inserted.
-    function listInsert(elist list, bytes32 index, bytes32 value) external returns (elist result) {
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-        checkInput(index, typeToBitMask(ETypes.Uint256)); //Currently we only support euint256 for index
-        checkInput(value, typeToBitMask(listTypeOf(elist.unwrap(list))));
-
-        result = elist.wrap(
-            createListResultHandle(
-                EOps.EListInsert,
-                listTypeOf(elist.unwrap(list)),
-                lengthOf(elist.unwrap(list)) + 1,
-                abi.encodePacked(elist.unwrap(list), index, value)
-            )
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListInsert(list, index, value, result, getNewEventId());
-    }
-
-    /// @notice Concatenates two encrypted lists into a new list.
-    /// @dev Both lists must have the same element type. Returns a new list with all elements.
-    /// @param lhs The first encrypted list.
-    /// @param rhs The second encrypted list (must have same element type as lhs).
-    /// @return result A new encrypted list containing all elements from both lists.
-    function listConcat(elist lhs, elist rhs) external returns (elist result) {
-        checkInput(elist.unwrap(lhs), typeToBitMask(ETypes.List));
-        checkInput(elist.unwrap(rhs), typeToBitMask(ETypes.List));
-        ETypes lhsType = listTypeOf(elist.unwrap(lhs));
-        ETypes rhsType = listTypeOf(elist.unwrap(rhs));
-        require(lhsType == rhsType, ListTypeMismatch(lhsType, rhsType));
-
-        result = elist.wrap(
-            createListResultHandle(
-                EOps.EListConcat,
-                listTypeOf(elist.unwrap(lhs)),
-                lengthOf(elist.unwrap(lhs)) + lengthOf(elist.unwrap(rhs)),
-                abi.encodePacked(elist.unwrap(lhs), elist.unwrap(rhs))
-            )
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListConcat(lhs, rhs, result, getNewEventId());
-    }
-
-    /// @notice Extracts a slice from an encrypted list starting at an encrypted index.
-    /// @dev Returns a new list of the specified length. Uses defaultValue for out-of-range positions.
-    /// @param list The encrypted list to slice.
-    /// @param start The encrypted starting index.
-    /// @param len The number of elements to include in the slice.
-    /// @param defaultValue The encrypted value to use for out-of-range positions.
-    /// @return result A new encrypted list containing the slice.
-    function listSlice(elist list, bytes32 start, uint16 len, bytes32 defaultValue) external returns (elist result) {
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-        checkInput(defaultValue, typeToBitMask(listTypeOf(elist.unwrap(list))));
-        checkInput(start, typeToBitMask(ETypes.Uint256));
-
-        result = elist.wrap(
-            createListResultHandle(
-                EOps.EListSlice,
-                listTypeOf(elist.unwrap(list)),
-                len,
-                abi.encodePacked(elist.unwrap(list), start, defaultValue)
-            )
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListSlice(list, start, len, defaultValue, result, getNewEventId());
-    }
-
-    /// @notice Creates an encrypted list containing a range of encrypted integers.
-    /// @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.
-    /// @return result A new encrypted list containing the range [start, end).
-    function listRange(uint16 start, uint16 end) external returns (elist result) {
-        require(start <= end, InvalidRange(start, end));
-
-        result = elist.wrap(
-            createListResultHandle(EOps.EListRange, ETypes.Uint256, end - start, abi.encodePacked(start, end))
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListRange(start, end, result, getNewEventId());
-    }
-
-    /// @notice Randomly shuffles the elements of an encrypted list.
-    /// @dev This is a paid operation. Returns a new list with elements in random order.
-    /// The shuffle is cryptographically secure, computed by the covalidator.
-    /// @param list The encrypted list to shuffle.
-    /// @return result A new encrypted list with elements in random order.
-    function listShuffle(elist list) external payable paying returns (elist result) {
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-        randCounter++;
-        result = elist.wrap(
-            createListResultHandle(
-                EOps.EListShuffle,
-                listTypeOf(elist.unwrap(list)),
-                lengthOf(elist.unwrap(list)),
-                abi.encodePacked(elist.unwrap(list), bytes32(randCounter))
-            )
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListShuffle(list, randCounter, result, getNewEventId());
-    }
-
-    /// @notice Reverses the order of elements in an encrypted list.
-    /// @dev Returns a new list with elements in reverse order; original list is unchanged.
-    /// @param list The encrypted list to reverse.
-    /// @return result A new encrypted list with elements in reverse order.
-    function listReverse(elist list) external returns (elist result) {
-        checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
-
-        result = elist.wrap(
-            createListResultHandle(
-                EOps.EListReverse,
-                listTypeOf(elist.unwrap(list)),
-                lengthOf(elist.unwrap(list)),
-                abi.encodePacked(elist.unwrap(list))
-            )
-        );
-        allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListReverse(list, result, getNewEventId());
-    }
-
-}

package/src/lightning-parts/IEList.sol

@@ -1,33 +0,0 @@
-/// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {elist, ETypes} from "../TypesPreview.sol";
-import {IEListHandleMetadata} from "./primitives/interfaces/IEListHandleMetadata.sol";
-
-interface IEList is IEListHandleMetadata {
-
-    function newEList(bytes32[] memory handles, ETypes listType) external returns (elist newList);
-
-    function newEList(bytes[] calldata inputs, ETypes listType, address user) external payable returns (elist newList);
-
-    function listAppend(elist list, bytes32 value) external returns (elist result);
-
-    function listGet(elist list, uint16 i) external returns (bytes32 result);
-
-    function listGetOr(elist list, bytes32 i, bytes32 defaultValue) external returns (bytes32 result);
-
-    function listSet(elist list, bytes32 i, bytes32 value) external returns (elist result);
-
-    function listInsert(elist list, bytes32 i, bytes32 value) external returns (elist result);
-
-    function listConcat(elist lhs, elist rhs) external returns (elist result);
-
-    function listSlice(elist list, bytes32 start, uint16 len, bytes32 defaultValue) external returns (elist result);
-
-    function listRange(uint16 start, uint16 end) external returns (elist result);
-
-    function listShuffle(elist list) external payable returns (elist result);
-
-    function listReverse(elist list) external returns (elist result);
-
-}

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

@@ -1,63 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {ETypes, EOps} from "@inco/lightning/src/Types.sol";
-import {HandleGeneration} from "@inco/lightning/src/lightning-parts/primitives/HandleGeneration.sol";
-import {EListHandleMetadata} from "./EListHandleMetadata.sol";
-
-/// @title EListHandleGeneration
-/// @notice Generates deterministic handles for encrypted list operations
-/// @dev Extends the base HandleGeneration with list-specific handle creation.
-///      List handles incorporate additional metadata:
-///      - List length (number of elements)
-///      - Element type (encrypted type of individual elements)
-///      - List marker (ETypes.List to identify as a list)
-///
-///      The handle is derived from:
-///      - The operation type (EOps.NewEList for list creation)
-///      - The packed input handles (for lists created from existing handles)
-contract EListHandleGeneration is HandleGeneration, EListHandleMetadata {
-
-    /// @notice Creates a handle for a list operation result
-    /// @dev Generates a deterministic handle by hashing the operation and inputs,
-    ///      then embedding list metadata (length, element type, list marker, version).
-    /// @param op The operation that produced this list (e.g., NewEList, Slice)
-    /// @param listType The encrypted type of individual list elements (euint8, euint64, etc.)
-    /// @param len The number of elements in the resulting list
-    /// @param packedInputs ABI-packed representation of the input handles
-    /// @return result The deterministic handle for this list
-    function createListResultHandle(EOps op, ETypes listType, uint16 len, bytes memory packedInputs)
-        internal
-        pure
-        returns (bytes32 result)
-    {
-        bytes32 baseHandle = keccak256(abi.encodePacked(op, packedInputs));
-        baseHandle = embedListLength(baseHandle, len);
-        baseHandle = embedListType(baseHandle, listType);
-        result = embedTypeVersion(baseHandle, ETypes.List);
-    }
-
-    /// @notice Creates a handle for a new list composed from individual encrypted handles
-    /// @dev This is the primary entry point for creating lists from existing encrypted values.
-    ///      The handle is deterministically derived from the input handles, ensuring the same
-    ///      inputs always produce the same list handle.
-    /// @param handles Array of encrypted value handles to combine into a list
-    /// @param listType The encrypted type of all elements (must be uniform)
-    /// @return newHandle The deterministic handle for the new list
-    function createListInputHandle(bytes32[] memory handles, ETypes listType)
-        internal
-        pure
-        returns (bytes32 newHandle)
-    {
-        newHandle = createListResultHandle(
-            EOps.NewEList,
-            listType,
-            uint16(handles.length),
-            abi.encodePacked(
-                //Since we're only dealing with handles, it should be sufficient to treat this operation as an operand on handles.
-                handles
-            )
-        );
-    }
-
-}

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

@@ -1,60 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {ETypes} from "@inco/lightning/src/Types.sol";
-import {IEListHandleMetadata} from "./interfaces/IEListHandleMetadata.sol";
-
-/// @title EListHandleMetadata
-/// @notice Utilities for embedding and extracting metadata from encrypted list handles
-/// @dev Encrypted lists have additional metadata compared to scalar handles:
-///      Handle structure (32 bytes / 256 bits):
-///      - Bytes 0-26: Handle-specific data (hash, counters, etc.)
-///      - Bytes 27-28: List length (uint16, max 65535 elements)
-///      - Byte 29: Element type (ETypes enum value for individual elements)
-///      - Byte 30: List type marker (identifies this as a list handle)
-///      - Byte 31: Handle version
-///
-///      This allows efficient extraction of list metadata without external calls.
-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 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) {
-        // 27 and 28 bits are used for the list length
-        result = prehandle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffffff;
-        result = bytes32(uint256(result) | (uint256(len) << 24)); // append length
-    }
-
-    /// @notice Extracts the list length from a list handle
-    /// @dev Reads bytes 27-28 of the handle as a uint16
-    /// @param handle The encrypted list handle to inspect
-    /// @return The number of elements in the list
-    function lengthOf(bytes32 handle) public pure returns (uint16) {
-        return uint16(uint256(handle) >> 24);
-    }
-
-    /// @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 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;
-        result = bytes32(uint256(result) | (uint256(listType) << 16)); // append element type
-    }
-
-    /// @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.
-    /// @param handle The encrypted list handle to inspect
-    /// @return The encrypted type of list elements (euint8, euint64, etc.)
-    function listTypeOf(bytes32 handle) internal pure returns (ETypes) {
-        return ETypes(uint8(uint256(handle) >> 16));
-    }
-
-}

package/src/lightning-parts/primitives/interfaces/IEListHandleMetadata.sol

@@ -1,8 +0,0 @@
-/// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-interface IEListHandleMetadata {
-
-    function lengthOf(bytes32 handle) external pure returns (uint16);
-
-}

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

@@ -1,66 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {PreviewIncoTest} from "../../test/PreviewIncoTest.sol";
-import {ElistTester} from "../../test/EListTester.sol";
-import {incoPreview, ETypes, elist} from "../../Preview.Lib.sol";
-import {FEE, Fee} from "@inco/lightning/src/lightning-parts/Fee.sol";
-import {EList} from "../EList.sol";
-import {VerifierAddressGetter} from "@inco/lightning/src/lightning-parts/primitives/VerifierAddressGetter.sol";
-
-contract ElistFeeTester is EList {
-
-    constructor() VerifierAddressGetter(address(0)) {}
-
-}
-
-contract TestEList is PreviewIncoTest {
-
-    ElistTester tester;
-    ElistFeeTester feeTester;
-
-    function setUp() public virtual override {
-        super.setUp();
-        tester = new ElistTester(incoPreview);
-        vm.deal(address(tester), 1 ether);
-        feeTester = new ElistFeeTester();
-    }
-
-    function testNewElistFromInputs() public {
-        createList();
-        // todo test read the created list
-    }
-
-    function testListAppend() public {
-        createList();
-        bytes memory ctValue = fakePrepareEuint256Ciphertext(40, address(this), address(tester));
-        tester.listAppend(ctValue);
-    }
-
-    function createList() internal returns (elist list) {
-        bytes[] memory inputs = new bytes[](3);
-        inputs[0] = fakePrepareEuint256Ciphertext(10, address(this), address(tester));
-        inputs[1] = fakePrepareEuint256Ciphertext(20, address(this), address(tester));
-        inputs[2] = fakePrepareEuint256Ciphertext(30, address(this), address(tester));
-        list = tester.newEList(inputs, ETypes.Uint256, address(this));
-    }
-
-    function testRevertsOnBadFeeAmount() public {
-        // should fail if no fee
-        vm.expectRevert(Fee.FeeNotPaid.selector);
-        feeTester.listShuffle(elist.wrap(bytes32(0)));
-
-        // should fail if not enough fee
-        vm.expectRevert(Fee.FeeNotPaid.selector);
-        feeTester.listShuffle{value: FEE - 1}(elist.wrap(bytes32(0)));
-
-        // should fail if too much fee
-        vm.expectRevert(Fee.FeeNotPaid.selector);
-        feeTester.listShuffle{value: FEE + 1}(elist.wrap(bytes32(0)));
-
-        vm.expectRevert(Fee.FeeNotPaid.selector);
-        bytes[] memory inputs = new bytes[](3);
-        feeTester.newEList{value: FEE * 2}(inputs, ETypes.Uint256, address(this));
-    }
-
-}

package/src/misc/ABIHelper.sol

@@ -1,15 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {Session} from "@inco/lightning/src/periphery/SessionVerifier.sol";
-
-// @dev this contract is not used on-chain, it is only used to generate the
-// ABI of some symbols that are not exposed directly by the IncoLightning or
-// periphery contracts, but are needed for the JS SDK.
-contract ABIHelper {
-
-    function getSession() public pure returns (Session memory) {
-        revert("This function exists only to include Session struct in ABI");
-    }
-
-}

package/src/test/EListTester.sol

@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {IIncoLightningPreview} from "../IIncoLightningPreview.sol";
-/// forge-lint: disable-next-line(unused-import)
-import {ETypes, elist} from "../TypesPreview.sol";
-import {euint256} from "@inco/lightning/src/Types.sol";
-import {IncoUtils, FEE} from "@inco/lightning/src/periphery/IncoUtils.sol";
-
-contract ElistTester is IncoUtils {
-
-    /// forge-lint: disable-next-line(screaming-snake-case-immutable)
-    IIncoLightningPreview immutable inco;
-
-    constructor(IIncoLightningPreview _inco) {
-        inco = _inco;
-    }
-
-    elist public list;
-    elist public newRangeList;
-
-    function newEList(bytes[] memory inputs, ETypes listType, address user)
-        public
-        payable
-        refundUnspent
-        returns (elist)
-    {
-        list = inco.newEList{value: FEE * inputs.length}(inputs, listType, user);
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listAppend(bytes memory ctValue) public payable refundUnspent returns (elist) {
-        euint256 handle = inco.newEuint256{value: FEE}(ctValue, msg.sender);
-        inco.allow(euint256.unwrap(handle), address(this));
-        inco.allow(euint256.unwrap(handle), address(msg.sender));
-        list = inco.listAppend(list, euint256.unwrap(handle));
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listGet(uint16 index) public returns (bytes32) {
-        bytes32 res = inco.listGet(list, index);
-        inco.allow(res, msg.sender);
-        return res;
-    }
-
-    function newEList(bytes32[] memory handles, ETypes listType) public payable refundUnspent returns (elist) {
-        list = inco.newEList(handles, listType);
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listGetOr(bytes memory ctIndex, bytes memory ctDefaultValue)
-        public
-        payable
-        refundUnspent
-        returns (bytes32)
-    {
-        euint256 index = inco.newEuint256{value: FEE}(ctIndex, msg.sender);
-        euint256 defaultValue = inco.newEuint256{value: FEE}(ctDefaultValue, msg.sender);
-        bytes32 res = inco.listGetOr(list, euint256.unwrap(index), euint256.unwrap(defaultValue));
-        inco.allow(res, msg.sender);
-        return res;
-    }
-
-    function listSet(bytes memory ctIndex, bytes memory ctValue) public payable refundUnspent returns (elist) {
-        euint256 index = inco.newEuint256{value: FEE}(ctIndex, msg.sender);
-        euint256 value = inco.newEuint256{value: FEE}(ctValue, msg.sender);
-        list = inco.listSet(list, euint256.unwrap(index), euint256.unwrap(value));
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listInsert(bytes memory ctIndex, bytes memory ctValue) public payable refundUnspent returns (elist) {
-        euint256 index = inco.newEuint256{value: FEE}(ctIndex, msg.sender);
-        euint256 value = inco.newEuint256{value: FEE}(ctValue, msg.sender);
-        list = inco.listInsert(list, euint256.unwrap(index), euint256.unwrap(value));
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listConcat(bytes[] memory cts, ETypes listType, address user)
-        public
-        payable
-        refundUnspent
-        returns (elist)
-    {
-        elist rhs = inco.newEList{value: FEE * cts.length}(cts, listType, user);
-        inco.allow(elist.unwrap(rhs), address(this));
-        inco.allow(elist.unwrap(rhs), address(msg.sender));
-        list = inco.listConcat(list, rhs);
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listSlice(bytes memory ctStart, uint16 len, bytes memory ctDefaultValue)
-        public
-        payable
-        refundUnspent
-        returns (elist)
-    {
-        euint256 start = inco.newEuint256{value: FEE}(ctStart, msg.sender);
-        euint256 defaultValue = inco.newEuint256{value: FEE}(ctDefaultValue, msg.sender);
-        list = inco.listSlice(list, euint256.unwrap(start), len, euint256.unwrap(defaultValue));
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listRange(uint16 start, uint16 end) public returns (elist) {
-        newRangeList = inco.listRange(start, end);
-        inco.allow(elist.unwrap(newRangeList), address(this));
-        inco.allow(elist.unwrap(newRangeList), address(msg.sender));
-        return newRangeList;
-    }
-
-    function listGetRange(uint16 index) public returns (bytes32) {
-        bytes32 res = inco.listGet(newRangeList, index);
-        inco.allow(res, msg.sender);
-        return res;
-    }
-
-    function listShuffle() public payable refundUnspent returns (elist) {
-        list = inco.listShuffle{value: FEE}(list);
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    function listReverse() public returns (elist) {
-        list = inco.listReverse(list);
-        inco.allow(elist.unwrap(list), address(this));
-        inco.allow(elist.unwrap(list), address(msg.sender));
-        return list;
-    }
-
-    receive() external payable {
-        // Allow contract to receive ETH
-    }
-
-}

package/src/test/PreviewIncoTest.sol

@@ -1,32 +0,0 @@
-// SPDX-License-Identifier: No License
-pragma solidity ^0.8;
-
-import {IncoTest} from "@inco/lightning/src/test/IncoTest.sol";
-import {CONTRACT_NAME, MAJOR_VERSION} from "@inco/lightning/src/version/IncoLightningConfig.sol";
-import {IncoLightningPreview} from "../IncoLightningPreview.sol";
-import {inco} from "@inco/lightning/src/Lib.sol";
-import {console} from "forge-std/console.sol";
-import {IncoLightning} from "@inco/lightning/src/IncoLightning.sol";
-
-contract PreviewIncoTest is IncoTest {
-
-    function setUp() public virtual override {
-        super.setUp();
-        bytes32 salt = getSalt(CONTRACT_NAME, MAJOR_VERSION, testDeployer, "");
-
-        IncoLightningPreview newImplem = new IncoLightningPreview(
-            // a new inco lightning instance is used a fallback implem for non preview features
-            address(new IncoLightning(salt, inco.incoVerifier())),
-            address(inco.incoVerifier())
-        );
-        vm.prank(owner);
-        inco.upgradeToAndCall(address(newImplem), "");
-        console.log("inco address is %s", vm.toString(address(inco)));
-        vm.getRecordedLogs(); // clear the upgrade log
-    }
-
-    function testExample() public pure {
-        return;
-    }
-
-}