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

package/src/lightning-parts/EList.sol

@@ -5,10 +5,12 @@ import {
     ETypes,
     EOps,
     typeToBitMask,
+    typeBitSize,
     isTypeSupported,
     IndexOutOfRange,
     InvalidRange,
     ListTypeMismatch,
+    ListTooLong,
     UnsupportedType,
     elist
 } from "../Types.sol";
@@ -17,6 +19,9 @@ import {EncryptedInput} from "./EncryptedInput.sol";
 import {EListHandleGeneration} from "./primitives/EListHandleGeneration.sol";
 import {IEList} from "./interfaces/IEList.sol";
 
+/// @dev Maximum number of elements allowed in an encrypted list.
+uint16 constant MAX_LIST_LENGTH = type(uint16).max;
+
 /// @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.
@@ -45,6 +50,11 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     event EListShuffle(elist indexed list, uint256 indexed counter, elist indexed result, uint256 eventId);
     event EListReverse(elist indexed list, elist indexed result, uint256 eventId);
 
+    /// @dev Returns the total bit size of an elist: length * typeBitSize(elementType).
+    function _elistBits(bytes32 handle) internal pure returns (uint256) {
+        return uint256(lengthOf(handle)) * typeBitSize(listTypeOf(handle));
+    }
+
     /// @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.
@@ -56,6 +66,7 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
         internal
         returns (elist newList)
     {
+        require(inputs.length <= MAX_LIST_LENGTH, ListTooLong(uint32(inputs.length), MAX_LIST_LENGTH));
         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.
@@ -73,6 +84,7 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @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(handles.length <= MAX_LIST_LENGTH, ListTooLong(uint32(handles.length), MAX_LIST_LENGTH));
         require(isTypeSupported(listType), UnsupportedType(listType));
         for (uint256 i = 0; i < handles.length; i++) {
             checkInput(handles[i], typeToBitMask(listType));
@@ -81,9 +93,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
         bytes32 newHandle = createListInputHandle(handles, listType);
 
         allowTransientInternal(newHandle, msg.sender);
-
-        emit NewEList(newHandle, listType, handles, getNewEventId());
-
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(newHandle, id));
+        emit NewEList(newHandle, listType, handles, id);
         return elist.wrap(newHandle);
     }
 
@@ -92,7 +104,12 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @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) {
+    function newEList(bytes32[] memory handles, ETypes listType)
+        external
+        payable
+        payingElistFee(uint256(handles.length) * typeBitSize(listType))
+        returns (elist newList)
+    {
         return newEListFromHandles(handles, listType);
     }
 
@@ -105,7 +122,7 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     function newEList(bytes[] calldata inputs, ETypes listType, address user)
         external
         payable
-        payingMultiple(inputs.length)
+        payingElistFee(uint256(inputs.length) * typeBitSize(listType))
         returns (elist newList)
     {
         return newEListFromInputs(inputs, listType, user);
@@ -124,7 +141,12 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @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) {
+    function listAppend(elist list, bytes32 value)
+        external
+        payable
+        payingElistFee(_elistBits(elist.unwrap(list)) + typeBitSize(listTypeOf(elist.unwrap(list))))
+        returns (elist result)
+    {
         checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
         checkInput(value, typeToBitMask(listTypeOf(elist.unwrap(list))));
 
@@ -136,8 +158,10 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
                 abi.encodePacked(elist.unwrap(list), value)
             )
         );
+        uint256 id = getNextEventId();
         allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListAppend(list, value, result, getNewEventId());
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListAppend(list, value, result, id);
     }
 
     /// @notice Retrieves an encrypted element at a specific index.
@@ -151,7 +175,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
 
         result =
             createResultHandle(EOps.EListGet, listTypeOf(elist.unwrap(list)), abi.encodePacked(elist.unwrap(list), i));
-        emit EListGet(list, i, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(result, id));
+        emit EListGet(list, i, result, id);
     }
 
     /// @notice Retrieves an encrypted element at an encrypted index, with a default value for out-of-range access.
@@ -168,17 +194,27 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
         result = createResultHandle(
             EOps.EListGetOr, listTypeOf(elist.unwrap(list)), abi.encodePacked(elist.unwrap(list), index, defaultValue)
         );
