@inco/lightning 0.5.2 → 0.6.0

package/src/libs/incoLightning_devnet_v1_904635675.sol

@@ -0,0 +1,457 @@
+// AUTOGENERATED FILE. DO NOT EDIT.
+// This file was generated by the IncoLightning library generator.
+// The original template is located at Lib.template.sol
+
+/// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import { IncoLightning } from "../IncoLightning.sol";
+import { ebool, euint256, eaddress, ETypes } from "../Types.sol";
+
+IncoLightning constant inco = IncoLightning(0x3473820DcAa71Af8157b93C7f2bf1c676A2A39A6);
+address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
+
+function typeOf(bytes32 handle) pure returns (ETypes) {
+    return ETypes(uint8(uint256(handle) >> 8));
+}
+
+library e {
+    function sanitize(euint256 a) internal returns (euint256) {
+        if (euint256.unwrap(a) == bytes32(0)) {
+            return asEuint256(0);
+        }
+        return a;
+    }
+
+    function sanitize(ebool a) internal returns (ebool) {
+        if (ebool.unwrap(a) == bytes32(0)) {
+            return asEbool(false);
+        }
+        return a;
+    }
+
+    function sanitize(eaddress a) internal returns (eaddress) {
+        if (eaddress.unwrap(a) == bytes32(0)) {
+            return asEaddress(address(0));
+        }
+        return a;
+    }
+
+    function s(euint256 a) internal returns (euint256) {
+        return sanitize(a);
+    }
+
+    function s(ebool a) internal returns (ebool) {
+        return sanitize(a);
+    }
+
+    function s(eaddress a) internal returns (eaddress) {
+        return sanitize(a);
+    }
+
+    function add(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eAdd(s(a), s(b));
+    }
+
+    function add(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eAdd(s(a), asEuint256(b));
+    }
+
+    function add(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eAdd(asEuint256(a), s(b));
+    }
+
+    function sub(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eSub(s(a), s(b));
+    }
+
+    function sub(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eSub(s(a), asEuint256(b));
+    }
+
+    function sub(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eSub(asEuint256(a), s(b));
+    }
+
+    function mul(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMul(s(a), s(b));
+    }
+
+    function mul(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMul(s(a), asEuint256(b));
+    }
+
+    function mul(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMul(asEuint256(a), s(b));
+    }
+
+    function div(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eDiv(s(a), s(b));
+    }
+
+    function div(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eDiv(s(a), asEuint256(b));
+    }
+
+    function div(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eDiv(asEuint256(a), s(b));
+    }
+
+    function rem(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRem(s(a), s(b));
+    }
+
+    function rem(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRem(s(a), asEuint256(b));
+    }
+
+    function rem(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRem(asEuint256(a), s(b));
+    }
+
+    function and(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function and(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function and(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitAnd(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function and(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function and(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function and(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitAnd(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function or(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function or(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function or(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitOr(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function or(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function or(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function or(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitOr(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function xor(euint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(s(b))));
+    }
+
+    function xor(euint256 a, uint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b))));
+    }
+
+    function xor(uint256 a, euint256 b) internal returns (euint256) {
+        return euint256.wrap(inco.eBitXor(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b))));
+    }
+
+    function xor(ebool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(s(b))));
+    }
+
+    function xor(ebool a, bool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(s(a)), ebool.unwrap(asEbool(b))));
+    }
+
+    function xor(bool a, ebool b) internal returns (ebool) {
+        return ebool.wrap(inco.eBitXor(ebool.unwrap(asEbool(a)), ebool.unwrap(s(b))));
+    }
+
+    function shl(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShl(s(a), s(b));
+    }
+
+    function shl(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eShl(s(a), asEuint256(b));
+    }
+
+    function shl(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShl(asEuint256(a), s(b));
+    }
+
+    function shr(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShr(s(a), s(b));
+    }
+
+    function shr(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eShr(s(a), asEuint256(b));
+    }
+
+    function shr(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eShr(asEuint256(a), s(b));
+    }
+
+    function rotl(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotl(s(a), s(b));
+    }
+
+    function rotl(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRotl(s(a), asEuint256(b));
+    }
+
+    function rotl(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotl(asEuint256(a), s(b));
+    }
+
+    function rotr(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotr(s(a), s(b));
+    }
+
+    function rotr(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eRotr(s(a), asEuint256(b));
+    }
+
+    function rotr(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eRotr(asEuint256(a), s(b));
+    }
+
+    function eq(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
+    }
+
+    function eq(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eEq(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
+    }
+
+    function eq(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function eq(eaddress a, address b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function eq(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function eq(address a, eaddress b) internal returns (ebool) {
+        return inco.eEq(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ne(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(s(b)));
+    }
+
+    function ne(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eNe(euint256.unwrap(s(a)), euint256.unwrap(asEuint256(b)));
+    }
+
+    function ne(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(euint256.unwrap(asEuint256(a)), euint256.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ne(eaddress a, address b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(s(a)), eaddress.unwrap(asEaddress(b)));
+    }
+
+    function ne(address a, eaddress b) internal returns (ebool) {
+        return inco.eNe(eaddress.unwrap(asEaddress(a)), eaddress.unwrap(s(b)));
+    }
+
+    function ge(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGe(s(a), s(b));
+    }
+
+    function ge(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eGe(s(a), asEuint256(b));
+    }
+
+    function ge(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGe(asEuint256(a), s(b));
+    }
+
+    function gt(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGt(s(a), s(b));
+    }
+
+    function gt(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eGt(s(a), asEuint256(b));
+    }
+
+    function gt(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eGt(asEuint256(a), s(b));
+    }
+
+    function le(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLe(s(a), s(b));
+    }
+
+    function le(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eLe(s(a), asEuint256(b));
+    }
+
+    function le(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLe(asEuint256(a), s(b));
+    }
+
+    function lt(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLt(s(a), s(b));
+    }
+
+    function lt(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eLt(s(a), asEuint256(b));
+    }
+
+    function lt(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eLt(asEuint256(a), s(b));
+    }
+
+    function min(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMin(s(a), s(b));
+    }
+
+    function min(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMin(s(a), asEuint256(b));
+    }
+
+    function min(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMin(asEuint256(a), s(b));
+    }
+
+    function max(euint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMax(s(a), s(b));
+    }
+
+    function max(euint256 a, uint256 b) internal returns (euint256) {
+        return inco.eMax(s(a), asEuint256(b));
+    }
+
+    function max(uint256 a, euint256 b) internal returns (euint256) {
+        return inco.eMax(asEuint256(a), s(b));
+    }
+
+    function not(ebool a) internal returns (ebool) {
+        return inco.eNot(s(a));
+    }
+
+    /// @dev costs the inco fee
+    function rand() internal returns (euint256) {
+        return euint256.wrap(inco.eRand{value: inco.getFee()}(ETypes.Uint256));
+    }
+
+    /// @dev costs the inco fee
+    function randBounded(uint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
+    }
+
+    /// @dev costs the inco fee
+    function randBounded(euint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(s(upperBound)), ETypes.Uint256));
+    }
+
+    function asEuint256(uint256 a) internal returns (euint256) {
+        return inco.asEuint256(a);
+    }
+
+    function asEbool(bool a) internal returns (ebool) {
+        return inco.asEbool(a);
+    }
+
+    function asEaddress(address a) internal returns (eaddress) {
+        return inco.asEaddress(a);
+    }
+
+    function asEbool(euint256 a) internal returns (ebool) {
+        return ebool.wrap(inco.eCast(euint256.unwrap(a), ETypes.Bool));
+    }
+
+    function asEuint256(ebool a) internal returns (euint256) {
+        return euint256.wrap(inco.eCast(ebool.unwrap(a), ETypes.Uint256));
+    }
+
+    /// @dev costs the inco fee
+    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
+        return inco.newEuint256{value: inco.getFee()}(ciphertext, user);
+    }
+
+    /// @dev costs the inco fee
+    function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
+        return inco.newEbool{value: inco.getFee()}(ciphertext, user);
+    }
+
+    /// @dev costs the inco fee
+    function newEaddress(bytes memory ciphertext, address user) internal returns (eaddress) {
+        return inco.newEaddress{value: inco.getFee()}(ciphertext, user);
+    }
+
+    function allow(euint256 a, address to) internal {
+        inco.allow(euint256.unwrap(a), to);
+    }
+
+    function allow(ebool a, address to) internal {
+        inco.allow(ebool.unwrap(a), to);
+    }
+
+    function allow(eaddress a, address to) internal {
+        inco.allow(eaddress.unwrap(a), to);
+    }
+
+    function reveal(euint256 a) internal {
+        inco.reveal(euint256.unwrap(a));
+    }
+
+    function reveal(ebool a) internal {
+        inco.reveal(ebool.unwrap(a));
+    }
+
+    function reveal(eaddress a) internal {
+        inco.reveal(eaddress.unwrap(a));
+    }
+
+    function allowThis(euint256 a) internal {
+        allow(a, address(this));
+    }
+
+    function allowThis(ebool a) internal {
+        allow(a, address(this));
+    }
+
+    function allowThis(eaddress a) internal {
+        allow(a, address(this));
+    }
+
+    function isAllowed(address user, euint256 a) internal view returns (bool) {
+        return inco.isAllowed(euint256.unwrap(a), user);
+    }
+
+    function select(ebool control, euint256 ifTrue, euint256 ifFalse) internal returns (euint256) {
+        return euint256.wrap(inco.eIfThenElse(s(control), euint256.unwrap(s(ifTrue)), euint256.unwrap(s(ifFalse))));
+    }
+
+    function select(ebool control, ebool ifTrue, ebool ifFalse) internal returns (ebool) {
+        return ebool.wrap(inco.eIfThenElse(s(control), ebool.unwrap(s(ifTrue)), ebool.unwrap(s(ifFalse))));
+    }
+
+    function select(ebool control, eaddress ifTrue, eaddress ifFalse) internal returns (eaddress) {
+        return eaddress.wrap(inco.eIfThenElse(s(control), eaddress.unwrap(s(ifTrue)), eaddress.unwrap(s(ifFalse))));
+    }
+}

package/src/libs/incoLightning_testnet_v0_183408998.sol

@@ -353,16 +353,19 @@ library e {
         return inco.eNot(s(a));
     }
 
+    /// @dev costs the inco fee
     function rand() internal returns (euint256) {
-        return euint256.wrap(inco.eRand(ETypes.Uint256));
+        return euint256.wrap(inco.eRand{value: inco.getFee()}(ETypes.Uint256));
     }
 
+    /// @dev costs the inco fee
     function randBounded(uint256 upperBound) internal returns (euint256) {
-        return euint256.wrap(inco.eRandBounded(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
+        return euint256.wrap(inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
     }
 
+    /// @dev costs the inco fee
     function randBounded(euint256 upperBound) internal returns (euint256) {
-        return euint256.wrap(inco.eRandBounded(euint256.unwrap(s(upperBound)), ETypes.Uint256));
+        return euint256.wrap(inco.eRandBounded{value: inco.getFee()}(euint256.unwrap(s(upperBound)), ETypes.Uint256));
     }
 
     function asEuint256(uint256 a) internal returns (euint256) {
@@ -385,16 +388,19 @@ library e {
         return euint256.wrap(inco.eCast(ebool.unwrap(a), ETypes.Uint256));
     }
 
+    /// @dev costs the inco fee
     function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
-        return inco.newEuint256(ciphertext, user);
+        return inco.newEuint256{value: inco.getFee()}(ciphertext, user);
     }
 
+    /// @dev costs the inco fee
     function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
-        return inco.newEbool(ciphertext, user);
+        return inco.newEbool{value: inco.getFee()}(ciphertext, user);
     }
 
+    /// @dev costs the inco fee
     function newEaddress(bytes memory ciphertext, address user) internal returns (eaddress) {
-        return inco.newEaddress(ciphertext, user);
+        return inco.newEaddress{value: inco.getFee()}(ciphertext, user);
     }
 
     function allow(euint256 a, address to) internal {

package/src/lightning-parts/AccessControl/BaseAccessControlList.sol

@@ -1,8 +1,9 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {SenderNotAllowedForHandle} from "../../Types.sol";
+import {EOps, SenderNotAllowedForHandle} from "../../Types.sol";
 import {IBaseAccessControlList} from "./interfaces/IBaseAccessControlList.sol";
+import {EventCounter} from "../primitives/EventCounter.sol";
 import {VerifierAddressGetter} from "../primitives/VerifierAddressGetter.sol";
 import {AllowanceProof} from "../AccessControl/AdvancedAccessControl.types.sol";
 
@@ -22,14 +23,24 @@ contract AccessControlListStorage {
     }
 }
 
-// todo should add allowance events ?
-abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControlListStorage, VerifierAddressGetter {
+abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControlListStorage, VerifierAddressGetter, EventCounter {
     error ProofVerificationFailed(
         address verifyingContract,
         bytes4 callFunction,
         bytes argData
     );
-    
+
+    event Allow(
+        bytes32 handle,
+        address account,
+        uint256 eventId
+    );
+
+    event Reveal(
+        bytes32 handle,
+        uint256 eventId
+    );
+
     /// @dev persistent
     function allow(bytes32 handle, address account) public {
         require(
@@ -47,13 +58,18 @@ abstract contract BaseAccessControlList is IBaseAccessControlList, AccessControl
         );
         ACLStorage storage $ = getACLStorage();
         $.persistedAllowedForDecryption[handle] = true;
+        uint256 id = getNextEventId();
+        emit Reveal(handle, id);
+        setDigest(abi.encodePacked(EOps.Reveal, handle, id));
     }
 
     /// @dev persistent
     function allowInternal(bytes32 handle, address account) internal {
         ACLStorage storage $ = getACLStorage();
         $.persistedAllowedPairs[handle][account] = true;
-        // todo emit event ?
+        uint256 id = getNextEventId();
+        emit Allow(handle, account, id);
+        setDigest(abi.encodePacked(EOps.Allow, handle, account, id));
     }
 
     // todo current transient allowance is unsafe, make storage account bound + how to clean between UserOps

package/src/lightning-parts/AccessControl/test/TestAdvancedAccessControl.t.sol

@@ -73,6 +73,7 @@ contract TestAdvancedAccessControl is IncoTest {
     function setUp() public override {
         super.setUp();
         someContract = new SomeContractWithConfidentialData();
+        vm.deal(address(someContract), 100 ether);
         bytes memory secretCt = fakePrepareEuint256Ciphertext(42);
         vm.prank(alice);
         someContract.saveAPersonalSecret(secretCt);

package/src/lightning-parts/EncryptedInput.sol

@@ -2,17 +2,17 @@
 pragma solidity ^0.8;
 
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
-import {EventCounter} from "./primitives/EventCounter.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
 import {euint256, ebool, eaddress, ETypes} from "../Types.sol";
 import {IEncryptedInput} from "./interfaces/IEncryptedInput.sol";
 import {HandleAlreadyExists} from "../Errors.sol";
+import {Fee} from "./Fee.sol";
 
 abstract contract EncryptedInput is
     IEncryptedInput,
     BaseAccessControlList,
-    EventCounter,
-    HandleGeneration
+    HandleGeneration,
+    Fee
 {
     event NewInput(
         bytes32 indexed result,
@@ -26,21 +26,21 @@ abstract contract EncryptedInput is
     function newEuint256(
         bytes memory ciphertext,
         address user
-    ) external returns (euint256 newValue) {
+    ) external payable returns (euint256 newValue) {
         return euint256.wrap(newInput(ciphertext, user, ETypes.Uint256));
     }
 
     function newEbool(
         bytes memory ciphertext,
         address user
-    ) external returns (ebool newValue) {
+    ) external payable returns (ebool newValue) {
         return ebool.wrap(newInput(ciphertext, user, ETypes.Bool));
     }
 
     function newEaddress(
         bytes memory ciphertext,
         address user
-    ) external returns (eaddress newValue) {
+    ) external payable returns (eaddress newValue) {
         return
             eaddress.wrap(
                 newInput(ciphertext, user, ETypes.AddressOrUint160OrBytes20)
@@ -51,7 +51,23 @@ abstract contract EncryptedInput is
         bytes memory ciphertext,
         address user,
         ETypes inputType
+    ) internal paying returns (bytes32 newHandle) {
+        newHandle = _newInput(ciphertext, user, inputType);
+    }
+
+    function newInputNotPaying(
+        bytes memory ciphertext,
+        address user,
+        ETypes inputType
     ) internal returns (bytes32 newHandle) {
+        newHandle = _newInput(ciphertext, user, inputType);
+    }
+
+    function _newInput(
+        bytes memory ciphertext,
+        address user,
+        ETypes inputType
+    ) private returns (bytes32 newHandle) {
         newHandle = getInputHandle(ciphertext, user, msg.sender, inputType);
         // We assume that providing the same handle (which via HADU implies same plaintext, same context, and same
         // instance of encryption)

package/src/lightning-parts/EncryptedOperations.sol

@@ -3,15 +3,15 @@ pragma solidity ^0.8;
 
 import {euint256, ebool, EOps, SenderNotAllowedForHandle, ETypes, isTypeSupported, typeToBitMask} from "../Types.sol";
 import {BaseAccessControlList} from "./AccessControl/BaseAccessControlList.sol";
-import {EventCounter} from "./primitives/EventCounter.sol";
 import {HandleGeneration} from "./primitives/HandleGeneration.sol";
 import {IEncryptedOperations} from "./interfaces/IEncryptedOperations.sol";
+import {Fee} from "./Fee.sol";
 
 abstract contract EncryptedOperations is
     IEncryptedOperations,
     BaseAccessControlList,
-    EventCounter,
-    HandleGeneration
+    HandleGeneration,
+    Fee
 {
     error UnexpectedType(ETypes actual, bytes32 expectedTypes);
     error UnsupportedType(ETypes actual);
@@ -600,12 +600,12 @@ abstract contract EncryptedOperations is
 
     function eRand(
         ETypes randType
-    ) external returns (bytes32 result) {
+    ) external paying payable returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
 
         result = createResultHandle(
             EOps.Rand,
-            randType,
+            randType, 
             bytes32(randCounter++),
             bytes32(uint256(randType))
         );
@@ -620,7 +620,7 @@ abstract contract EncryptedOperations is
     function eRandBounded(
         bytes32 upperBound,
         ETypes randType
-    ) external returns (bytes32 result) {
+    ) external paying payable returns (bytes32 result) {
         require(isTypeSupported(randType), UnsupportedType(randType));
         checkInput(upperBound, typeToBitMask(ETypes.Uint256));