@inco/lightning 0.4.0 → 0.5.0

package/README.md

@@ -1,5 +1,7 @@
 # Inco lite
 
+<!-- todo #1035 upgrade deployment and upgrade documentation now outdated @silasdavis -->
+
 ## Install dependencies
 
 `bun install`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inco/lightning",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "repository": "https://github.com/Inco-fhevm/inco-monorepo",
   "files": [
     "src/",
@@ -19,16 +19,13 @@
     "@openzeppelin/contracts": "^5.2.0",
     "@openzeppelin/contracts-upgradeable": "^5.2.0",
     "@safe-global/safe-smart-account": "https://github.com/safe-global/safe-smart-account.git#v1.5.0",
-    "automata-dcap-attestation": "https://github.com/automata-network/automata-dcap-attestation.git#evm-v1.0.0",
-    "automata-on-chain-pccs": "https://github.com/automata-network/automata-on-chain-pccs.git#v1.0.0",
     "ds-test": "https://github.com/dapphub/ds-test",
     "forge-std": "https://github.com/foundry-rs/forge-std",
     "solady": "https://github.com/Vectorized/solady.git#v0.1.24",
     "tsx": "^4.19.3"
   },
   "devDependencies": {
-    "@types/bun": "latest",
-    "prettier": "^3.5.3"
+    "@types/bun": "latest"
   },
   "publishConfig": {
     "registry": "https://npm.pkg.github.com"

package/src/DeployUtils.sol

@@ -1,15 +1,26 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {IncoLightning} from "../src/IncoLightning.sol";
+import {IncoLightning} from "./IncoLightning.sol";
 import {Script} from "forge-std/Script.sol";
+import {IIncoLightning} from "./interfaces/IIncoLightning.sol";
 import {Vm} from "forge-std/Vm.sol";
-import {CreateX, createXAddress, createXDeployer} from "../src/pasted-dependencies/CreateX.sol";
+import {
+    CreateX,
+    createXAddress,
+    createXDeployer
+} from "./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 {
+    CONTRACT_NAME,
+    MAJOR_VERSION,
+    VERIFIER_NAME
+} from "./version/IncoLightningConfig.sol";
+import {IncoVerifier} from "./IncoVerifier.sol";
+import {IIncoVerifier} from "./interfaces/IIncoVerifier.sol";
 import {console} from "forge-std/console.sol";
 import {CreateXHelper} from "./CreateXHelper.sol";
-import {IncoLightningPreview} from "@inco/lightning-preview/src/IncoLightningPreview.sol";
+import {IQuoteVerifier} from "./interfaces/automata-interfaces/IQuoteVerifier.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
@@ -36,122 +47,147 @@ contract DeployUtils is Script {
     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
+                abi.encodePacked(
+                    deployer,
+                    crossChainDeployAuthorizedFlag,
+                    bytes11(
+                        keccak256(
+                            abi.encodePacked(
+                                name,
+                                majorVersionNumber,
+                                // "ghost" minor and patch versions are passed in the salt for retro compatibility
+                                // of the deployment address
+                                // todo #1037 remove permanently fake minor and patch versions from the salt
+                                uint8(1),
+                                uint8(29),
+                                pepper
+                            )
                         )
                     )
                 )
-            )
-        );
+            );
     }
 
