first draft

.gitignore

+node_modules
+.env
+
+# Hardhat files
+/cache
+/artifacts
+
+# TypeChain files
+/typechain
+/typechain-types
+
+# solidity-coverage files
+/coverage
+/coverage.json

README.md

+# Sample Hardhat Project
+
+This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a script that deploys that contract.
+
+Try running some of the following tasks:
+
+```shell
+npx hardhat help
+npx hardhat test
+REPORT_GAS=true npx hardhat test
+npx hardhat node
+npx hardhat run scripts/deploy.ts
+```

contracts/MasterKeeper.sol

+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.24;
+
+
+import "./interfaces/chainlink/AutomationCompatibleInterface.sol";
+import "./interfaces/openzeppelin/Ownable.sol";
+import "./interfaces/uniswapV3/UniswapV3Pool.sol";
+import "./libraries/ArrayMutation.sol";
+
+// Uncomment this line to use console.log
+// import "hardhat/console.sol";
+
+contract MasterKeeper is Ownable, AutomationCompatibleInterface{
+    
+    AutomationCompatibleInterface public LimitOrderRegistry;
+
+    UniswapV3Pool[] public list;
+
+    constructor (AutomationCompatibleInterface _LimitOrderRegistry) {
+        LimitOrderRegistry = _LimitOrderRegistry;
+    }
+
+    function addPool(UniswapV3Pool pool) external onlyOwner {
+        list.push(pool);
+    }
+
+    function clearPool() external onlyOwner {
+        list = new UniswapV3Pool[](0);
+    }
+
+    function removePool(uint256 idx) external onlyOwner {
+        list = ArrayMutation.removeFromArray(idx, list);
+    }
+
+
+    /// @notice loop through all active pools and checkUpkeep on limit order registry for each one
+    /// @notice @param checkData is not used, todo can remove?
+    function checkUpkeep(bytes calldata checkData) external view override returns (bool upkeepNeeded, bytes memory performData){
+        //loop through all listed pools, short circuit loop when we find a needed upkeep
+        for(uint256 i = 0; i < list.length; i++){
+            (bool needed, bytes memory pData) = LimitOrderRegistry.checkUpkeep(abi.encode(list[i]));
+            if(needed){
+                return (needed, pData);
+            }
+        }
+    }
+
+    function performUpkeep(bytes calldata performData) external override {
+        LimitOrderRegistry.performUpkeep(performData);
+    }
+
+
+}

contracts/interfaces/ILimitOrderRegistry.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+interface ILimitOrderRegistry {
+
+}

contracts/interfaces/chainlink/AutomationCompatibleInterface.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface AutomationCompatibleInterface {
+  /**
+   * @notice method that is simulated by the keepers to see if any work actually
+   * needs to be performed. This method does does not actually need to be
+   * executable, and since it is only ever simulated it can consume lots of gas.
+   * @dev To ensure that it is never called, you may want to add the
+   * cannotExecute modifier from KeeperBase to your implementation of this
+   * method.
+   * @param checkData specified in the upkeep registration so it is always the
+   * same for a registered upkeep. This can easily be broken down into specific
+   * arguments using `abi.decode`, so multiple upkeeps can be registered on the
+   * same contract and easily differentiated by the contract.
+   * @return upkeepNeeded boolean to indicate whether the keeper should call
+   * performUpkeep or not.
+   * @return performData bytes that the keeper should call performUpkeep with, if
+   * upkeep is needed. If you would like to encode data to decode later, try
+   * `abi.encode`.
+   */
+  function checkUpkeep(bytes calldata checkData) external view returns (bool upkeepNeeded, bytes memory performData);
+
+  /**
+   * @notice method that is actually executed by the keepers, via the registry.
+   * The data returned by the checkUpkeep simulation will be passed into
+   * this method to actually be executed.
+   * @dev The input to this method should not be trusted, and the caller of the
+   * method should not even be restricted to any single registry. Anyone should
+   * be able call it, and the input should be validated, there is no guarantee
+   * that the data passed in is the performData returned from checkUpkeep. This
+   * could happen due to malicious keepers, racing keepers, or simply a state
+   * change while the performUpkeep transaction is waiting for confirmation.
+   * Always validate the data passed in.
+   * @param performData is the data which was passed back from the checkData
+   * simulation. If it is encoded, it can easily be decoded into other types by
+   * calling `abi.decode`. This data should not be trusted, and should be
+   * validated against the contract's current state.
+   */
+  function performUpkeep(bytes calldata performData) external;
+}
\ No newline at end of file

