怎样开发智能合约中的时间锁

if (block.timestamp < _timelockTime) {
    revert ErrorNotReady(block.timestamp, _timelockTime);
}

❯ forge init timelocked-contract
Initializing /Users/rg/Development/timelocked-contract...
Installing ds-test in "/Users/rg/Development/timelocked-contract/lib/ds-test", (url: https://github.com/dapphub/ds-test, tag: None)
    Installed ds-test
    Initialized forge project.
❯ cd timelocked-contract 
❯ forge test
[⠒] Compiling...
[⠰] Compiling 3 files with 0.8.10
[⠔] Solc finished in 143.06ms
Compiler run successful



Running 1 test for src/test/Contract.t.sol:ContractTest
[PASS] testExample() (gas: 190)
Test result: ok. 1 passed; 0 failed; finished in 469.71µs

// Create hash of transaction data for use in the queue
function generateTxnHash(
    address _to,
    uint256 _amount,
    uint256 _timestamp) public pure returns (bytes32) {
    return keccak256(abi.encode(_to, _amount, _timestamp));
}

interface CheatCodes {
      function warp(uint256) external;
}

// SPDX-License-Identifier: UNLICENSEDpragma solidity 0.8.10;



import "ds-test/test.sol";import "../Contract.sol";



interface CheatCodes {    function warp(uint256) external;}



contract ContractTest is DSTest {    // HEVM_ADDRESS is the pre-defined contract that contains the cheatcodes    CheatCodes constant cheats = CheatCodes(HEVM_ADDRESS);



    Contract public c;    address toAddr = 0x1234567890123456789012345678901234567890;    function setUp() public {        c = new Contract();        c.queueMint(            toAddr,            100,            block.timestamp + 600        );    }



    // Ensure you can't double queue    function testFailDoubleQueue() public {        c.queueMint(            toAddr,            100,            block.timestamp + 600        );    }



    // Ensure you can't queue in the past    function testFailPastQueue() public {        c.queueMint(            toAddr,            100,            block.timestamp - 600        );    }



    // Minting should work after the time has passed    function testMintAfterTen() public {        uint256 targetTime = block.timestamp + 600;        cheats.warp(targetTime);        c.executeMint(            toAddr,            100,            targetTime        );    }



    // Minting should fail if you mint too soon    function testFailMintNow() public {        c.executeMint(            toAddr,            100,            block.timestamp + 600        );    }



    // Minting should fail if you didn't queue    function testFailMintNonQueued() public {        c.executeMint(            toAddr,            999,            block.timestamp + 600        );    }



    // Minting should fail if try to mint twice    function testFailDoubleMint() public {        uint256 targetTime = block.timestamp + 600;        cheats.warp(block.timestamp + 600);        c.executeMint(            toAddr,            100,            targetTime
        );                            // Minting should fail if you try to mint too late    function testFailLateMint() public {        uint256 targetTime = block.timestamp + 600;        cheats.warp(block.timestamp + 600 + 1801);        emit log_uint(block.timestamp);        c.executeMint(            toAddr,            100,            targetTime        );    }



    // you should be able to cancel a mint    function testCancelMint() public {        bytes32 txnHash = c.generateTxnHash(            toAddr,            100,            block.timestamp + 600        );        c.cancelMint(txnHash);    }



    // you should be able to cancel a mint once but not twice    function testFailCancelMint() public {        bytes32 txnHash = c.generateTxnHash(            toAddr,            999,            block.timestamp + 600        );        c.cancelMint(txnHash);        c.cancelMint(txnHash);    }



    // you shouldn't be able to cancel a mint that doesn't exist    function testFailCancelMintNonQueued() public {        bytes32 txnHash = c.generateTxnHash(            toAddr,            999,            block.timestamp + 600        );        c.cancelMint(txnHash);    }}

// SPDX-License-Identifier: MITpragma solidity ^0.8.10;



import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";



contract Contract is ERC20, Ownable {    constructor() ERC20("TimeLock Token", "TLT") {}}

❯ forge install openzeppelin/openzeppelin-contracts

@openzeppelin/=lib/openzeppelin-contracts/
ds-test/=lib/ds-test/src/

// SPDX-License-Identifier: UNLICENSEDpragma solidity 0.8.10;



import "@openzeppelin/contracts/token/ERC20/ERC20.sol";import "@openzeppelin/contracts/access/Ownable.sol";



contract Contract is ERC20, Ownable {    // Error Messages for the contract    error ErrorAlreadyQueued(bytes32 txnHash);    error ErrorNotQueued(bytes32 txnHash);    error ErrorTimeNotInRange(uint256 blockTimestmap, uint256 timestamp);    error ErrorNotReady(uint256 blockTimestmap, uint256 timestamp);    error ErrorTimeExpired(uint256 blockTimestamp, uint256 expiresAt);



    // Queue Minting Event    event QueueMint(        bytes32 indexed txnHash,        address indexed to,        uint256 amount        uint256 timestamp);    // Mint Event    event ExecuteMint(        bytes32 indexed txnHash,        address indexed to,        uint256 amount,        uint256 timestamp);    // Cancel Mint Event    event CancelMint(bytes32 indexed txnHash);



    // Constants for minting window    uint256 public constant MIN_DELAY = 60; // 1 minute    uint256 public constant MAX_DELAY = 3600; // 1 hour    uint256 public constant GRACE_PERIOD = 1800; // 30 minutes



    // Minting Queue    mapping(bytes32 => bool) public mintQueue;



    constructor() ERC20("TimeLock Token", "TLT") {}



    // Create hash of transaction data for use in the queue    function generateTxnHash(        address _to,        uint256 _amount,        uint256 _timestamp) public pure returns (bytes32) {        return keccak256(abi.encode(_to, _amount, _timestamp));    }



    // Queue a mint for a given address amount, and timestamp    function queueMint(        address _to,        uint256 _amount,        uint256 _timestamp) public onlyOwner {        // Generate the transaction hash        bytes32 txnHash = generateTxnHash(_to, _amount, _timestamp);        // Check if the transaction is already in the queue        if (mintQueue[txnHash]) {            revert ErrorAlreadyQueued(txnHash);        }        // Check if the time is in the range        if (            _timestamp < block.timestamp + MIN_DELAY ||            _timestamp > block.timestamp + MAX_DELAY        ) {            revert ErrorTimeNotInRange(_timestamp, block.timestamp);        }        // Queue the transaction        mintQueue[txnHash] = true;        // Emit the QueueMint event        emit QueueMint(txnHash, _to, _amount, _timestamp);    }



    // Execute a mint for a given address, amount, and timestamp    function executeMint(        address _to,        uint256 _amount,        uint256 _timestamp) external onlyOwner {        // Generate the transaction hash        bytes32 txnHash = generateTxnHash(_to, _amount, _timestamp);        // Check if the transaction is in the queue        if (!mintQueue[txnHash]) {            revert ErrorNotQueued(txnHash);        }
        // Check if the time has passed        if (block.timestamp < _timestamp) {            revert ErrorNotReady(block.timestamp, _timestamp);        }        // Check if the window has expired        if (block.timestamp > _timestamp + GRACE_PERIOD) {            revert ErrorTimeExpired(block.timestamp, _timestamp);        }        // Remove the transaction from the queue        mintQueue[txnHash] = false;        // Execute the mint        mint(_to, _amount);        // Emit the ExecuteMint event        emit ExecuteMint(txnHash, _to, _amount, _timestamp);    }



    // Cancel a mint for a given transaction hash    function cancelMint(bytes32 _txnHash) external onlyOwner {        // Check if the transaction is in the queue        if (!mintQueue[_txnHash]) {            revert ErrorNotQueued(_txnHash);        }        // Remove the transaction from the queue        mintQueue[_txnHash] = false;        // Emit the CancelMint event        emit CancelMint(_txnHash);    }



    // Mint tokens to a given address    function mint(address to, uint256 amount) internal {        _mint(to, amount);    }}