@inco/lightning 0.1.29 → 0.1.31

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.1.31
+
+- Implement batching callbacks with `DecryptionHandler.sol` as source-of-truth for pending callbacks [#629](https://github.com/Inco-fhevm/inco-monorepo/pull/629) [#616](https://github.com/Inco-fhevm/inco-monorepo/pull/629)
+
 ## 0.1.29
 
 - Publish contracts with verification [#535](https://github.com/Inco-fhevm/inco-monorepo/pull/535)

package/manifest.yaml

@@ -84,6 +84,29 @@ incoLightning_0_1_29__340846814:
       deployDate: 2025-04-22T15:55:47.828Z
       commit: v3-28-g93c05a49-dirty
       addTwoAddress: "0x1A98fB1f7E57C0648b1d2A7DEA6e126C302A7e93"
+incoLightning_0_1_29__863421733:
+  release:
+    name: incoLightning_0_1_29__863421733
+    executorAddress: "0xeBAFF6D578733E4603b99CBdbb221482F29a78E1"
+    deployer: "0x8202D2D747784Cb7D48868E44C42C4bf162a70BC"
+    pepper: demonet
+    version:
+      major: 0
+      minor: 1
+      patch: 29
+      shortSalt: "863421733"
+    salt: "0x8202d2d747784cb7d48868e44c42c4bf162a70bc00834654f6d289ccc7e5ab25"
+  deployments:
+    - decryptSigner: "0x000000000000000000000000000000000000baBe"
+      eciesPublicKey: "0x000000000000000000000000000000000000000000000000000000000000\
+        000000000000000000000000000000000000000000000000000000000000000000babe"
+      chainId: "84532"
+      blockNumber: "25719113"
+      chainName: Base Sepolia
+      active: true
+      deployDate: 2025-05-14T07:08:39.059Z
+      commit: v4
+      addTwoAddress: "0x436506A7c6462e5bab1f5CbAF9fD2a1d18F44F08"
 incoLightning_0_1_27__558243565:
   release:
     name: incoLightning_0_1_27__558243565

package/package.json

@@ -1,27 +1,30 @@
 {
   "name": "@inco/lightning",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "files": [
     "src/",
-    "foundry.toml",
     "dumps/",
     "CHANGELOG.md",
-    "remappings.txt",
-    "foundry.toml",
     "manifest.yaml"
   ],
   "scripts": {
+    "generate:libraries": "bun run ../pega/lib/deployment/cmd/generate-libraries.ts",
     "publish:github": "bun publish --registry=https://npm.pkg.github.com",
-    "generate:libraries": "bun run ../pega/lib/deployment/cmd/generate-libraries.ts"
+    "publish:npm": "bun publish --access public"
   },
   "dependencies": {
+    "@inco/shared": "^0.1.0",
     "@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"
   },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "prettier": "^3.5.3"
+  },
   "publishConfig": {
     "registry": "https://npm.pkg.github.com"
   }

package/src/CreateXHelper.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import {CreateX} from "./pasted-dependencies/CreateX.sol";
+
+// See: https://github.com/pcaversaccio/createx/issues/140 apparently this is as good as it gets if you fully compute
+// the address from a salt since the internal _guard function is an essential part of the derivation
+contract CreateXHelper is CreateX {
+    address internal constant _CREATEX = 0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed;
+
+    function computeCreate3DeployAddress(bytes32 salt) public view returns (address computedAddress) {
+        return CreateX(_CREATEX).computeCreate3Address({salt: _guard(salt) });
+    }
+}

package/src/DeployUtils.sol

@@ -7,6 +7,8 @@ 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";
+import {console} from "forge-std/console.sol";
+import {CreateXHelper} from "./CreateXHelper.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
@@ -40,33 +42,45 @@ contract DeployUtils is Script {
     ) internal pure returns (bytes32) {
         return
             bytes32(
-                abi.encodePacked(
-                    deployer,
-                    crossChainDeployAuthorizedFlag,
-                    bytes11(
-                        keccak256(
-                            abi.encodePacked(
-                                name,
-                                majorVersionNumber,
-                                minorVersionNumber,
-                                patchVersionNumber,
-                                pepper
-                            )
+            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
+    /// @dev deploys an CreateX proxy with an IncoLightning implementation
     /// @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) {
+        return deployIncoLightningUsingConfig(
+            deployer,
+            pepper,
+            MINOR_VERSION,
+            PATCH_VERSION
+        );
+    }
+
+    /// @dev Computes the address of the IncoLightning contract using CreateX based on the deployer and pepper
+    function computeIncoLightningAddress(
+        address deployer,
+        string memory pepper
+    ) public returns (address) {
+        CreateXHelper createX = new CreateXHelper();
         bytes32 salt = getSalt(
             CONTRACT_NAME,
             MAJOR_VERSION,
@@ -75,6 +89,32 @@ contract DeployUtils is Script {
             deployer,
             pepper
         );
+        return createX.computeCreate3DeployAddress({salt: salt});
+    }
+
+    /// @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,
+        // FIXME: on the next major version (new contract address and state) we should remove these from the salt altogether
+        uint8 minorVersionForSalt,
+        uint8 patchVersionForSalt
+    ) internal returns (IncoLightning proxy) {
+        bytes32 salt = getSalt(
+            CONTRACT_NAME,
+            MAJOR_VERSION,
+            minorVersionForSalt,
+            patchVersionForSalt,
+            deployer,
+            pepper
+        );
+        console.log(
+            "Deploying Inco with deployerAddress: %s, salt: %s",
+            vm.toString(deployer),
+            vm.toString(salt)
+        );
         proxy = IncoLightning(
             deployProxy({
                 deployer: deployer,
@@ -85,9 +125,45 @@ contract DeployUtils is Script {
         );
     }
 
-    /// @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
+    /// @dev Upgrades an existing IncoLightning contract whose major version is in IncoLightningConfig.sol but whose
+    /// minor and patch versions can be provided to this function in order to perform an upgrade
+    /// @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 upgradeIncoLightningUsingConfig(
+        address deployer,
+        string memory pepper,
+    // FIXME: on the next major version (new contract address and state) we should remove these from the salt altogether
+        uint8 minorVersionForSalt,
+        uint8 patchVersionForSalt
+    ) internal returns (IncoLightning proxy) {
+        // Here we hack around the fact that we must use the same salt for an ugprade and currently the salt includes
+        // the minor and patch versions
+        bytes32 salt = getSalt(
+            CONTRACT_NAME,
+            MAJOR_VERSION,
+            minorVersionForSalt,
+            patchVersionForSalt,
+            deployer,
+            pepper
+        );
+        CreateXHelper createX = new CreateXHelper();
+        address proxyAddress = createX.computeCreate3DeployAddress({salt: salt});
+        console.log(
+            "Upgrading Inco with deployerAddress: %s, salt: %s, proxyAddress: %s",
+            vm.toString(deployer),
+            vm.toString(salt),
+            vm.toString(proxyAddress)
+        );
+        proxy = IncoLightning(proxyAddress);
+
+        IncoLightning newImplementation = new IncoLightning(salt);
+        proxy.upgradeToAndCall(address(newImplementation), "");
+        return proxy;
+    }
+
+/// @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,

package/src/Lib.demonet.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(0xeBAFF6D578733E4603b99CBdbb221482F29a78E1);
+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);
+    }
+}