@inco/lightning-preview 0.7.9

package/README.md

@@ -0,0 +1,3 @@
+# Inco Lightning Preview
+
+Reproducing the Inco Lightning file structure, here are the not yet public features fro Inco Lightning.

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@inco/lightning-preview",
+  "version": "0.7.9",
+  "repository": "https://github.com/Inco-fhevm/inco-monorepo",
+  "files": [
+    "src/",
+    "remappings.txt"
+  ],
+  "scripts": {
+    "lint": "forge lint && forge fmt --check",
+    "lint:fix": "forge fmt",
+    "build": "forge build",
+    "publish:github": "bun publish --registry=https://npm.pkg.github.com",
+    "publish:npm": "bun publish --access public"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com"
+  },
+  "dependencies": {
+    "@inco/lightning": "0.0.0",
+    "@openzeppelin/contracts": "^5.3.0",
+    "@openzeppelin/contracts-upgradeable": "^5.3.0",
+    "ds-test": "https://github.com/dapphub/ds-test",
+    "forge-std": "https://github.com/foundry-rs/forge-std"
+  }
+}

package/remappings.txt

@@ -0,0 +1,9 @@
+@openzeppelin/=../../node_modules/@openzeppelin/
+forge-std/=../../node_modules/forge-std/src/
+ds-test/=../../node_modules/ds-test/src/
+automata-dcap-attestation/=../../node_modules/automata-dcap-attestation/evm/contracts/
+@automata-network/dcap-attestation/=../../node_modules/automata-dcap-attestation/evm/contracts/
+automata-on-chain-pccs/=../../node_modules/automata-on-chain-pccs/src/
+@automata-network/on-chain-pccs/=../../node_modules/automata-on-chain-pccs/src/
+@inco/=../
+solady/=../../node_modules/solady/src/

package/src/IIncoLightningPreview.sol

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

package/src/IncoLightningPreview.sol

@@ -0,0 +1,66 @@
+// 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";
+
+contract IncoLightningPreview is EList, UUPSUpgradeable, Version, OwnableUpgradeable {
+
+    IncoLightning private immutable LIGHTNING;
+
+    // Note passing in address rather than IncoLightning directly since the contracts mismatch due to different
+    // remappings
+    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);
+    }
+
+    function includesPreviewFeatures() public pure returns (bool) {
+        return true;
+    }
+
+    function _authorizeUpgrade(address) internal view override {
+        require(msg.sender == owner());
+    }
+
+    function initialize(address owner) public initializer {
+        __Ownable_init(owner);
+    }
+
+    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

@@ -0,0 +1,316 @@
+// 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) public 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) public 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) external 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) external 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) external 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) external 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) external 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) external returns (elist ret) {
+        return incoPreview.listShuffle(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) external returns (elist ret) {
+        return incoPreview.listShuffle(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) external 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) public pure returns (uint16 len) {
+        return incoPreview.lengthOf(elist.unwrap(a));
+    }
+
+}

package/src/PreviewDeployUtils.sol

@@ -0,0 +1,50 @@
+// 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";
+
+contract PreviewDeployUtils is DeployUtils {
+
+    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
+                )
+            })
+        );
+    }
+
+    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

@@ -0,0 +1,18 @@
+// 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

@@ -0,0 +1,232 @@
+// 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";
+
+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);
+
+    function newEListFromInputs(bytes[] memory 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);
+    }
+
+    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);
+    }
+
+    function newEList(bytes32[] memory handles, ETypes listType) external returns (elist newList) {
+        return newEListFromHandles(handles, listType);
+    }
+
+    function newEList(bytes[] memory inputs, ETypes listType, address user)
+        external
+        payable
+        payingMultiple(inputs.length)
+        returns (elist newList)
+    {
+        return newEListFromInputs(inputs, listType, user);
+    }
+
+    function elementTypeOf(bytes32 handle) internal pure returns (ETypes) {
+        return ETypes(uint8(uint256(handle) >> 16));
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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());
+    }
+
+    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

@@ -0,0 +1,33 @@
+/// 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[] memory 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

@@ -0,0 +1,37 @@
+// 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";
+
+contract EListHandleGeneration is HandleGeneration, EListHandleMetadata {
+
+    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);
+    }
+
+    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

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {ETypes} from "@inco/lightning/src/Types.sol";
+import {IEListHandleMetadata} from "./interfaces/IEListHandleMetadata.sol";
+
+contract EListHandleMetadata is IEListHandleMetadata {
+
+    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
+    }
+
+    function lengthOf(bytes32 handle) public pure returns (uint16) {
+        return uint16(uint256(handle) >> 24);
+    }
+
+    function embedListType(bytes32 prehandle, ETypes listType) internal pure returns (bytes32 result) {
+        result = prehandle & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffff;
+        result = bytes32(uint256(result) | (uint256(listType) << 16)); // append element type
+    }
+
+    function listTypeOf(bytes32 handle) internal pure returns (ETypes) {
+        return ETypes(uint8(uint256(handle) >> 16));
+    }
+
+}

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

@@ -0,0 +1,8 @@
+/// 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

@@ -0,0 +1,66 @@
+// 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

@@ -0,0 +1,15 @@
+// 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

@@ -0,0 +1,148 @@
+// 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 {Fee, FEE} from "@inco/lightning/src/lightning-parts/Fee.sol";
+
+contract ElistTester is Fee {
+
+    /// 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

@@ -0,0 +1,32 @@
+// 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;
+    }
+
+}