@inco/lightning 0.1.20

package/dumps/incoLightning_0_1_25__986372984.env

@@ -0,0 +1,15 @@
+DEPLOYER_ADDRESS=0x8202D2D747784Cb7D48868E44C42C4bf162a70BC
+STATE_DUMP=incoLightning_0_1_25__986372984.dump.json
+SESSION_VERIFIER_ADDRESS=0x359D300756aBf9dF80A4865399D5B3Ed29c7AE8B
+ADD_TWO_ADDRESS=0x723c2be5E61e7bBec4684DEfEaE63656ad3eaa10
+EXECUTOR_ADDRESS=0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd
+ECIES_PUBLIC_KEY=0x0246392874c73d1a834e7e91a2b103ad3b87ffc2b69c01dacc48f75a6436e222ee
+CALLBACK_ADDRESS=0x2581773F31B13CeEd15413975089768EEA74dCE2
+SENDER_ADDRESS=0x376238EA4D1a46C4C3D95f685b99945C4600c051
+SENDER_PRIVATE_KEY=0x9e47d2a6127a314f4354652ddcb921eafd363777fde6f1e738a650f9f8979d19
+COVALIDATOR_ECIES_PRIVATE_KEY=0x9afa56c8686787717d7b056fd6239b0434b3a589017e59e956c60a01f09dac9e
+COVALIDATOR_CALLBACK_PRIVATE_KEY=0x405dd37d8a291edc8f0ab706a01ba33379ddbf8b2e09d6ff360c8e55ebd9473c
+COVALIDATOR_ACL_ADDR=0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd
+COVALIDATOR_INCO_EXECUTOR_ADDR=0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd
+COVALIDATOR_DECRYPTION_HANDLER_ADDR=0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd
+

package/foundry.toml

@@ -0,0 +1,20 @@
+[profile.default]
+src = 'src'
+test = 'src'
+cache_path = 'out/foundry-cache'
+allow_paths = ['../../', "out/*", "broadcast/*"]
+evm_version = 'cancun'
+solc = '0.8.28'
+extra_output = ["storageLayout", "abi", "evm.methodIdentifiers"]
+ffi = true
+ast = true
+build_info = true
+fs_permissions = [
+    { access = "read", path = "./" },
+    { access = "read-write", path = "./fixtures" },
+    { access = "write", path = "out/" },
+    { access = "read-write", path = "deployments/" },
+    { access = "read-write", path = "src/generated/" },
+]
+optimizer = true
+optimizer-runs = 10_000_000

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@inco/lightning",
+  "version": "0.1.20",
+  "repository": "https://github.com/Inco-fhevm/inco-monorepo",
+  "files": [
+    "src/",
+    "foundry.toml",
+    "dumps/",
+    "CHANGELOG.md",
+    "remappings.txt"
+  ],
+  "scripts": {
+    "generate:libraries": "bun run ../pega/lib/deployment/cmd/generate-libraries.ts",
+    "publish:github": "bun publish --registry=https://npm.pkg.github.com",
+    "publish:npm": "bun publish --access public"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.2.0",
+    "@openzeppelin/contracts-upgradeable": "^5.2.0",
+    "ds-test": "https://github.com/dapphub/ds-test",
+    "forge-std": "https://github.com/foundry-rs/forge-std",
+    "tsx": "^4.19.3"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com"
+  }
+}

package/remappings.txt

@@ -0,0 +1,4 @@
+@openzeppelin/=../../node_modules/@openzeppelin/
+forge-std/=../../node_modules/forge-std/src/
+ds-test/=../../node_modules/ds-test/src/
+@inco/=../

package/src/DeployUtils.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoLightning} from "../src/IncoLightning.sol";
+import {Script} from "forge-std/Script.sol";
+import {Vm} from "forge-std/Vm.sol";
+import {CreateX, createXAddress, createXDeployer} from "../src/pasted-dependencies/CreateX.sol";
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {CONTRACT_NAME, MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION} from "../src/version/IncoLightningConfig.sol";
+
+// can be set to 0x01 so the inco address can exist on only one chain, we want the same contract at the same address
+// on all chains
+bytes1 constant crossChainDeployAuthorizedFlag = 0x00;
+
+// GLOSSARY
+// Pepper: a deployment-time string mixed into the salt hash function, used to avoid address collision on deploying
+//      the same contract twice with the same deployer address, name and version
+// Salt: a hash of the contract name, version, deployer address, and pepper.
+//      in the context of deployment using create3 with createX, the salt determines the address of the contract, and
+//      using the crossChainDeployAuthorizedFlag, it prevents the contract from being deployed by someone other than
+//      the deployer at the expected address
+
+/// @dev not a script in itself, use this contract in tests or scripts to get new instances of IncoLightning
+contract DeployUtils is Script {
+    /// @dev CreateX is deployed on most chains, use this method for the testing environment
+    function deployCreateX() public returns (CreateX createX) {
+        vm.prank(createXDeployer);
+        createX = new CreateX();
+        require(createXAddress == address(createX));
+        return createX;
+    }
+
+    function getSalt(
+        string memory name,
+        uint8 majorVersionNumber,
+        uint8 minorVersionNumber,
+        uint8 patchVersionNumber,
+        address deployer,
+        string memory pepper
+    ) internal pure returns (bytes32) {
+        return
+            bytes32(
+                abi.encodePacked(
+                    deployer,
+                    crossChainDeployAuthorizedFlag,
+                    bytes11(
+                        keccak256(
+                            abi.encodePacked(
+                                name,
+                                majorVersionNumber,
+                                minorVersionNumber,
+                                patchVersionNumber,
+                                pepper
+                            )
+                        )
+                    )
+                )
+            );
+    }
+
+    // todo add a method predicting the deployment address
+
+    /// @dev wrap in prank or broadcast depending on prod or testing environment
+    /// @param deployer MUST be the signer of the transaction
+    /// @param pepper a value used to avoid address collision on deploying the same contract twice with the same deployer
+    function deployIncoLightningUsingConfig(
+        address deployer,
+        string memory pepper
+    ) internal returns (IncoLightning proxy) {
+        bytes32 salt = getSalt(
+            CONTRACT_NAME,
+            MAJOR_VERSION,
+            MINOR_VERSION,
+            PATCH_VERSION,
+            deployer,
+            pepper
+        );
+        proxy = IncoLightning(
+            deployProxy({
+                deployer: deployer,
+                salt: salt,
+                implem: address(new IncoLightning(salt)),
+                initFunctionSelector: IncoLightning.initialize.selector
+            })
+        );
+    }
+
+    /// @notice deploys a ERC1967Proxy contract using CreateX (create3 pattern), gives the deployer the ownership of
+    ///     the proxy
+    /// @dev deployer is made the owner of the contract
+    function deployProxy(
+        address deployer,
+        bytes32 salt,
+        address implem,
+        bytes4 initFunctionSelector
+    ) internal returns (address proxy) {
+        CreateX createX = CreateX(createXAddress);
+        CreateX.Values memory msgValues = CreateX.Values(0, 0);
+        bytes memory initCall = abi.encodeWithSelector(
+            initFunctionSelector,
+            deployer
+        );
+        bytes memory bytecode = abi.encodePacked(
+            type(ERC1967Proxy).creationCode,
+            abi.encode(implem, initCall)
+        );
+        proxy = createX.deployCreate3AndInit(salt, bytecode, "", msgValues);
+    }
+}