-    /// @dev Computes the address of the IncoLightning contract using CreateX based on the deployer and pepper
-    /// @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
-    /// @param majorVersion major version of the contract
-    /// @param minorVersion minor version of the contract
-    /// @param patchVersion patch version of the contract
-    /// @return the address of the IncoLightning contract
-    /// @dev this function is used to compute the address of the contract before deploying it, so that we can check
-    /// @notice this must be called after vm.startBroadcast() to get the correct address
-    function computeIncoLightningAddress(
-        address deployer,
-        string memory pepper,
-        uint8 majorVersion,
-        uint8 minorVersion,
-        uint8 patchVersion
-    ) public returns (address) {
+    /// @notice Computes the address of the contract using CreateX based on the deployer and pepper
+    /// @dev not sure what the msg.sender influence is over the result
+    /// @param salt The salt value that will be passed to CreateX
+    /// @return The address of the deployed contract by CreateX
+    function computeAddressFromSalt(bytes32 salt) public returns (address) {
         CreateXHelper createX = new CreateXHelper();
-        bytes32 salt = getSalt(
-            CONTRACT_NAME,
-            majorVersion,
-            minorVersion,
-            patchVersion,
-            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
-    /// @param minorVersionForSalt minor version of the contract to use in the salt
-    /// @param patchVersionForSalt patch version of the contract to use in the salt
-    /// @param includePreviewFeatures whether to include preview features in the contract
-    /// @param teeLifecycleAddress the address of the TEELifecycle contract to use in the contract
+    /// @param quoteVerifier the address of the QuoteVerifier contract to use in the contract
     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,
-        bool includePreviewFeatures,
-        address teeLifecycleAddress
-    ) internal returns (IncoLightning proxy) {
-        bytes32 salt = getSalt(
-            CONTRACT_NAME,
-            MAJOR_VERSION,
-            minorVersionForSalt,
-            patchVersionForSalt,
+        IQuoteVerifier quoteVerifier
+    )
+        internal
+        returns (IIncoLightning lightningProxy, IIncoVerifier verifierProxy)
+    {
+        (bytes32 lightningSalt, bytes32 verifierSalt) = getIncoSalts(
             deployer,
             pepper
         );
         console.log(
-            "Deploying Inco with deployerAddress: %s, salt: %s",
+            "Deploying Inco with deployerAddress: %s, lightning salt: %s",
             vm.toString(deployer),
-            vm.toString(salt)
+            vm.toString(lightningSalt)
+        );
+        lightningProxy = deployLightning(lightningSalt, verifierSalt, deployer);
+        verifierProxy = deployVerifier(
+            verifierSalt,
+            lightningProxy,
+            deployer,
+            quoteVerifier
+        );
+    }
+
+    function getIncoSalts(
+        address deployer,
+        string memory pepper
+    ) internal pure returns (bytes32 lightningSalt, bytes32 verifierSalt) {
+        lightningSalt = getSalt(CONTRACT_NAME, MAJOR_VERSION, deployer, pepper);
+        verifierSalt = getSalt(VERIFIER_NAME, MAJOR_VERSION, deployer, pepper);
+    }
+
+    /// @notice Deploys the IncoLightning contract
+    /// @param lightningSalt The salt value that will be passed to CreateX
+    /// @param verifierSalt The salt value that will be passed to CreateX
+    /// @param deployer The address of the deployer
+    function deployLightning(
+        bytes32 lightningSalt,
+        bytes32 verifierSalt,
+        address deployer
+    ) internal returns (IIncoLightning lightningProxy) {
+        address verifierAddress = computeAddressFromSalt(verifierSalt);
+        IncoLightning lightningImplem = new IncoLightning(
+            lightningSalt,
+            IIncoVerifier(verifierAddress)
         );
-        IncoLightning implementation = new IncoLightning(salt);
-        if (includePreviewFeatures) {
-            IncoLightningPreview preview = new IncoLightningPreview(address(implementation));
-            // FIXME: This is hack, we ought to define an interface IIncoLightning here and use that instead
-            implementation = IncoLightning(address(preview));
-        }
-        proxy = IncoLightning(
+        lightningProxy = IIncoLightning(
             deployProxy({
-                salt: salt,
-                implem: address(implementation),
+                salt: lightningSalt,
+                implem: address(lightningImplem),
                 initCall: abi.encodeWithSelector(
-                    IncoLightning.initialize.selector,
-                    deployer,
-                    teeLifecycleAddress
+                    IIncoLightning.initialize.selector,
+                    deployer // owner
                 )
             })
         );
     }
 
+    /// @notice Deploys the IncoVerifier contract
+    /// @param verifierSalt The salt value that will be passed to CreateX
+    /// @param lightning The previously deployed lightning contract
+    /// @param deployer The address of the deployer
+    /// @param quoteVerifier The address of the TEE lifecycle contract
+    /// @dev lightning implem must already be deployed
+    function deployVerifier(
+        bytes32 verifierSalt,
+        IIncoLightning lightning,
+        address deployer,
+        IQuoteVerifier quoteVerifier
+    ) internal returns (IIncoVerifier verifierProxy) {
+        IncoVerifier verifierImplem = new IncoVerifier(address(lightning));
+        verifierProxy = IIncoVerifier(
+            deployProxy({
+                salt: verifierSalt,
+                implem: address(verifierImplem),
+                initCall: abi.encodeWithSelector(
+                    IIncoVerifier.initialize.selector,
+                    deployer, // owner
+                    VERIFIER_NAME,
+                    lightning.getVersion(),
+                    quoteVerifier
+                )
+            })
+        );
+    }
 
-/// @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
+    /// @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(
         bytes32 salt,
         address implem,
         bytes memory initCall
     ) internal returns (address proxy) {
         CreateX createX = CreateX(createXAddress);
-        CreateX.Values memory msgValues = CreateX.Values(0, 0);
         bytes memory bytecode = abi.encodePacked(
             type(ERC1967Proxy).creationCode,
             abi.encode(implem, initCall)
         );
-        proxy = createX.deployCreate3AndInit(salt, bytecode, "", msgValues);
+        // todo: check if we don't have a double delegatecall cost issue
+        proxy = createX.deployCreate3(salt, bytecode);
     }
 }

package/src/IIncoLightning.sol

@@ -1,13 +1,20 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {IIncoLightningGen} from "./IncoLightning.gen.sol";
-import {IEncryptedInputGen} from "./lightning-parts/EncryptedInput.gen.sol";
-import {IDecryptionHandlerGen} from "./lightning-parts/DecryptionHandler.gen.sol";
-import {IEncryptedOperationsGen} from "./lightning-parts/EncryptedOperations.gen.sol";
-import {ITrivialEncryptionGen} from "./lightning-parts/TrivialEncryption.gen.sol";
-import {IBaseAccessControlListGen} from "./lightning-parts/AccessControl/BaseAccessControlList.gen.sol";
-import {IHandleGenerationGen} from "./lightning-parts/primitives/HandleGeneration.gen.sol";
+import {IEncryptedInput} from "./lightning-parts/interfaces/IEncryptedInput.sol";
+import {IEncryptedOperations} from "./lightning-parts/interfaces/IEncryptedOperations.sol";
+import {ITrivialEncryption} from "./lightning-parts/interfaces/ITrivialEncryption.sol";
+import {IBaseAccessControlList} from "./lightning-parts/AccessControl/interfaces/IBaseAccessControlList.sol";
+import {IHandleGeneration} from "./lightning-parts/primitives/interfaces/IHandleGeneration.sol";
+import {IVersion} from "./version/interfaces/IVersion.sol";
 
-
-interface IIncoLightning is IIncoLightningGen, IEncryptedInputGen, IDecryptionHandlerGen, IEncryptedOperationsGen, ITrivialEncryptionGen, IBaseAccessControlListGen, IHandleGenerationGen {}
+interface IIncoLightning is
+    IEncryptedInput,
+    IEncryptedOperations,
+    ITrivialEncryption,
+    IBaseAccessControlList,
+    IHandleGeneration,
+    IVersion
+{
+    function initialize(address owner) external;
+}

package/src/IncoLightning.sol

@@ -1,31 +1,40 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import {IIncoLightning} from "./IIncoLightning.sol";
-import {CONTRACT_NAME, MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION} from "./version/IncoLightningConfig.sol";
-import {DecryptionHandler} from "./lightning-parts/DecryptionHandler.sol";
+import {IIncoLightning} from "./interfaces/IIncoLightning.sol";
+import {
+    CONTRACT_NAME,
+    MAJOR_VERSION,
+    MINOR_VERSION,
+    PATCH_VERSION
+} from "./version/IncoLightningConfig.sol";
 import {EncryptedInput} from "./lightning-parts/EncryptedInput.sol";
 import {EncryptedOperations} from "./lightning-parts/EncryptedOperations.sol";
-import {IIncoLightningGen} from "./IncoLightning.gen.sol";
 import {TrivialEncryption} from "./lightning-parts/TrivialEncryption.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 import {Version} from "./version/Version.sol";
+import {IIncoVerifier} from "./interfaces/IIncoVerifier.sol";
+import {VerifierAddressGetter} from "./lightning-parts/primitives/VerifierAddressGetter.sol";
+
+// todo add initialization of tee lifecycle
 
 /// @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
+/// @dev implicitly extends BaseAccessControlList, IncoVerifierGetter
 contract IncoLightning is
     IIncoLightning,
     EncryptedOperations,
-    DecryptionHandler,
     TrivialEncryption,
     UUPSUpgradeable,
     EncryptedInput,
+    OwnableUpgradeable,
     Version
 {
     // salt embeds the deployer address, the contract name, the version and the pepper
     constructor(
-        bytes32 salt
+        bytes32 salt,
+        IIncoVerifier _incoVerifier
     )
         Version(
             MAJOR_VERSION,
@@ -34,15 +43,15 @@ contract IncoLightning is
             salt,
             CONTRACT_NAME
         )
+        VerifierAddressGetter(address(_incoVerifier))
     {}
 
     function _authorizeUpgrade(address) internal view override {
         require(msg.sender == owner());
     }
 
-    function initialize(address owner, address teeLifecycleAddress) public initializer {
+    function initialize(address owner) public initializer {
         __Ownable_init(owner);
-        __SignatureVerifier_init(teeLifecycleAddress);
     }
 
     fallback() external {} // must be included for createX deploy

package/src/IncoVerifier.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {AdvancedAccessControl} from "./lightning-parts/AccessControl/AdvancedAccessControl.sol";
+import {DecryptionAttester} from "./lightning-parts/DecryptionAttester.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {IQuoteVerifier} from "./interfaces/automata-interfaces/IQuoteVerifier.sol";
+import {TEELifecycle} from "./lightning-parts/TEELifecycle.sol";
+import {IIncoVerifier} from "./interfaces/IIncoVerifier.sol";
+import {LightningAddressGetter} from "./lightning-parts/primitives/LightningAddressGetter.sol";
+
+/// @dev implicitely extends OwnableUpgradeable, EIP712Upgradeable, SignatureVerifier, LightningAddressGetter
+/// @dev NEVER deploy this contract on its own, always deploy as a joint process with IncoLightning
+contract IncoVerifier is
+    IIncoVerifier,
+    AdvancedAccessControl,
+    DecryptionAttester,
+    TEELifecycle,
+    UUPSUpgradeable
+{
+    constructor(
+        address _incoLightningAddress
+    ) LightningAddressGetter(_incoLightningAddress) {}
+
+    function _authorizeUpgrade(address) internal view override {
+        require(msg.sender == owner());
+    }
+
+    function initialize(
+        address owner,
+        string memory name,
+        string memory version,
+        IQuoteVerifier quoteVerifier
+    ) public initializer {
+        __Ownable_init(owner);
+        __EIP712_init(name, version);
+        __TEELifecycle_init(quoteVerifier);
+    }
+
+    function getEIP712Name() external view returns (string memory) {
+        return _EIP712Name();
+    }
+
+    function getEIP712Version() external view returns (string memory) {
+        return _EIP712Version();
+    }
+}

package/src/Lib.alphanet.sol

@@ -5,12 +5,11 @@
 /// SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import "./IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, isTypeSupported } from "./Types.sol";
+import { IncoLightning } from "./IncoLightning.sol";
+import { ebool, euint256, eaddress, ETypes } from "./Types.sol";
 
 IncoLightning constant inco = IncoLightning(0x4651DfD7729aE5568092E7351fAaD872266d4CBd);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
-uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
 function typeOf(bytes32 handle) pure returns (ETypes) {
     return ETypes(uint8(uint256(handle) >> 8));
@@ -449,16 +448,4 @@ library e {
     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))));
     }
-
-    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);
-    }
-
-    function requestDecryption(eaddress a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
-        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, eaddress.unwrap(s(a)), callbackData);
-    }
 }

