合约有功能：

• 可以存入ETH和erc20代币（分别调用接口depNativeToken和depErc20Token），存入时需要指定存款时间，获得一个存款凭证。存款时间到了之后，存款人持存款凭证里的编码取回资金（调用refund接口），取回的资金返回原地址。
• 不经过存款接口转到该合约地址的资金，可以由owner取出（调用getDeadFund接口）。
• 操作成功后会生成对应的事件，如存款、取款等操作。

其它特点：

• 为了保障安全，用修饰器isEoaAddress使得所有接口只接受EOA地址的调用，不接受合约地址的调用。
• 函数computeReceiptKey用于生成存款凭证的编码，由存款地址、计数器和区块号生成；
• 存款时间小于10年；
• owner可以转移；

//SPDX-License-Identifier: MIT
pragma solidity 0.8.25;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract TimeLockBox {
    address public owner;
    uint128 public counter;
    mapping(address => Receipt) private receiptRepo;
    mapping(address => bool) private hasReceipt;
    address[] private receiptKeys;
    struct Receipt {
        address customer;
        // address(0) in this contract means native token
        address token;
        uint256 amount;
        uint256 unlockTime;
        bool isNativeToken;
    }

    using SafeERC20 for IERC20;

    event Deposit(
        address receiptKey,
        address customer,
        address token,
        uint256 amount,
        uint256 lockDays,
        uint256 unlockTime
    );
    event Withdraw(
        address receiptKey,
        address customer,
        address token,
        uint256 amount,
        uint256 time
    );
    event NewOwner(address oldOwner, address newOwner);

    constructor() {
        owner = msg.sender;
        counter = 0;
    }

    function computeReceiptKey(address customer)
        private
        view
        returns (address)
    {
        return
            address(
                uint160(
                    uint256(
                        keccak256(abi.encode(customer, counter + block.number))
                    )
                )
            );
    }

    modifier isEoaAddress(address sender) {
        require(tx.origin == sender, "not support contract address");
        _;
    }

    modifier isLegalLockdays(uint256 lockDays) {
        require(
            (lockDays > 0) && (lockDays <= 3650),
            "lockDays is too large or small"
        );
        _;
    }

    function getUnlockTime(uint256 lockDays) private view returns (uint256) {
        return lockDays * 86400 + block.timestamp;
    }

    function incrementCounter() private {
        unchecked {
            counter = counter + 1;
        }
    }

    function changeOwner(address newOwner) external {
        require(msg.sender == owner, "only owner can change owner");
        owner = newOwner;
        emit NewOwner(msg.sender, owner);
    }

    function getReceipt(address receiptKey) external {
        Receipt memory receipt = receiptRepo[receiptKey];
        emit Deposit(
            receiptKey,
            receipt.customer,
            receipt.token,
            receipt.amount,
            0,
            receipt.unlockTime
        );
    }

    function depNativeToken(uint256 lockDays)
        external
        payable
        isEoaAddress(msg.sender)
        isLegalLockdays(lockDays)
    {
        require(msg.value > 0, "native token amount <= 0");
        incrementCounter();
        uint256 unlockTime = getUnlockTime(lockDays);
        Receipt memory receipt = Receipt(
            msg.sender,
            address(0),
            msg.value,
            unlockTime,
            true
        );
        address receiptKey = computeReceiptKey(receipt.customer);
        require(!hasReceipt[receiptKey], "receipt key collision");
        receiptRepo[receiptKey] = receipt;
        hasReceipt[receiptKey] = true;
        receiptKeys.push(receiptKey);

        emit Deposit(
            receiptKey,
            msg.sender,
            address(0),
            msg.value,
            lockDays,
            unlockTime
        );
    }

    function depErc20Token(
        address token,
        uint256 amount,
        uint256 lockDays
    ) external isEoaAddress(msg.sender) isLegalLockdays(lockDays) {
        require(amount > 0, "token amount <= 0");
        incrementCounter();

        uint256 unlockTime = getUnlockTime(lockDays);
        Receipt memory receipt = Receipt(
            msg.sender,
            token,
            amount,
            unlockTime,
            false
        );
        address receiptKey = computeReceiptKey(receipt.customer);
        require(!hasReceipt[receiptKey], "receipt key collision");
        receiptRepo[receiptKey] = receipt;
        hasReceipt[receiptKey] = true;
        receiptKeys.push(receiptKey);

        IERC20(token).safeTransferFrom(msg.sender, address(this), amount);

        emit Deposit(
            receiptKey,
            msg.sender,
            token,
            amount,
            lockDays,
            unlockTime
        );
    }

    function refund(address receiptKey) isEoaAddress(msg.sender) external {
        require(hasReceipt[receiptKey], "has not receipt or already drawn");

        Receipt memory receipt = receiptRepo[receiptKey];
        require(
            msg.sender == receipt.customer,
            "can only refund your own receipt"
        );

        require(
            receipt.unlockTime < block.timestamp,
            "unlock time not reached"
        );
        hasReceipt[receiptKey] = false;

        if (receipt.isNativeToken) {
            payable(receipt.customer).transfer(receipt.amount);
        } else {
            IERC20(receipt.token).safeTransfer(
                receipt.customer,
                receipt.amount
            );
        }
        emit Withdraw(
            receiptKey,
            receipt.customer,
            receipt.token,
            receipt.amount,
            block.timestamp
        );
    }

    function getDeadFund(address deadToken) isEoaAddress(msg.sender) external {
        require(msg.sender == owner, "only owner can get dead fund");

        uint256 tokenDepAmount = 0;
        Receipt memory receipt;
        for (uint256 i = 0; i < receiptKeys.length; i++) {
            address receiptKey = receiptKeys[i];
            receipt = receiptRepo[receiptKey];
            if (hasReceipt[receiptKey] && receipt.token == deadToken) {
                tokenDepAmount = tokenDepAmount + receipt.amount;
            }
        }

        uint256 deadAmount;
        if (deadToken == address(0)) {
            deadAmount = address(this).balance - tokenDepAmount;
            require(deadAmount > 0, "amount of dead fund must > 0");
            payable(owner).transfer(deadAmount);
        } else {
            deadAmount = IERC20(deadToken).balanceOf(address(this)) - tokenDepAmount;
            require(deadAmount > 0, "amount of dead fund must > 0");
            IERC20(deadToken).safeTransfer(owner, deadAmount);
        }

        emit Withdraw(
            address(0),
            owner,
            deadToken,
            deadAmount,
            block.timestamp
        );
    }
}