package/src/IncoLightning.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {EncryptedInput} from "./lightning-parts/EncryptedInput.sol";
+import {EncryptedOperations} from "./lightning-parts/EncryptedOperations.sol";
+import {DecryptionHandler} from "./lightning-parts/DecryptionHandler.sol";
+import {TrivialEncryption} from "./lightning-parts/TrivialEncryption.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {CONTRACT_NAME, MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION} from "./version/IncoLightningConfig.sol";
+import {Version} from "./version/Version.sol";
+
+/// @title Inco Lightning
+/// @notice Onchain singleton for Inco Lightning, TEE-based encrypted data and operations over shared state service
+/// @dev implicitly extends BaseAccessControlList, SignatureVerifier, OwnableUpgradeable
+contract IncoLightning is
+    EncryptedOperations,
+    DecryptionHandler,
+    TrivialEncryption,
+    UUPSUpgradeable,
+    EncryptedInput,
+    Version
+{
+    // salt embeds the deployer address, the contract name, the version and the pepper
+    constructor(
+        bytes32 salt
+    )
+        Version(
+            MAJOR_VERSION,
+            MINOR_VERSION,
+            PATCH_VERSION,
+            salt,
+            CONTRACT_NAME
+        )
+    {}
+
+    function _authorizeUpgrade(address) internal view override {
+        require(msg.sender == owner());
+    }
+
+    function initialize(address owner) public initializer {
+        __Ownable_init(owner);
+    }
+
+    fallback() external {} // must be included for createX deploy
+}

package/src/Lib.sol

@@ -0,0 +1,389 @@
+// 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.sol";
+import { ebool, euint256, ETypes } from "./Types.sol";
+
+IncoLightning constant inco = IncoLightning(0xc3c81F7Bf86Af7ed3a5f5Bb1924A063a1c126cDd);
+address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
+uint256 constant defaultDecryptionDelayLimit = 2 hours;
+
+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 s(euint256 a) internal returns (euint256) {
+        return sanitize(a);
+    }
+
+    function s(ebool a) internal returns (ebool) {
+        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(s(a), s(b));
+    }
+
+    function eq(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eEq(s(a), asEuint256(b));
+    }
+
+    function eq(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eEq(asEuint256(a), s(b));
+    }
+
+    function ne(euint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(s(a), s(b));
+    }
+
+    function ne(euint256 a, uint256 b) internal returns (ebool) {
+        return inco.eNe(s(a), asEuint256(b));
+    }
+
+    function ne(uint256 a, euint256 b) internal returns (ebool) {
+        return inco.eNe(asEuint256(a), 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));
+    }
+
+    function rand() internal returns (euint256) {
+        return euint256.wrap(inco.eRand(ETypes.Uint256));
+    }
+
+    function randBounded(uint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded(euint256.unwrap(asEuint256(upperBound)), ETypes.Uint256));
+    }
+
+    function randBounded(euint256 upperBound) internal returns (euint256) {
+        return euint256.wrap(inco.eRandBounded(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 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));
+    }
+
+    function newEuint256(bytes memory ciphertext, address user) internal returns (euint256) {
+        return inco.newEuint256(ciphertext, user);
+    }
+
+    function newEbool(bytes memory ciphertext, address user) internal returns (ebool) {
+        return inco.newEbool(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 allowThis(euint256 a) internal {
+        allow(a, address(this));
+    }
+
+    function allowThis(ebool 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 requestDecryption(euint256 a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
+        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, euint256.unwrap(s(a)), callbackData);
+    }
+
+    function requestDecryption(ebool a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
+        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, ebool.unwrap(s(a)), callbackData);
+    }
+}