package/src/Lib.demonet.sol

@@ -5,12 +5,11 @@
 /// SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import "./IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, isTypeSupported } from "./Types.sol";
+import { IncoLightning } from "./IncoLightning.sol";
+import { ebool, euint256, eaddress, ETypes } from "./Types.sol";
 
 IncoLightning constant inco = IncoLightning(0xeBAFF6D578733E4603b99CBdbb221482F29a78E1);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
-uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
 function typeOf(bytes32 handle) pure returns (ETypes) {
     return ETypes(uint8(uint256(handle) >> 8));
@@ -449,16 +448,4 @@ library e {
     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))));
     }
-
-    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);
-    }
-
-    function requestDecryption(eaddress a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
-        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, eaddress.unwrap(s(a)), callbackData);
-    }
 }

package/src/Lib.devnet.sol

@@ -5,12 +5,11 @@
 /// SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import "./IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, isTypeSupported } from "./Types.sol";
+import { IncoLightning } from "./IncoLightning.sol";
+import { ebool, euint256, eaddress, ETypes } from "./Types.sol";
 
 IncoLightning constant inco = IncoLightning(0x3B22be60Ae699933959CA3cE147C96caa88Ccd3D);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
-uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
 function typeOf(bytes32 handle) pure returns (ETypes) {
     return ETypes(uint8(uint256(handle) >> 8));
@@ -449,16 +448,4 @@ library e {
     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))));
     }