-        emit EListGetOr(list, index, defaultValue, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(result, id));
+        emit EListGetOr(list, index, defaultValue, result, id);
     }
 
     /// @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.
+    /// Index must be euint256. If the encrypted index is out of bounds, the operation
+    /// is silently ignored by the covalidator and the returned list is identical to the input.
+    /// This is by design: because the index is encrypted, reverting would leak information
+    /// about whether the index was valid.
     /// @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) {
+    /// @return result A new encrypted list with the element replaced, or unchanged if index is out of bounds.
+    function listSet(elist list, bytes32 index, bytes32 value)
+        external
+        payable
+        payingElistFee(_elistBits(elist.unwrap(list)))
+        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))));
@@ -192,7 +228,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
             )
         );
         allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListSet(list, index, value, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListSet(list, index, value, result, id);
     }
 
     /// @notice Inserts an encrypted element at an encrypted index, shifting subsequent elements.
@@ -201,7 +239,12 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @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) {
+    function listInsert(elist list, bytes32 index, bytes32 value)
+        external
+        payable
+        payingElistFee(_elistBits(elist.unwrap(list)) + typeBitSize(listTypeOf(elist.unwrap(list))))
+        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))));
@@ -215,7 +258,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
             )
         );
         allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListInsert(list, index, value, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListInsert(list, index, value, result, id);
     }
 
     /// @notice Concatenates two encrypted lists into a new list.
@@ -223,7 +268,12 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @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) {
+    function listConcat(elist lhs, elist rhs)
+        external
+        payable
+        payingElistFee(_elistBits(elist.unwrap(lhs)) + _elistBits(elist.unwrap(rhs)))
+        returns (elist result)
+    {
         checkInput(elist.unwrap(lhs), typeToBitMask(ETypes.List));
         checkInput(elist.unwrap(rhs), typeToBitMask(ETypes.List));
         ETypes lhsType = listTypeOf(elist.unwrap(lhs));
@@ -239,7 +289,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
             )
         );
         allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListConcat(lhs, rhs, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListConcat(lhs, rhs, result, id);
     }
 
     /// @notice Extracts a slice from an encrypted list starting at an encrypted index.
@@ -249,7 +301,12 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @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) {
+    function listSlice(elist list, bytes32 start, uint16 len, bytes32 defaultValue)
+        external
+        payable
+        payingElistFee(uint256(len) * typeBitSize(listTypeOf(elist.unwrap(list))))
+        returns (elist result)
+    {
         checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
         checkInput(defaultValue, typeToBitMask(listTypeOf(elist.unwrap(list))));
         checkInput(start, typeToBitMask(ETypes.Uint256));
@@ -263,7 +320,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
             )
         );
         allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListSlice(list, start, len, defaultValue, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListSlice(list, start, len, defaultValue, result, id);
     }
 
     /// @notice Creates an encrypted list containing a range of encrypted integers.
@@ -271,14 +330,21 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// @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) {
+    function listRange(uint16 start, uint16 end)
+        external
+        payable
+        payingElistFee(uint256(end - start) * typeBitSize(ETypes.Uint256))
+        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());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListRange(start, end, result, id);
     }
 
     /// @notice Randomly shuffles the elements of an encrypted list.
@@ -286,7 +352,12 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
     /// 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) {
+    function listShuffle(elist list)
+        external
+        payable
+        payingElistFee(_elistBits(elist.unwrap(list)))
+        returns (elist result)
+    {
         checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
         randCounter++;
         result = elist.wrap(
@@ -298,14 +369,21 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
             )
         );
         allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListShuffle(list, randCounter, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListShuffle(list, randCounter, result, id);
     }
 
     /// @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) {
+    function listReverse(elist list)
+        external
+        payable
+        payingElistFee(_elistBits(elist.unwrap(list)))
+        returns (elist result)
+    {
         checkInput(elist.unwrap(list), typeToBitMask(ETypes.List));
 
         result = elist.wrap(
@@ -317,7 +395,9 @@ abstract contract EList is IEList, EncryptedOperations, EncryptedInput, EListHan
             )
         );
         allowTransientInternal(elist.unwrap(result), msg.sender);
-        emit EListReverse(list, result, getNewEventId());
+        uint256 id = getNextEventId();
+        setDigest(abi.encodePacked(elist.unwrap(result), id));
+        emit EListReverse(list, result, id);
     }
 
 }