contracts/interfaces/openzeppelin/Context.sol

+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Provides information about the current execution context, including the
+ * sender of the transaction and its data. While these are generally available
+ * via msg.sender and msg.data, they should not be accessed in such a direct
+ * manner, since when dealing with meta-transactions the account sending and
+ * paying for execution may not be the actual sender (as far as an application
+ * is concerned).
+ *
+ * This contract is only required for intermediate, library-like contracts.
+ */
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        return msg.data;
+    }
+}
\ No newline at end of file

contracts/interfaces/openzeppelin/Ownable.sol

+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
+
+pragma solidity ^0.8.0;
+
+import "./Context.sol";
+
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * By default, the owner account will be the one that deploys the contract. This
+ * can later be changed with {transferOwnership}.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be applied to your functions to restrict their use to
+ * the owner.
+ */
+abstract contract Ownable is Context {
+    address private _owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /**
+     * @dev Initializes the contract setting the deployer as the initial owner.
+     */
+    constructor() {
+        _transferOwnership(_msgSender());
+    }
+
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        _checkOwner();
+        _;
+    }
+
+    /**
+     * @dev Returns the address of the current owner.
+     */
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+
+    /**
+     * @dev Throws if the sender is not the owner.
+     */
+    function _checkOwner() internal view virtual {
+        require(owner() == _msgSender(), "Ownable: caller is not the owner");
+    }
+
+    /**
+     * @dev Leaves the contract without owner. It will not be possible to call
+     * `onlyOwner` functions anymore. Can only be called by the current owner.
+     *
+     * NOTE: Renouncing ownership will leave the contract without an owner,
+     * thereby removing any functionality that is only available to the owner.
+     */
+    function renounceOwnership() public virtual onlyOwner {
+        _transferOwnership(address(0));
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Can only be called by the current owner.
+     */
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        _transferOwnership(newOwner);
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Internal function without access restriction.
+     */
+    function _transferOwnership(address newOwner) internal virtual {
+        address oldOwner = _owner;
+        _owner = newOwner;
+        emit OwnershipTransferred(oldOwner, newOwner);
+    }
+}
\ No newline at end of file

contracts/interfaces/uniswapV3/IUniswapV3Router.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.16;
+
+/// @title Callback for IUniswapV3PoolActions#swap
+/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
+interface IUniswapV3SwapCallback {
+    /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
+    /// @dev In the implementation you must pay the pool tokens owed for the swap.
+    /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
+    /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
+    /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
+    /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
+    /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
+    /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
+    /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
+    function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external;
+}
+
+/// @title Router token swapping functionality
+/// @notice Functions for swapping tokens via Uniswap V3
+interface IUniswapV3Router is IUniswapV3SwapCallback {
+    struct ExactInputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 amountOutMinimum;
+        uint160 sqrtPriceLimitX96;
+    }
+
+    /// @notice Swaps `amountIn` of one token for as much as possible of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
+    /// @return amountOut The amount of the received token
+    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
+
+    struct ExactInputParams {
+        bytes path;
+        address recipient;
+        uint256 deadline;
+        uint256 amountIn;
+        uint256 amountOutMinimum;
+    }
+
+    /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
+    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
+    /// @return amountOut The amount of the received token
+    function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
+
+    struct ExactOutputSingleParams {
+        address tokenIn;
+        address tokenOut;
+        uint24 fee;
+        address recipient;
+        uint256 deadline;
+        uint256 amountOut;
+        uint256 amountInMaximum;
+        uint160 sqrtPriceLimitX96;
+    }
+
+    /// @notice Swaps as little as possible of one token for `amountOut` of another token
+    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
+    /// @return amountIn The amount of the input token
+    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
+
+    struct ExactOutputParams {
+        bytes path;
+        address recipient;
+        uint256 deadline;
+        uint256 amountOut;
+        uint256 amountInMaximum;
+    }
+
+    /// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
+    /// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
+    /// @return amountIn The amount of the input token
+    function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
+}