-
-    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);
-    }
-
-    function requestDecryption(eaddress a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
-        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, eaddress.unwrap(s(a)), callbackData);
-    }
 }

package/src/Lib.sol

@@ -5,12 +5,11 @@
 /// SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import "./IncoLightning.sol";
-import { ebool, euint256, eaddress, ETypes, isTypeSupported } from "./Types.sol";
+import { IncoLightning } from "./IncoLightning.sol";
+import { ebool, euint256, eaddress, ETypes } from "./Types.sol";
 
 IncoLightning constant inco = IncoLightning(0x63D8135aF4D393B1dB43B649010c8D3EE19FC9fd);
 address constant deployedBy = 0x8202D2D747784Cb7D48868E44C42C4bf162a70BC;
-uint256 constant defaultDecryptionDelayLimit = 2 hours;
 
 function typeOf(bytes32 handle) pure returns (ETypes) {
     return ETypes(uint8(uint256(handle) >> 8));
@@ -449,16 +448,4 @@ library e {
     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))));
     }
-
-    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);
-    }
-
-    function requestDecryption(eaddress a, bytes4 callbackSelector, bytes memory callbackData) internal returns (uint256 requestId) {
-        requestId = inco.requestDecryption(callbackSelector, block.timestamp + defaultDecryptionDelayLimit, eaddress.unwrap(s(a)), callbackData);
-    }
 }

