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

package/src/Lib.template.sol

@@ -14,10 +14,10 @@ import {
     SliceOutOfRange,
     UnsupportedListType
 } from "./Types.sol";
-import {DecryptionAttestation, ElementDecryptionProof} from "./lightning-parts/DecryptionAttester.types.sol";
+import {DecryptionAttestation, ElementAttestationWithProof} from "./lightning-parts/DecryptionAttester.types.sol";
 
 // forge-lint: disable-next-line(screaming-snake-case-const)
-IncoLightning constant inco = IncoLightning(0x000000000000000000000000000000000000baBe);
+IncoLightning constant inco = IncoLightning(payable(0x000000000000000000000000000000000000baBe));
 // forge-lint: disable-next-line(screaming-snake-case-const)
 address constant deployedBy = 0x000000000000000000000000000000000000baBe;
 
@@ -700,7 +700,7 @@ library e {
 
     /// @notice Generates a random encrypted uint256 less than a plaintext upper bound (costs the inco fee)
     /// @dev costs the inco fee
-    /// @param upperBound The plaintext upper bound
+    /// @param upperBound The plaintext upper bound (exclusive). If the upper bound is 0, the whole 256bit range is sampled, equivalent to providing type(uint256).max as upper bound.
     /// @return The encrypted random value
     function randBounded(uint256 upperBound) internal returns (euint256) {
         bytes32 boundHandle = euint256.unwrap(asEuint256(upperBound));
@@ -711,7 +711,7 @@ library e {
 
     /// @notice Generates a random encrypted uint256 less than an encrypted upper bound (costs the inco fee)
     /// @dev costs the inco fee
-    /// @param upperBound The encrypted upper bound
+    /// @param upperBound The encrypted upper bound (exclusive). If the upper bound is e(0), the whole 256bit range is sampled, equivalent to providing e(type(uint256).max) as upper bound.
     /// @return The encrypted random value
     function randBounded(euint256 upperBound) internal returns (euint256) {
         bytes32 boundHandle = euint256.unwrap(s(upperBound));
@@ -741,13 +741,6 @@ library e {
         return inco.asEaddress(a);
     }
 
-    /// @notice Casts an encrypted uint256 to an encrypted bool
-    /// @param a The encrypted uint256 value
-    /// @return The encrypted bool value
-    function asEbool(euint256 a) internal returns (ebool) {
-        return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
-    }
-
     /// @notice Casts an encrypted bool to an encrypted uint256
     /// @param a The encrypted bool value
     /// @return The encrypted uint256 value
@@ -978,7 +971,7 @@ library e {
     /// @param listType Type of each element in the list.
     /// @return ret A new elist handle
     function newEList(bytes32[] memory handles, ETypes listType) internal returns (elist ret) {
-        return inco.newEList(handles, listType);
+        return inco.newEList{value: inco.getEListFee(uint16(handles.length), listType)}(handles, listType);
     }
 
     /// @notice Takes an array of user encrypted ciphertexts and returns a new elist handle.
@@ -988,7 +981,7 @@ library e {
     /// @return ret A new elist handle
     /// @dev each ciphertext costs the inco fee
     function newEList(bytes[] memory ciphertexts, ETypes listType, address user) internal returns (elist ret) {
-        return inco.newEList{value: inco.getFee() * ciphertexts.length}(ciphertexts, listType, user);
+        return inco.newEList{value: inco.getEListFee(uint16(ciphertexts.length), listType)}(ciphertexts, listType, user);
     }
 
     /// @notice Appends an ebool element at the end of a list.
@@ -996,7 +989,7 @@ library e {
     /// @param b Element value to be appended.
     /// @return ret A new elist handle with length len(a)+1.
     function append(elist a, ebool b) internal returns (elist ret) {
-        return inco.listAppend(a, ebool.unwrap(s(b)));
+        return inco.listAppend{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, ebool.unwrap(s(b)));
     }
 
     /// @notice Appends an euint256 element at the end of a list.
@@ -1004,25 +997,34 @@ library e {
     /// @param b Element value to be appended.
     /// @return ret A new elist handle with length len(a)+1.
     function append(elist a, euint256 b) internal returns (elist ret) {
-        return inco.listAppend(a, euint256.unwrap(s(b)));
+        return inco.listAppend{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, euint256.unwrap(s(b)));
     }
 
     /// @notice Replaces an element at some hidden index "i" (ebool variant).
+    /// @dev If the encrypted index is out of bounds, the operation is silently ignored
+    /// and the returned list is identical to the input. This avoids leaking index validity.
     /// @param a EList handle to modify element in.
     /// @param i Hidden index position of an element to modify.
     /// @param b Element value to be changed.
     /// @return ret A new elist handle
     function set(elist a, euint256 i, ebool b) internal returns (elist ret) {
-        return inco.listSet(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+        return
+            inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(
+                a, euint256.unwrap(s(i)), ebool.unwrap(s(b))
+            );
     }
 
     /// @notice Replaces an element at some hidden index "i" (euint256 variant).
+    /// @dev If the encrypted index is out of bounds, the operation is silently ignored
+    /// and the returned list is identical to the input. This avoids leaking index validity.
     /// @param a EList handle to modify element in.
     /// @param i Hidden index position of an element to modify.
     /// @param b Element value to be changed.
     /// @return ret A new elist handle
     function set(elist a, euint256 i, euint256 b) internal returns (elist ret) {
-        return inco.listSet(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+        return inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(
+            a, euint256.unwrap(s(i)), euint256.unwrap(s(b))
+        );
     }
 
     /// @notice Replaces an element at plaintext index "i" (ebool variant). Reverts if out of range.
@@ -1032,7 +1034,9 @@ library e {
     /// @return ret A new elist handle
     function set(elist a, uint16 i, ebool b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+        return inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(
+            a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b))
+        );
     }
 
     /// @notice Replaces an element at plaintext index "i" (euint256 variant). Reverts if out of range.
@@ -1042,7 +1046,9 @@ library e {
     /// @return ret A new elist handle
     function set(elist a, uint16 i, euint256 b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+        return inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(
+            a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b))
+        );
     }
 
     /// @notice Return hidden element at some hidden position (ebool variant).
@@ -1085,7 +1091,9 @@ library e {
     /// @param b Element value to be inserted.
     /// @return ret A new elist handle with length len(a)+1.
     function insert(elist a, euint256 i, ebool b) internal returns (elist ret) {
-        return inco.listInsert(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(
+            a, euint256.unwrap(s(i)), ebool.unwrap(s(b))
+        );
     }
 
     /// @notice Inserts an ebool element at a known position. Reverts if out of range.
@@ -1095,7 +1103,9 @@ library e {
     /// @return ret A new elist handle with length len(a)+1.
     function insert(elist a, uint16 i, ebool b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(
+            a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b))
+        );
     }
 
     /// @notice Inserts a hidden element at a desired hidden position (euint256, hidden index).
@@ -1104,7 +1114,9 @@ library e {
     /// @param b Element value to be inserted.
     /// @return ret A new elist handle with length len(a)+1.
     function insert(elist a, euint256 i, euint256 b) internal returns (elist ret) {
-        return inco.listInsert(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(
+            a, euint256.unwrap(s(i)), euint256.unwrap(s(b))
+        );
     }
 
     /// @notice Inserts a euint256 element at a known position. Reverts if out of range.
@@ -1114,7 +1126,9 @@ library e {
     /// @return ret A new elist handle with length len(a)+1.
     function insert(elist a, uint16 i, euint256 b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(
+            a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b))
+        );
     }
 
     /// @notice Concatenates two elists into one.
@@ -1122,7 +1136,7 @@ library e {
     /// @param b EList handle to be appended
     /// @return ret A new elist handle with length len(a)+len(b).
     function concat(elist a, elist b) internal returns (elist ret) {
-        return inco.listConcat(a, b);
+        return inco.listConcat{value: inco.getEListFee(length(a) + length(b), listTypeOf(a))}(a, b);
     }
 
     /// @notice Slices a list from plaintext start to plaintext end.
@@ -1142,7 +1156,9 @@ library e {
         } else {
             revert UnsupportedListType(listTypeOf(a));
         }
-        return inco.listSlice(a, euint256.unwrap(asEuint256(start)), end - start, defaultValue);
+        return inco.listSlice{value: inco.getEListFee(end - start, listTypeOf(a))}(
+            a, euint256.unwrap(asEuint256(start)), end - start, defaultValue
+        );
     }
 
     /// @notice Slices at a hidden index with a specified length (euint256 default).
@@ -1152,7 +1168,9 @@ library e {
     /// @param defaultValue Default value if out of range.
     /// @return ret A new sliced list with length "len".
     function sliceLen(elist a, euint256 start, uint16 len, euint256 defaultValue) internal returns (elist ret) {
-        return inco.listSlice(a, euint256.unwrap(s(start)), len, euint256.unwrap(s(defaultValue)));
+        return inco.listSlice{value: inco.getEListFee(len, listTypeOf(a))}(
+            a, euint256.unwrap(s(start)), len, euint256.unwrap(s(defaultValue))
+        );
     }
 
     /// @notice Slices at a hidden index with a specified length (ebool default).
@@ -1162,7 +1180,9 @@ library e {
     /// @param defaultValue Default value if out of range.
     /// @return ret A new sliced list with length "len".
     function sliceLen(elist a, euint256 start, uint16 len, ebool defaultValue) internal returns (elist ret) {
-        return inco.listSlice(a, euint256.unwrap(s(start)), len, ebool.unwrap(s(defaultValue)));
+        return inco.listSlice{value: inco.getEListFee(len, listTypeOf(a))}(
+            a, euint256.unwrap(s(start)), len, ebool.unwrap(s(defaultValue))
+        );
     }
 
     /// @notice Creates a new list populated with ordered values from within range.
@@ -1170,7 +1190,7 @@ library e {
     /// @param end End of the range, exclusive. Must be >= start.
     /// @return ret A new elist handle with length "end-start"
     function range(uint16 start, uint16 end) internal returns (elist ret) {
-        return inco.listRange(start, end);
+        return inco.listRange{value: inco.getEListFee(end - start, ETypes.Uint256)}(start, end);
     }
 
     /// @notice Deterministically shuffles elements within a list.
@@ -1178,8 +1198,7 @@ library e {
     /// @param a elist handle to be shuffled
     /// @return ret A new elist handle with elements shuffled
     function shuffle(elist a) internal returns (elist ret) {
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, a));
-        return elist.wrap(result);
+        return inco.listShuffle{value: inco.getEListFee(length(a), listTypeOf(a))}(a);
     }
 
     /// @notice A convenience function equivalent to range() followed by shuffle().
@@ -1188,16 +1207,16 @@ library e {
     /// @param end End of the range, exclusive. Must be >= start.
     /// @return ret A new elist handle in random order with length "end-start".
     function shuffledRange(uint16 start, uint16 end) internal returns (elist ret) {
-        elist rangeList = inco.listRange(start, end);
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, rangeList));
-        return elist.wrap(result);
+        uint256 fee = inco.getEListFee(end - start, ETypes.Uint256);
+        elist rangeList = inco.listRange{value: fee}(start, end);
+        return inco.listShuffle{value: fee}(rangeList);
     }
 
     /// @notice Reverses the order of elements in a list.
     /// @param a Elist handle to be reversed
     /// @return ret A new elist handle with elements in reverse order
     function reverse(elist a) internal returns (elist ret) {
-        return inco.listReverse(a);
+        return inco.listReverse{value: inco.getEListFee(length(a), listTypeOf(a))}(a);
     }
 
     /// @notice Returns the length of the list in plaintext. Pure function, no gas cost.
@@ -1218,7 +1237,7 @@ library e {
      */
     function verifyEListDecryption(
         elist elistHandle,
-        ElementDecryptionProof[] memory proofElements,
+        ElementAttestationWithProof[] memory proofElements,
         bytes32 proof,
         bytes[] memory signatures
     ) internal view returns (bool) {

package/src/Lib.testnet.sol

@@ -7,9 +7,9 @@ pragma solidity ^0.8;
 
 import { IncoLightning } from "./IncoLightning.sol";
 import { ebool, euint256, eaddress, ETypes, elist, IndexOutOfRange, InvalidRange, SliceOutOfRange, UnsupportedListType } from "./Types.sol";
-import { DecryptionAttestation, ElementDecryptionProof } from "./lightning-parts/DecryptionAttester.types.sol";
+import { DecryptionAttestation, ElementAttestationWithProof } from "./lightning-parts/DecryptionAttester.types.sol";
 
-IncoLightning constant inco = IncoLightning(0x168FDc3Ae19A5d5b03614578C58974FF30FCBe92);
+IncoLightning constant inco = IncoLightning(payable(0x168FDc3Ae19A5d5b03614578C58974FF30FCBe92));
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
 
 /// @notice Returns the ETypes enum value encoded in a handle
@@ -693,7 +693,7 @@ library e {
 
     /// @notice Generates a random encrypted uint256 less than a plaintext upper bound (costs the inco fee)
     ///  @dev costs the inco fee
-    ///  @param upperBound The plaintext upper bound
+    ///  @param upperBound The plaintext upper bound (exclusive). If the upper bound is 0, the whole 256bit range is sampled, equivalent to providing type(uint256).max as upper bound.
     ///  @return The encrypted random value
     function randBounded(uint256 upperBound) internal returns (euint256) {
         bytes32 boundHandle = euint256.unwrap(asEuint256(upperBound));
@@ -703,7 +703,7 @@ library e {
 
     /// @notice Generates a random encrypted uint256 less than an encrypted upper bound (costs the inco fee)
     ///  @dev costs the inco fee
-    ///  @param upperBound The encrypted upper bound
+    ///  @param upperBound The encrypted upper bound (exclusive). If the upper bound is e(0), the whole 256bit range is sampled, equivalent to providing e(type(uint256).max) as upper bound.
     ///  @return The encrypted random value
     function randBounded(euint256 upperBound) internal returns (euint256) {
         bytes32 boundHandle = euint256.unwrap(s(upperBound));
@@ -732,13 +732,6 @@ library e {
         return inco.asEaddress(a);
     }
 
-    /// @notice Casts an encrypted uint256 to an encrypted bool
-    ///  @param a The encrypted uint256 value
-    ///  @return The encrypted bool value
-    function asEbool(euint256 a) internal returns (ebool) {
-        return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
-    }
-
     /// @notice Casts an encrypted bool to an encrypted uint256
     ///  @param a The encrypted bool value
     ///  @return The encrypted uint256 value
@@ -959,7 +952,7 @@ library e {
     ///  @param listType Type of each element in the list.
     ///  @return ret A new elist handle
     function newEList(bytes32[] memory handles, ETypes listType) internal returns (elist ret) {
-        return inco.newEList(handles, listType);
+        return inco.newEList{value: inco.getEListFee(uint16(handles.length), listType)}(handles, listType);
     }
 
     /// @notice Takes an array of user encrypted ciphertexts and returns a new elist handle.
@@ -969,7 +962,7 @@ library e {
     ///  @return ret A new elist handle
     ///  @dev each ciphertext costs the inco fee
     function newEList(bytes[] memory ciphertexts, ETypes listType, address user) internal returns (elist ret) {
-        return inco.newEList{value: inco.getFee() * ciphertexts.length}(ciphertexts, listType, user);
+        return inco.newEList{value: inco.getEListFee(uint16(ciphertexts.length), listType)}(ciphertexts, listType, user);
     }
 
     /// @notice Appends an ebool element at the end of a list.
@@ -977,7 +970,7 @@ library e {
     ///  @param b Element value to be appended.
     ///  @return ret A new elist handle with length len(a)+1.
     function append(elist a, ebool b) internal returns (elist ret) {
-        return inco.listAppend(a, ebool.unwrap(s(b)));
+        return inco.listAppend{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, ebool.unwrap(s(b)));
     }
 
     /// @notice Appends an euint256 element at the end of a list.
@@ -985,25 +978,29 @@ library e {
     ///  @param b Element value to be appended.
     ///  @return ret A new elist handle with length len(a)+1.
     function append(elist a, euint256 b) internal returns (elist ret) {
-        return inco.listAppend(a, euint256.unwrap(s(b)));
+        return inco.listAppend{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, euint256.unwrap(s(b)));
     }
 
     /// @notice Replaces an element at some hidden index "i" (ebool variant).
+    ///  @dev If the encrypted index is out of bounds, the operation is silently ignored
+    ///  and the returned list is identical to the input. This avoids leaking index validity.
     ///  @param a EList handle to modify element in.
     ///  @param i Hidden index position of an element to modify.
     ///  @param b Element value to be changed.
     ///  @return ret A new elist handle
     function set(elist a, euint256 i, ebool b) internal returns (elist ret) {
-        return inco.listSet(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+        return inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
     }
 
     /// @notice Replaces an element at some hidden index "i" (euint256 variant).
+    ///  @dev If the encrypted index is out of bounds, the operation is silently ignored
+    ///  and the returned list is identical to the input. This avoids leaking index validity.
     ///  @param a EList handle to modify element in.
     ///  @param i Hidden index position of an element to modify.
     ///  @param b Element value to be changed.
     ///  @return ret A new elist handle
     function set(elist a, euint256 i, euint256 b) internal returns (elist ret) {
-        return inco.listSet(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+        return inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
     }
 
     /// @notice Replaces an element at plaintext index "i" (ebool variant). Reverts if out of range.
@@ -1013,7 +1010,7 @@ library e {
     ///  @return ret A new elist handle
     function set(elist a, uint16 i, ebool b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+        return inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
     }
 
     /// @notice Replaces an element at plaintext index "i" (euint256 variant). Reverts if out of range.
@@ -1023,7 +1020,7 @@ library e {
     ///  @return ret A new elist handle
     function set(elist a, uint16 i, euint256 b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listSet(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+        return inco.listSet{value: inco.getEListFee(length(a), listTypeOf(a))}(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
     }
 
     /// @notice Return hidden element at some hidden position (ebool variant).
@@ -1066,7 +1063,7 @@ library e {
     ///  @param b Element value to be inserted.
     ///  @return ret A new elist handle with length len(a)+1.
     function insert(elist a, euint256 i, ebool b) internal returns (elist ret) {
-        return inco.listInsert(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, euint256.unwrap(s(i)), ebool.unwrap(s(b)));
     }
 
     /// @notice Inserts an ebool element at a known position. Reverts if out of range.
@@ -1076,7 +1073,7 @@ library e {
     ///  @return ret A new elist handle with length len(a)+1.
     function insert(elist a, uint16 i, ebool b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, euint256.unwrap(asEuint256(uint256(i))), ebool.unwrap(s(b)));
     }
 
     /// @notice Inserts a hidden element at a desired hidden position (euint256, hidden index).
@@ -1085,7 +1082,7 @@ library e {
     ///  @param b Element value to be inserted.
     ///  @return ret A new elist handle with length len(a)+1.
     function insert(elist a, euint256 i, euint256 b) internal returns (elist ret) {
-        return inco.listInsert(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, euint256.unwrap(s(i)), euint256.unwrap(s(b)));
     }
 
     /// @notice Inserts a euint256 element at a known position. Reverts if out of range.
@@ -1095,7 +1092,7 @@ library e {
     ///  @return ret A new elist handle with length len(a)+1.
     function insert(elist a, uint16 i, euint256 b) internal returns (elist ret) {
         require(i < length(a), IndexOutOfRange(i, length(a)));
-        return inco.listInsert(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
+        return inco.listInsert{value: inco.getEListFee(length(a) + 1, listTypeOf(a))}(a, euint256.unwrap(asEuint256(uint256(i))), euint256.unwrap(s(b)));
     }
 
     /// @notice Concatenates two elists into one.
@@ -1103,7 +1100,7 @@ library e {
     ///  @param b EList handle to be appended
     ///  @return ret A new elist handle with length len(a)+len(b).
     function concat(elist a, elist b) internal returns (elist ret) {
-        return inco.listConcat(a, b);
+        return inco.listConcat{value: inco.getEListFee(length(a) + length(b), listTypeOf(a))}(a, b);
     }
 
     /// @notice Slices a list from plaintext start to plaintext end.
@@ -1123,7 +1120,7 @@ library e {
         } else {
             revert UnsupportedListType(listTypeOf(a));
         }
-        return inco.listSlice(a, euint256.unwrap(asEuint256(start)), end - start, defaultValue);
+        return inco.listSlice{value: inco.getEListFee(end - start, listTypeOf(a))}(a, euint256.unwrap(asEuint256(start)), end - start, defaultValue);
     }
 
     /// @notice Slices at a hidden index with a specified length (euint256 default).
@@ -1133,7 +1130,7 @@ library e {
     ///  @param defaultValue Default value if out of range.
     ///  @return ret A new sliced list with length "len".
     function sliceLen(elist a, euint256 start, uint16 len, euint256 defaultValue) internal returns (elist ret) {
-        return inco.listSlice(a, euint256.unwrap(s(start)), len, euint256.unwrap(s(defaultValue)));
+        return inco.listSlice{value: inco.getEListFee(len, listTypeOf(a))}(a, euint256.unwrap(s(start)), len, euint256.unwrap(s(defaultValue)));
     }
 
     /// @notice Slices at a hidden index with a specified length (ebool default).
@@ -1143,7 +1140,7 @@ library e {
     ///  @param defaultValue Default value if out of range.
     ///  @return ret A new sliced list with length "len".
     function sliceLen(elist a, euint256 start, uint16 len, ebool defaultValue) internal returns (elist ret) {
-        return inco.listSlice(a, euint256.unwrap(s(start)), len, ebool.unwrap(s(defaultValue)));
+        return inco.listSlice{value: inco.getEListFee(len, listTypeOf(a))}(a, euint256.unwrap(s(start)), len, ebool.unwrap(s(defaultValue)));
     }
 
     /// @notice Creates a new list populated with ordered values from within range.
@@ -1151,7 +1148,7 @@ library e {
     ///  @param end End of the range, exclusive. Must be >= start.
     ///  @return ret A new elist handle with length "end-start"
     function range(uint16 start, uint16 end) internal returns (elist ret) {
-        return inco.listRange(start, end);
+        return inco.listRange{value: inco.getEListFee(end - start, ETypes.Uint256)}(start, end);
     }
 
     /// @notice Deterministically shuffles elements within a list.
@@ -1159,8 +1156,7 @@ library e {
     ///  @param a elist handle to be shuffled
     ///  @return ret A new elist handle with elements shuffled
     function shuffle(elist a) internal returns (elist ret) {
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, a));
-        return elist.wrap(result);
+        return inco.listShuffle{value: inco.getEListFee(length(a), listTypeOf(a))}(a);
     }
 
     /// @notice A convenience function equivalent to range() followed by shuffle().
@@ -1169,16 +1165,16 @@ library e {
     ///  @param end End of the range, exclusive. Must be >= start.
     ///  @return ret A new elist handle in random order with length "end-start".
     function shuffledRange(uint16 start, uint16 end) internal returns (elist ret) {
-        elist rangeList = inco.listRange(start, end);
-        bytes32 result = _callWithFeeRetry(abi.encodeWithSelector(inco.listShuffle.selector, rangeList));
-        return elist.wrap(result);
+        uint256 fee = inco.getEListFee(end - start, ETypes.Uint256);
+        elist rangeList = inco.listRange{value: fee}(start, end);
+        return inco.listShuffle{value: fee}(rangeList);
     }
 
     /// @notice Reverses the order of elements in a list.
     ///  @param a Elist handle to be reversed
     ///  @return ret A new elist handle with elements in reverse order
     function reverse(elist a) internal returns (elist ret) {
-        return inco.listReverse(a);
+        return inco.listReverse{value: inco.getEListFee(length(a), listTypeOf(a))}(a);
     }
 
     /// @notice Returns the length of the list in plaintext. Pure function, no gas cost.
@@ -1195,7 +1191,7 @@ library e {
     ///  @param signatures Array of signatures from attesters
     ///  @return bool True if verification succeeds
     ///  @dev For privacy, publish only pairHash. For transparency, publish commitment+value. Can mix both in the same array.
-    function verifyEListDecryption(elist elistHandle, ElementDecryptionProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
+    function verifyEListDecryption(elist elistHandle, ElementAttestationWithProof[] memory proofElements, bytes32 proof, bytes[] memory signatures) internal view returns (bool) {
         return inco.incoVerifier().isValidEListDecryptionAttestation(elist.unwrap(elistHandle), proofElements, proof, signatures);
     }
 }

package/src/Types.sol

@@ -246,15 +246,24 @@ function isTypeSupported(ETypes t) pure returns (bool) {
     return t == ETypes.Uint256 || t == ETypes.Bool || t == ETypes.AddressOrUint160OrBytes20;
 }
 
+/// Checks whether we can cast to the given type
+/// @param t the type to check
+/// @dev Casting to ebool is not supported in order to not confuse developers coming from other languages where anything above 0 becomes true.
+function canCastTo(ETypes t) pure returns (bool) {
+    return t == ETypes.Uint256 || t == ETypes.AddressOrUint160OrBytes20;
+}
+
 error SenderNotAllowedForHandle(bytes32 handle, address sender);
 error SharerNotAllowedForHandle(bytes32 handle, address sharer);
 error IndexOutOfRange(uint16 i, uint16 len);
 error SliceOutOfRange(uint16 start, uint16 end, uint16 len);
 error ZeroLength();
+error ListTooLong(uint32 provided, uint16 max);
 error InvalidRange(uint16 start, uint16 end);
 error ListTypeMismatch(ETypes lhs, ETypes rhs);
 error UnsupportedListType(ETypes listType);
 error UnsupportedType(ETypes actual);
+error UnexpectedType(ETypes actual, bytes32 expectedTypes);
 
 string constant EVM_HOST_CHAIN_PREFIX = "evm/";
 uint8 constant HANDLE_VERSION = 0;
@@ -268,6 +277,15 @@ bytes32 constant ALLOWANCE_GRANTED_MAGIC_VALUE = keccak256("Inco Read Access on
 // NOTE: this must be a uint8 to get hash agreement!
 uint8 constant HANDLE_INDEX = 0;
 
+/// Returns the bit size of a supported element type.
+/// @param t the type to get the bit size for
+function typeBitSize(ETypes t) pure returns (uint256) {
+    if (t == ETypes.Bool) return 1;
+    if (t == ETypes.AddressOrUint160OrBytes20) return 160;
+    if (t == ETypes.Uint256) return 256;
+    revert UnsupportedType(t);
+}
+
 /// Util function to convert an ETypes to a bit mask
 /// @param t the type to convert to a bit mask
 function typeToBitMask(ETypes t) pure returns (bytes32) {

package/src/interfaces/IIncoLightning.sol

@@ -7,6 +7,8 @@ import {IVersion} from "../version/interfaces/IVersion.sol";
 
 interface IIncoLightning is ITrivialEncryption, IEList, IVersion {
 
+    error EthInboundTransferUnsupported();
+
     function initialize(address owner) external;
 
     function withdrawFees() external;