contracts/interfaces/uniswapV3/NonFungiblePositionManager.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.16;
+
+interface NonFungiblePositionManager {
+    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+    event Collect(uint256 indexed tokenId, address recipient, uint256 amount0, uint256 amount1);
+    event DecreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+    event IncreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+
+    struct CollectParams {
+        uint256 tokenId;
+        address recipient;
+        uint128 amount0Max;
+        uint128 amount1Max;
+    }
+
+    struct DecreaseLiquidityParams {
+        uint256 tokenId;
+        uint128 liquidity;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    struct IncreaseLiquidityParams {
+        uint256 tokenId;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        uint256 deadline;
+    }
+
+    struct MintParams {
+        address token0;
+        address token1;
+        uint24 fee;
+        int24 tickLower;
+        int24 tickUpper;
+        uint256 amount0Desired;
+        uint256 amount1Desired;
+        uint256 amount0Min;
+        uint256 amount1Min;
+        address recipient;
+        uint256 deadline;
+    }
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    function PERMIT_TYPEHASH() external view returns (bytes32);
+
+    function WETH9() external view returns (address);
+
+    function approve(address to, uint256 tokenId) external;
+
+    function balanceOf(address owner) external view returns (uint256);
+
+    function baseURI() external pure returns (string memory);
+
+    function burn(uint256 tokenId) external payable;
+
+    function collect(CollectParams memory params) external payable returns (uint256 amount0, uint256 amount1);
+
+    function createAndInitializePoolIfNecessary(
+        address token0,
+        address token1,
+        uint24 fee,
+        uint160 sqrtPriceX96
+    ) external payable returns (address pool);
+
+    function decreaseLiquidity(
+        DecreaseLiquidityParams memory params
+    ) external payable returns (uint256 amount0, uint256 amount1);
+
+    function factory() external view returns (address);
+
+    function getApproved(uint256 tokenId) external view returns (address);
+
+    function increaseLiquidity(
+        IncreaseLiquidityParams memory params
+    ) external payable returns (uint128 liquidity, uint256 amount0, uint256 amount1);
+
+    function isApprovedForAll(address owner, address operator) external view returns (bool);
+
+    function mint(
+        MintParams memory params
+    ) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
+
+    function multicall(bytes[] memory data) external payable returns (bytes[] memory results);
+
+    function name() external view returns (string memory);
+
+    function ownerOf(uint256 tokenId) external view returns (address);
+
+    function permit(address spender, uint256 tokenId, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external payable;
+
+    function positions(
+        uint256 tokenId
+    )
+        external
+        view
+        returns (
+            uint96 nonce,
+            address operator,
+            address token0,
+            address token1,
+            uint24 fee,
+            int24 tickLower,
+            int24 tickUpper,
+            uint128 liquidity,
+            uint256 feeGrowthInside0LastX128,
+            uint256 feeGrowthInside1LastX128,
+            uint128 tokensOwed0,
+            uint128 tokensOwed1
+        );
+
+    function refundETH() external payable;
+
+    function safeTransferFrom(address from, address to, uint256 tokenId) external;
+
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) external;
+
+    function selfPermit(address token, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external payable;
+
+    function selfPermitAllowed(
+        address token,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable;
+
+    function selfPermitAllowedIfNecessary(
+        address token,
+        uint256 nonce,
+        uint256 expiry,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable;
+
+    function selfPermitIfNecessary(
+        address token,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external payable;
+
+    function setApprovalForAll(address operator, bool approved) external;
+
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+
+    function sweepToken(address token, uint256 amountMinimum, address recipient) external payable;
+
+    function symbol() external view returns (string memory);
+
+    function tokenByIndex(uint256 index) external view returns (uint256);
+
+    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
+
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+
+    function totalSupply() external view returns (uint256);
+
+    function transferFrom(address from, address to, uint256 tokenId) external;
+
+    function uniswapV3MintCallback(uint256 amount0Owed, uint256 amount1Owed, bytes memory data) external;
+
+    function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;
+}

contracts/interfaces/uniswapV3/UniswapV3Pool.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.16;
+
+interface UniswapV3Pool {
+    event Burn(
+        address indexed owner,
+        int24 indexed tickLower,
+        int24 indexed tickUpper,
+        uint128 amount,
+        uint256 amount0,
+        uint256 amount1
+    );
+    event Collect(
+        address indexed owner,
+        address recipient,
+        int24 indexed tickLower,
+        int24 indexed tickUpper,
+        uint128 amount0,
+        uint128 amount1
+    );
+    event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
+    event Flash(
+        address indexed sender,
+        address indexed recipient,
+        uint256 amount0,
+        uint256 amount1,
+        uint256 paid0,
+        uint256 paid1
+    );
+    event IncreaseObservationCardinalityNext(
+        uint16 observationCardinalityNextOld,
+        uint16 observationCardinalityNextNew
+    );
+    event Initialize(uint160 sqrtPriceX96, int24 tick);
+    event Mint(
+        address sender,
+        address indexed owner,
+        int24 indexed tickLower,
+        int24 indexed tickUpper,
+        uint128 amount,
+        uint256 amount0,
+        uint256 amount1
+    );
+    event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
+    event Swap(
+        address indexed sender,
+        address indexed recipient,
+        int256 amount0,
+        int256 amount1,
+        uint160 sqrtPriceX96,
+        uint128 liquidity,
+        int24 tick
+    );
+
+    function burn(int24 tickLower, int24 tickUpper, uint128 amount) external returns (uint256 amount0, uint256 amount1);
+
+    function collect(
+        address recipient,
+        int24 tickLower,
+        int24 tickUpper,
+        uint128 amount0Requested,
+        uint128 amount1Requested
+    ) external returns (uint128 amount0, uint128 amount1);
+
+    function collectProtocol(
+        address recipient,
+        uint128 amount0Requested,
+        uint128 amount1Requested
+    ) external returns (uint128 amount0, uint128 amount1);
+
+    function factory() external view returns (address);
+
+    function fee() external view returns (uint24);
+
+    function feeGrowthGlobal0X128() external view returns (uint256);
+
+    function feeGrowthGlobal1X128() external view returns (uint256);
+
+    function flash(address recipient, uint256 amount0, uint256 amount1, bytes memory data) external;
+
+    function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
+
+    function initialize(uint160 sqrtPriceX96) external;
+
+    function liquidity() external view returns (uint128);
+
+    function maxLiquidityPerTick() external view returns (uint128);
+
+    function mint(
+        address recipient,
+        int24 tickLower,
+        int24 tickUpper,
+        uint128 amount,
+        bytes memory data
+    ) external returns (uint256 amount0, uint256 amount1);
+
+    function observations(
+        uint256
+    )
+        external
+        view
+        returns (
+            uint32 blockTimestamp,
+            int56 tickCumulative,
+            uint160 secondsPerLiquidityCumulativeX128,
+            bool initialized
+        );
+
+    function observe(
+        uint32[] memory secondsAgos
+    ) external view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
+
+    function positions(
+        bytes32
+    )
+        external
+        view
+        returns (
+            uint128 liquidity,
+            uint256 feeGrowthInside0LastX128,
+            uint256 feeGrowthInside1LastX128,
+            uint128 tokensOwed0,
+            uint128 tokensOwed1
+        );
+
+    function protocolFees() external view returns (uint128 token0, uint128 token1);
+
+    function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
+
+    function slot0()
+        external
+        view
+        returns (
+            uint160 sqrtPriceX96,
+            int24 tick,
+            uint16 observationIndex,
+            uint16 observationCardinality,
+            uint16 observationCardinalityNext,
+            uint8 feeProtocol,
+            bool unlocked
+        );
+
+    function snapshotCumulativesInside(
+        int24 tickLower,
+        int24 tickUpper
+    ) external view returns (int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside);
+
+    function swap(
+        address recipient,
+        bool zeroForOne,
+        int256 amountSpecified,
+        uint160 sqrtPriceLimitX96,
+        bytes memory data
+    ) external returns (int256 amount0, int256 amount1);
+
+    function tickBitmap(int16) external view returns (uint256);
+
+    function tickSpacing() external view returns (int24);
+
+    function ticks(
+        int24
+    )
+        external
+        view
+        returns (
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            uint256 feeGrowthOutside0X128,
+            uint256 feeGrowthOutside1X128,
+            int56 tickCumulativeOutside,
+            uint160 secondsPerLiquidityOutsideX128,
+            uint32 secondsOutside,
+            bool initialized
+        );
+
+    function token0() external view returns (address);
+
+    function token1() external view returns (address);
+}

contracts/libraries/ArrayMutation.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+import "../interfaces/uniswapV3/UniswapV3Pool.sol";
+
+library ArrayMutation {
+  ///@param idx the element to remove from @param inputArray
+  function removeFromArray(uint idx, UniswapV3Pool[] memory inputArray) internal pure returns (UniswapV3Pool[] memory newList) {
+    //if length == 0, return false / revert?
+    require(inputArray.length > 0, "inputArray length == 0");
+
+    //if length == 1, reset to empty array
+    if (inputArray.length == 1) {
+      return new UniswapV3Pool[](0);
+    }
+
+    UniswapV3Pool finalElement = inputArray[inputArray.length - 1];
+
+    //if final element == deleted element, simply return the array minus the final element
+    if (finalElement == inputArray[idx]) {
+      newList = new UniswapV3Pool[](inputArray.length - 1);
+      for (uint k = 0; k < newList.length; k++) {
+        newList[k] = inputArray[k];
+      }
+
+      return newList;
+    }
+
+    //if not the final element, replace the withdrawn idx with the final element
+    inputArray[idx] = finalElement;
+
+    newList = new UniswapV3Pool[](inputArray.length - 1);
+    for (uint j = 0; j < newList.length; j++) {
+      newList[j] = inputArray[j];
+    }
+    return newList;
+  }
+}

hardhat.config.ts

+import { HardhatUserConfig } from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+
+const config: HardhatUserConfig = {
+  solidity: "0.8.24",
+};
+
+export default config;

package.json

+{
+  "dependencies": {
+    "dotenv": "^16.0.0",
+    "hardhat": "^2.21.0"
+  },
+  "devDependencies": {
+    "@nomicfoundation/hardhat-toolbox": "^1.0.2",
+    "@nomiclabs/hardhat-ethers": "^2.2.2",
+    "@nomiclabs/hardhat-etherscan": "^3.0.3",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
+    "@typechain/ethers-v5": "^10.0.0",
+    "@typechain/hardhat": "^6.0.0",
+    "@types/chai": "^4.3.0",
+    "@types/jest": "^29.4.1",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "12",
+    "chai": "^4.3.6",
+    "chai-bignumber": "^3.0.0",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.2",
+    "typechain": "^8.0.0"
+  }
+}
\ No newline at end of file

scripts/deploy.ts

+import { ethers } from "hardhat";
+
+async function main() {
+  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
+  const unlockTime = currentTimestampInSeconds + 60;
+
+  const lockedAmount = ethers.parseEther("0.001");
+
+  const lock = await ethers.deployContract("Lock", [unlockTime], {
+    value: lockedAmount,
+  });
+
+  await lock.waitForDeployment();
+
+  console.log(
+    `Lock with ${ethers.formatEther(
+      lockedAmount
+    )}ETH and unlock timestamp ${unlockTime} deployed to ${lock.target}`
+  );
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

tsconfig.json

+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  }
+}