package/src/lightning-parts/EncryptedOperations.sol

@@ -1,7 +1,16 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {euint256, ebool, EOps, SenderNotAllowedForHandle, ETypes, isTypeSupported, typeToBitMask} from "../Types.sol";
+import {
+    euint256,
+    ebool,
+    EOps,
+    SenderNotAllowedForHandle,
+    ETypes,
+    isTypeSupported,
+    canCastTo,
+    typeToBitMask
+} from "../Types.sol";
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
 import {IEncryptedOperations} from "./interfaces/IEncryptedOperations.sol";
@@ -135,7 +144,7 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     }
 
     /// @notice Divides one encrypted uint256 by another.
-    /// @dev Division by zero returns zero.
+    /// @dev Division by zero returns encrypted type(uint256).max.
     /// @param lhs The dividend (encrypted).
     /// @param rhs The divisor (encrypted).
     /// @return result The encrypted quotient (lhs / rhs).
@@ -149,7 +158,7 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     }
 
     /// @notice Computes the remainder of dividing one encrypted uint256 by another.
-    /// @dev Remainder by zero returns zero.
+    /// @dev Remainder by zero returns the encrypted dividend (lhs).
     /// @param lhs The dividend (encrypted).
     /// @param rhs The divisor (encrypted).
     /// @return result The encrypted remainder (lhs % rhs).
@@ -382,13 +391,13 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
     }
 
     /// @notice Casts an encrypted value to a different encrypted type.