package/src/Lib.template.sol

@@ -2,16 +2,14 @@
 // SPDX-License-Identifier: No License
 pragma solidity ^0.8;
 
-import "./IncoLightning.sol";
-import {ebool, euint256, eaddress, ETypes, isTypeSupported} from "./Types.sol";
+import {IncoLightning} from "./IncoLightning.sol";
+import {ebool, euint256, eaddress, ETypes} from "./Types.sol";
 
 IncoLightning constant inco = IncoLightning(
     0x000000000000000000000000000000000000baBe
 );
 address constant deployedBy = 0x000000000000000000000000000000000000baBe;
 
-uint256 constant defaultDecryptionDelayLimit = 2 hours;
-
 function typeOf(bytes32 handle) pure returns (ETypes) {
     return ETypes(uint8(uint256(handle) >> 8));
 }
@@ -471,7 +469,7 @@ library e {
     function isAllowed(address user, euint256 a) internal view returns (bool) {
         return inco.isAllowed(euint256.unwrap(a), user);
     }
-    
+
     function select(
         ebool control,
         euint256 ifTrue,
@@ -516,43 +514,4 @@ library e {
                 )
             );
     }
-
-    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
-        );
-    }
-
-    function requestDecryption(
-        eaddress a,
-        bytes4 callbackSelector,
-        bytes memory callbackData
-    ) internal returns (uint256 requestId) {
-        requestId = inco.requestDecryption(
-            callbackSelector,
-            block.timestamp + defaultDecryptionDelayLimit,
-            eaddress.unwrap(s(a)),
-            callbackData
-        );
-    }
 }