// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title Simple2of2Multisig
 * @dev 简化版2-of-2链上多签合约，支持ETH转账和合约调用
 * 核心功能：提交交易→收集2个签名→执行交易
 */
contract Simple2of2Multisig {
    // 授权人地址（2个）
    address public immutable owner1;
    address public immutable owner2;

    // 交易结构体：存储待执行的交易信息
    struct Transaction {
        address to;       // 接收方地址
        uint256 value;    // 转账ETH金额（wei）
        bytes data;       // 调用合约的calldata（空则为纯ETH转账）
        bool executed;    // 是否已执行
        uint8 confirmCount; // 已收集的签名数量
    }

    // 交易ID → 交易信息
    mapping(uint256 => Transaction) public transactions;
    // 交易ID → 授权人地址 → 是否已签名
    mapping(uint256 => mapping(address => bool)) public isConfirmed;
    // 交易计数器（生成唯一交易ID）
    uint256 public txCount;

    // 事件：提交交易
    event TransactionSubmitted(uint256 indexed txId, address indexed submitter, address to, uint256 value);
    // 事件：确认交易（签名）
    event TransactionConfirmed(uint256 indexed txId, address indexed confirmer);
    // 事件：执行交易
    event TransactionExecuted(uint256 indexed txId, address indexed executor);

    // 修饰器：仅授权人可调用
    modifier onlyOwner() {
        require(msg.sender == owner1 || msg.sender == owner2, "Not an owner");
        _;
    }

    // 修饰器：交易未执行
    modifier notExecuted(uint256 txId) {
        require(!transactions[txId].executed, "Transaction already executed");
        _;
    }

    // 构造函数：初始化2个授权人
    constructor(address _owner1, address _owner2) {
        require(_owner1 != address(0) && _owner2 != address(0) && _owner1 != _owner2, "Invalid owners");
        owner1 = _owner1;
        owner2 = _owner2;
    }

    /**
     * @dev 提交交易（任意授权人可提交）
     * @param _to 接收方地址
     * @param _value 转账ETH金额（wei）
     * @param _data 合约调用数据（空则为纯ETH转账）
     * @return txId 生成的交易ID
     */
    function submitTransaction(
        address _to,
        uint256 _value,
        bytes calldata _data
    ) external onlyOwner returns (uint256 txId) {
        require(_to != address(0), "Invalid to address");
        
        txId = txCount;
        transactions[txId] = Transaction({
            to: _to,
            value: _value,
            data: _data,
            executed: false,
            confirmCount: 0
        });

        txCount++;
        emit TransactionSubmitted(txId, msg.sender, _to, _value);
    }

    /**
     * @dev 确认交易（签名，任意授权人可确认）
     * @param txId 交易ID
     */
    function confirmTransaction(uint256 txId) external onlyOwner notExecuted(txId) {
        Transaction storage txn = transactions[txId];
        require(!isConfirmed[txId][msg.sender], "Already confirmed");

        isConfirmed[txId][msg.sender] = true;
        txn.confirmCount++;

        emit TransactionConfirmed(txId, msg.sender);
    }

    /**
     * @dev 执行交易（需收集2个签名，任意授权人可执行）
     * @param txId 交易ID
     */
    function executeTransaction(uint256 txId) external onlyOwner notExecuted(txId) {
        Transaction storage txn = transactions[txId];
        // 验证签名数量≥2（2-of-2门限）
        require(txn.confirmCount >= 2, "Not enough confirmations");

        // 标记交易已执行
        txn.executed = true;
        // 执行交易：转账ETH或调用合约
        (bool success, ) = txn.to.call{value: txn.value}(txn.data);
        require(success, "Transaction execution failed");

        emit TransactionExecuted(txId, msg.sender);
    }

    /**
     * @dev 接收ETH（合约可存储ETH）
     */
    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title GenericTimelock
 * @dev 通用型相对时间锁合约
 * 核心逻辑：提交操作→等待delay秒→执行操作（支持ETH转账/合约调用）
 */
contract GenericTimelock {
    // 管理员：有权提交/执行/撤销操作（生产环境可替换为多签地址）
    address public immutable admin;
    // 延迟时间（秒）：提交后需等待该时间才能执行
    uint256 public immutable delay;

    // 操作结构体：存储待执行的操作信息
    struct Operation {
        address to;          // 接收方地址
        uint256 value;       // 转账ETH金额（wei）
        bytes data;          // 合约调用calldata
        uint256 proposalTime;// 提交时间（区块时间）
        bool executed;       // 是否已执行
        bool canceled;       // 是否已撤销
    }

    // 操作ID → 操作信息（操作ID=keccak256(操作关键参数)，避免重复）
    mapping(bytes32 => Operation) public operations;

    // 事件：提交操作
    event OperationProposed(bytes32 indexed opId, address indexed proposer, address to, uint256 value);
    // 事件：执行操作
    event OperationExecuted(bytes32 indexed opId, address indexed executor);
    // 事件：撤销操作
    event OperationCanceled(bytes32 indexed opId, address indexed canceler);

    // 修饰器：仅管理员可调用
    modifier onlyAdmin() {
        require(msg.sender == admin, "Not admin");
        _;
    }

    // 修饰器：操作未执行且未撤销
    modifier validOperation(bytes32 opId) {
        Operation storage op = operations[opId];
        require(op.proposalTime > 0, "Operation does not exist");
        require(!op.executed, "Operation already executed");
        require(!op.canceled, "Operation canceled");
        _;
    }

    // 修饰器：操作已到可执行时间
    modifier timeLockPassed(bytes32 opId) {
        Operation storage op = operations[opId];
        require(block.timestamp >= op.proposalTime + delay, "Time lock not passed");
        _;
    }

    /**
     * @dev 构造函数
     * @param _admin 管理员地址（生产环境建议设为多签合约地址）
     * @param _delay 延迟时间（秒），建议≥86400（24小时）
     */
    constructor(address _admin, uint256 _delay) {
        require(_admin != address(0), "Invalid admin");
        require(_delay > 0, "Delay must be > 0");
        admin = _admin;
        delay = _delay;
    }

    /**
     * @dev 生成操作ID（唯一标识，防止重复提交）
     * @param to 接收方
     * @param value 转账金额
     * @param data 调用数据
     * @return opId 操作ID
     */
    function getOperationId(
        address to,
        uint256 value,
        bytes calldata data
    ) public pure returns (bytes32 opId) {
        opId = keccak256(abi.encodePacked(to, value, data));
    }

    /**
     * @dev 提交操作（提案）
     * @param to 接收方地址
     * @param value 转账ETH金额
     * @param data 合约调用数据（空则为纯ETH转账）
     * @return opId 操作ID
     */
    function proposeOperation(
        address to,
        uint256 value,
        bytes calldata data
    ) external onlyAdmin returns (bytes32 opId) {
        require(to != address(0), "Invalid to address");
        opId = getOperationId(to, value, data);
        require(operations[opId].proposalTime == 0, "Operation already proposed");

        operations[opId] = Operation({
            to: to,
            value: value,
            data: data,
            proposalTime: block.timestamp,
            executed: false,
            canceled: false
        });

        emit OperationProposed(opId, msg.sender, to, value);
        return opId;
    }

    /**
     * @dev 执行操作（需等待时间锁到期）
     * @param to 接收方地址（需与提交时一致）
     * @param value 转账金额（需与提交时一致）
     * @param data 调用数据（需与提交时一致）
     */
    function executeOperation(
        address to,
        uint256 value,
        bytes calldata data
    ) external onlyAdmin validOperation(getOperationId(to, value, data)) timeLockPassed(getOperationId(to, value, data)) {
        bytes32 opId = getOperationId(to, value, data);
        Operation storage op = operations[opId];

        // 标记操作已执行
        op.executed = true;
        // 执行转账/合约调用
        (bool success, ) = op.to.call{value: op.value}(op.data);
        require(success, "Operation execution failed");

        emit OperationExecuted(opId, msg.sender);
    }

    /**
     * @dev 撤销操作（仅未执行/未到期时可撤销）
     * @param to 接收方地址
     * @param value 转账金额
     * @param data 调用数据
     */
    function cancelOperation(
        address to,
        uint256 value,
        bytes calldata data
    ) external onlyAdmin validOperation(getOperationId(to, value, data)) {
        bytes32 opId = getOperationId(to, value, data);
        operations[opId].canceled = true;

        emit OperationCanceled(opId, msg.sender);
    }

    /**
     * @dev 接收ETH（合约可存储ETH）
     */
    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title MultisigWithTimelock
 * @dev 2-of-2多签 + 时间锁整合合约
 * 核心流程：提交交易→收集2个签名→等待delay秒→执行交易
 */
contract MultisigWithTimelock {
    // 多签授权人
    address public immutable owner1;
    address public immutable owner2;
    // 时间锁延迟（秒）
    uint256 public immutable delay;

    // 交易结构体：整合多签+时间锁
    struct Transaction {
        address to;
        uint256 value;
        bytes data;
        uint256 proposalTime; // 提交时间（时间锁起点）
        bool executed;
        bool canceled;
        uint8 confirmCount; // 多签签名数
    }

    mapping(uint256 => Transaction) public transactions;
    mapping(uint256 => mapping(address => bool)) public isConfirmed;
    uint256 public txCount;

    // 事件
    event TransactionProposed(uint256 indexed txId, address indexed proposer);
    event TransactionConfirmed(uint256 indexed txId, address indexed confirmer);
    event TransactionExecuted(uint256 indexed txId, address indexed executor);
    event TransactionCanceled(uint256 indexed txId, address indexed canceler);

    // 修饰器：仅授权人
    modifier onlyOwner() {
        require(msg.sender == owner1 || msg.sender == owner2, "Not owner");
        _;
    }

    // 修饰器：交易有效（未执行/未撤销）
    modifier validTx(uint256 txId) {
        Transaction storage txn = transactions[txId];
        require(txn.proposalTime > 0, "Tx does not exist");
        require(!txn.executed, "Tx executed");
        require(!txn.canceled, "Tx canceled");
        _;
    }

    // 修饰器：时间锁到期
    modifier timelockPassed(uint256 txId) {
        Transaction storage txn = transactions[txId];
        require(block.timestamp >= txn.proposalTime + delay, "Timelock not passed");
        _;
    }

    // 修饰器：多签签名数≥2
    modifier enoughConfirmations(uint256 txId) {
        require(transactions[txId].confirmCount >= 2, "Not enough confirmations");
        _;
    }

    constructor(address _owner1, address _owner2, uint256 _delay) {
        require(_owner1 != _owner2 && _owner1 != address(0), "Invalid owners");
        require(_delay > 0, "Delay > 0");
        owner1 = _owner1;
        owner2 = _owner2;
        delay = _delay;
    }

    /**
     * @dev 提交交易（多签授权人提交，启动时间锁）
     */
    function proposeTx(address to, uint256 value, bytes calldata data) external onlyOwner returns (uint256 txId) {
        require(to != address(0), "Invalid to");
        txId = txCount;
        transactions[txId] = Transaction({
            to: to,
            value: value,
            data: data,
            proposalTime: block.timestamp,
            executed: false,
            canceled: false,
            confirmCount: 0
        });
        txCount++;
        emit TransactionProposed(txId, msg.sender);
    }

    /**
     * @dev 确认交易（多签签名）
     */
    function confirmTx(uint256 txId) external onlyOwner validTx(txId) {
        Transaction storage txn = transactions[txId];
        require(!isConfirmed[txId][msg.sender], "Already confirmed");
        isConfirmed[txId][msg.sender] = true;
        txn.confirmCount++;
        emit TransactionConfirmed(txId, msg.sender);
    }

    /**
     * @dev 执行交易（需：2个签名+时间锁到期）
     */
    function executeTx(uint256 txId) external onlyOwner validTx(txId) enoughConfirmations(txId) timelockPassed(txId) {
        Transaction storage txn = transactions[txId];
        txn.executed = true;
        (bool success, ) = txn.to.call{value: txn.value}(txn.data);
        require(success, "Tx failed");
        emit TransactionExecuted(txId, msg.sender);
    }

    /**
     * @dev 撤销交易（仅未执行/未到期时）
     */
    function cancelTx(uint256 txId) external onlyOwner validTx(txId) {
        transactions[txId].canceled = true;
        emit TransactionCanceled(txId, msg.sender);
    }

    receive() external payable {}
}