-    /// @dev Supports casting between euint256, ebool, and eaddress.
+    /// @dev Supports casting to euint256 and eaddress. Casting to ebool is not supported, only from ebool to a larger type.
     /// @param ct The encrypted value to cast.
     /// @param toType The target type to cast to.
     /// @return result The casted encrypted value.
     function eCast(bytes32 ct, ETypes toType) external returns (bytes32 result) {
         checkInput(ct, SUPPORTED_TYPES_MASK);
-        require(isTypeSupported(toType), UnsupportedType(toType));
+        require(canCastTo(toType), UnsupportedType(toType));
         result = createResultHandle(EOps.Cast, toType, abi.encodePacked(ct));
         allowTransientInternal(result, msg.sender);
         uint256 id = getNextEventId();
@@ -411,12 +420,13 @@ abstract contract EncryptedOperations is IEncryptedOperations, BaseAccessControl
 
     /// @notice Generates an encrypted random value bounded by an upper limit.
     /// @dev This is a paid operation. The result is in the range [0, upperBound).
-    /// @param upperBound The encrypted upper bound (exclusive).
-    /// @param randType The type of random value to generate.
+    /// @param upperBound The encrypted upper bound (exclusive). If the upper bound is e(0), the whole bit width of randType is sampled.
+    /// @param randType The type of random value to generate. If upperBound is larger than the maximum value of randType, the function will revert.
     /// @return result An encrypted random value less than upperBound.
     function eRandBounded(bytes32 upperBound, ETypes randType) external payable paying returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
-        checkInput(upperBound, typeToBitMask(ETypes.Uint256));
+        require(typeOf(upperBound) <= randType, UnexpectedType(typeOf(upperBound), typeToBitMask(randType)));
+        checkInput(upperBound, SUPPORTED_TYPES_MASK);
         randCounter++;
         result = createResultHandle(EOps.RandBounded, randType, abi.encodePacked(bytes32(randCounter), upperBound));
         uint256 id = getNextEventId();

package/src/lightning-parts/Fee.sol

@@ -1,11 +1,15 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
+import {ETypes, typeBitSize} from "../Types.sol";
+
 /// @dev The current fee required for paid encryption operations.
 ///      This constant may be modified through contract upgrades.
 ///      Developers should call getFee() rather than hardcoding this value.
 uint256 constant FEE = 0.000001 ether;
 
+uint256 constant BIT_FEE = FEE / 256;
+
 /// @title Fee
 /// @notice Fee management utilities for encryption operations that require payment
 /// @dev Certain operations (encrypted inputs, randomness) require a fee to cover covalidator costs.
@@ -48,6 +52,31 @@ abstract contract Fee {
         _;
     }
 
+    /// @notice Modifier that requires payment proportional to elist bit size
+    /// @dev Fee = totalBits * BIT_FEE. totalBits is the sum of bit sizes across all elist inputs and outputs.
+    /// @param totalBits The total elist bit count for the operation
+    modifier payingElistFee(uint256 totalBits) {
+        require(msg.value == totalBits * BIT_FEE, FeeNotPaid());
+        _;
+    }
+
+    /// @notice Returns the per-bit fee for elist operations
+    /// @dev The fee may change through contract upgrades. Always query this function
+    ///      to get the current fee rather than caching the value.
+    /// @return The per-bit fee amount in wei
+    function getBitFee() public pure returns (uint256) {
+        return BIT_FEE;
+    }
+
+    /// @notice Returns the fee for an elist operation given element count and type
+    /// @dev Fee = BIT_FEE * nOfElements * typeBitSize(elType)
+    /// @param nOfElements The number of elements in the resulting list
+    /// @param elType The element type of the list
+    /// @return The fee amount in wei
+    function getEListFee(uint16 nOfElements, ETypes elType) public pure returns (uint256) {
+        return BIT_FEE * uint256(nOfElements) * typeBitSize(elType);
+    }
+
     /// @notice Withdraws all accumulated fees to the specified recipient
     /// @dev Internal function called by IncoLightning.withdrawFees(). Transfers the entire
     ///      contract balance to the recipient.

package/src/lightning-parts/interfaces/IDecryptionAttester.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {DecryptionAttestation, ElementDecryptionProof} from "../DecryptionAttester.types.sol";
+import {DecryptionAttestation, ElementAttestationWithProof} from "../DecryptionAttester.types.sol";
 
 interface IDecryptionAttester {
 
@@ -12,7 +12,7 @@ interface IDecryptionAttester {
         returns (bool);
     function isValidEListDecryptionAttestation(
         bytes32 elistHandle,
-        ElementDecryptionProof[] memory proofElements,
+        ElementAttestationWithProof[] memory proofElements,
         bytes32 proof,
         bytes[] memory signatures
     ) external view returns (bool);

package/src/lightning-parts/interfaces/IEList.sol

@@ -8,28 +8,31 @@ import {IEncryptedInput} from "./IEncryptedInput.sol";
 
 interface IEList is IEncryptedOperations, IEncryptedInput, IEListHandleMetadata {
 
-    function newEList(bytes32[] memory handles, ETypes listType) external returns (elist newList);
+    function newEList(bytes32[] memory handles, ETypes listType) external payable 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 listAppend(elist list, bytes32 value) external payable 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 listSet(elist list, bytes32 i, bytes32 value) external payable returns (elist result);
 
-    function listInsert(elist list, bytes32 i, bytes32 value) external returns (elist result);
+    function listInsert(elist list, bytes32 i, bytes32 value) external payable returns (elist result);
 
-    function listConcat(elist lhs, elist rhs) external returns (elist result);
+    function listConcat(elist lhs, elist rhs) external payable returns (elist result);
 
-    function listSlice(elist list, bytes32 start, uint16 len, bytes32 defaultValue) external returns (elist result);
+    function listSlice(elist list, bytes32 start, uint16 len, bytes32 defaultValue)
+        external
+        payable
+        returns (elist result);
 
-    function listRange(uint16 start, uint16 end) external returns (elist result);
+    function listRange(uint16 start, uint16 end) external payable returns (elist result);
 
     function listShuffle(elist list) external payable returns (elist result);
 
-    function listReverse(elist list) external returns (elist result);
+    function listReverse(elist list) external payable returns (elist result);
 
 }

package/src/lightning-parts/interfaces/IEncryptedInput.sol

@@ -10,8 +10,8 @@ interface IEncryptedInput is IBaseAccessControlList, IHandleGeneration {
     error InvalidInputVersion(uint16 version);
     error InputLengthTooShort(uint256 length);
 
-    event VersionAccepted(uint16 version);
-    event VersionRemoved(uint16 version);
+    event VersionAccepted(uint16 indexed version);
+    event VersionRemoved(uint16 indexed version);
 
     function newEuint256(bytes calldata ciphertext, address user) external payable returns (euint256 newValue);
     function newEbool(bytes calldata ciphertext, address user) external payable returns (ebool newValue);