账户抽象：ERC-4337、智能合约钱包与 Paymaster

// ERC-4337 定义的 UserOperation 结构
struct UserOperation {
    address sender;               // 智能合约钱包地址
    uint256 nonce;                // 防重放序列号（在钱包合约中维护）
    bytes initCode;               // 创建钱包的 factory + 初始化参数（首次使用时）
    bytes callData;               // 实际要执行的调用
    uint256 callGasLimit;         // 执行 callData 的 gas 上限
    uint256 verificationGasLimit; // 验证阶段的 gas 上限
    uint256 preVerificationGas;   // bundler 的基础操作 gas
    uint256 maxFeePerGas;         // EIP-1559 最大费用
    uint256 maxPriorityFeePerGas; // EIP-1559 优先费
    bytes paymasterAndData;       // Paymaster 地址 + 签名数据
    bytes signature;              // 用户签名（不一定是 ECDSA）
}

// 简化的 EntryPoint 入口逻辑
interface IEntryPoint {
    function handleOps(
        UserOperation[] calldata ops,
        address payable beneficiary  // bundler 获得 gas 退款的目标地址
    ) external;
}

// handleOps 的核心流程：
// for each op in ops:
//   1. 如果是首次使用（initCode != ""）：创建钱包合约
//   2. 调用 sender.validateUserOp(op, userOpHash, missingAccountFunds)
//      → 钱包验证 signature 是否正确
//      → 钱包验证 nonce 是否合法
//      → 钱包支付预验证 gas（若为 paymaster 则 paymaster 支付）
//   3. 调用 sender.execute(callData) 执行用户操作
//   4. 若使用了 paymaster：调用 paymaster.validatePaymasterUserOp + postOp

// 智能合约钱包中的 validateUserOp 示例
contract SimpleAccount is BaseAccount {
    address public owner;
    IEntryPoint private immutable _entryPoint;

    constructor(IEntryPoint anEntryPoint, address anOwner) {
        _entryPoint = anEntryPoint;
        owner = anOwner;
    }

    function entryPoint() public view override returns (IEntryPoint) {
        return _entryPoint;
    }

    // EntryPoint 在验证阶段调用此函数
    function _validateSignature(
        UserOperation calldata userOp,
        bytes32 userOpHash
    ) internal override virtual returns (uint256 validationData) {
        bytes32 hash = userOpHash.toEthSignedMessageHash();
        if (owner != hash.recover(userOp.signature))
            return SIG_VALIDATION_FAILED;
        return 0;
    }

    // 执行用户操作：这里可以是任意调用
    function execute(address dest, uint256 value, bytes calldata func)
        external
    {
        _requireFromEntryPoint();
        (bool success, bytes memory result) = dest.call{value: value}(func);
        if (!success) {
            assembly { revert(add(result, 32), mload(result)) }
        }
    }

    // 仅允许 EntryPoint 调用
    function _requireFromEntryPoint() internal view {
        require(msg.sender == address(entryPoint()), "Not from EntryPoint");
    }
}

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

import "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import "@openzeppelin/contracts/utils/Create2.sol";
import "./SimpleAccount.sol";

// Account Factory：使用 CREATE2 确定性创建用户钱包
contract SimpleAccountFactory {
    IEntryPoint public immutable entryPoint;

    constructor(IEntryPoint _entryPoint) {
        entryPoint = _entryPoint;
    }

    // 创建新钱包（首次使用时由 Bundler 调用）
    function createAccount(address owner, uint256 salt)
        public
        returns (SimpleAccount ret)
    {
        address addr = getAddress(owner, salt);
        uint256 codeSize = addr.code.length;
        if (codeSize > 0) {
            return SimpleAccount(payable(addr)); // 已存在
        }
        ret = new SimpleAccount{salt: bytes32(salt)}(entryPoint, owner);
    }

    // 预先计算钱包地址（CREATE2 确定性）
    function getAddress(address owner, uint256 salt)
        public
        view
        returns (address)
    {
        return Create2.computeAddress(
            bytes32(salt),
            keccak256(abi.encodePacked(
                type(SimpleAccount).creationCode,
                abi.encode(entryPoint, owner)
            ))
        );
    }
}

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

import "@account-abstraction/contracts/interfaces/IPaymaster.sol";
import "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract TokenPaymaster is IPaymaster {
    IEntryPoint public entryPoint;
    IERC20 public token;
    address public owner;
    uint256 public tokenToEthRate; // 动态更新

    constructor(IEntryPoint _entryPoint, IERC20 _token) {
        entryPoint = _entryPoint;
        token = _token;
        owner = msg.sender;
    }

    // EntryPoint 在验证阶段调用
    function validatePaymasterUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 maxCost
    ) external override returns (bytes memory context, uint256 validationData) {
        require(msg.sender == address(entryPoint), "Not EntryPoint");

        // 从 paymasterAndData 解析用户签名的 token 授权
        // 格式: address(paymaster) + tokenAmount + signature
        (uint256 tokenAmount, bytes memory signature) =
            abi.decode(userOp.paymasterAndData[20:], (uint256, bytes));

        // 验证用户确实允许 Paymaster 扣除这些 token
        require(
            verifyTokenApproval(userOp.sender, tokenAmount, signature),
            "Invalid approval"
        );

        // 计算需要的 token 数量
        uint256 requiredTokens = (maxCost * tokenToEthRate) / 1e18;
        require(tokenAmount >= requiredTokens, "Insufficient token amount");

        // 返回上下文，供 postOp 使用
        context = abi.encode(userOp.sender, tokenAmount);
        return (context, 0);
    }

    // EntryPoint 在执行后调用
    function postOp(
        PostOpMode mode,
        bytes calldata context,
        uint256 actualGasCost
    ) external override {
        require(msg.sender == address(entryPoint), "Not EntryPoint");

        (address sender, uint256 maxTokenAmount) = abi.decode(context, (address, uint256));

        uint256 actualTokenCost = (actualGasCost * tokenToEthRate) / 1e18;
        uint256 refund = maxTokenAmount - actualTokenCost;

        // 扣除用户 token
        token.transferFrom(sender, address(this), actualTokenCost);

        // 如果有余额，退还给用户
        if (refund > 0) {
            token.transfer(sender, refund);
        }

        // 如果 mode == opReverted，可以选择不收费或部分收费
    }

    function verifyTokenApproval(
        address sender,
        uint256 amount,
        bytes memory signature
    ) internal pure returns (bool) {
        // 验证签名逻辑...
        return true;
    }

    function updateRate(uint256 newRate) external {
        require(msg.sender == owner, "Not owner");
        tokenToEthRate = newRate;
    }

    // 存入 ETH 到 EntryPoint 作为质押
    function deposit() external payable {
        entryPoint.depositTo{value: msg.value}(address(this));
    }
}

// 社交恢复钱包的核心逻辑
contract SocialRecoveryWallet is SimpleAccount {
    address[] public guardians;           // 监护人列表
    mapping(address => bool) public isGuardian;
    uint256 public threshold;             // 恢复所需监护人数量

    // 当前恢复请求
    address public pendingNewOwner;
    uint256 public recoveryRound;
    mapping(uint256 => mapping(address => bool)) public hasGuardianConfirmed;

    modifier onlyGuardian() {
        require(isGuardian[msg.sender], "Not guardian");
        _;
    }

    // 监护人发起恢复
    function initiateRecovery(address newOwner) external onlyGuardian {
        require(newOwner != address(0), "Invalid owner");
        recoveryRound++;
        pendingNewOwner = newOwner;
        hasGuardianConfirmed[recoveryRound][msg.sender] = true;
    }

    // 监护人确认恢复
    function confirmRecovery() external onlyGuardian {
        require(pendingNewOwner != address(0), "No pending recovery");
        require(!hasGuardianConfirmed[recoveryRound][msg.sender], "Already confirmed");
        hasGuardianConfirmed[recoveryRound][msg.sender] = true;

        // 执行恢复
        if (_countConfirmations() >= threshold) {
            owner = pendingNewOwner;
            pendingNewOwner = address(0);
        }
    }

    // 取消恢复请求（由原 owner 调用）
    function cancelRecovery() external {
        require(msg.sender == owner || msg.sender == address(this), "Not authorized");
        pendingNewOwner = address(0);
    }

    function _countConfirmations() internal view returns (uint256 count) {
        for (uint256 i = 0; i < guardians.length; i++) {
            if (hasGuardianConfirmed[recoveryRound][guardians[i]]) {
                count++;
            }
        }
    }
}

// Session Key 管理合约
contract SessionKeyManager {
    struct Session {
        address sessionKey;     // 临时密钥地址
        uint256 expiresAt;      // 过期时间
        address[] allowedTargets; // 允许调用的合约白名单
        uint256 maxSpend;       // 最大消费限额
        uint256 spent;          // 已消费金额
        bool active;
    }

    mapping(address => Session) public sessions;
    address public owner;

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }

    // 用户签名授权创建 Session
    function createSession(
        address sessionKey,
        uint256 duration,
        address[] calldata allowedTargets,
        uint256 maxSpend,
        bytes calldata ownerSignature
    ) external {
        require(verifyOwnerSignature(
            keccak256(abi.encodePacked(sessionKey, duration, maxSpend)),
            ownerSignature
        ), "Invalid signature");

        sessions[sessionKey] = Session({
            sessionKey: sessionKey,
            expiresAt: block.timestamp + duration,
            allowedTargets: allowedTargets,
            maxSpend: maxSpend,
            spent: 0,
            active: true
        });
    }

    // dApp 使用 Session Key 代替用户签名发起交易
    function executeWithSession(
        address sessionKey,
        address target,
        bytes calldata callData,
        uint256 value
    ) external {
        Session storage session = sessions[sessionKey];
        require(session.active, "Session inactive");
        require(block.timestamp < session.expiresAt, "Session expired");
        require(_isAllowedTarget(session, target), "Target not allowed");
        require(session.spent + value <= session.maxSpend, "Spend limit exceeded");

        session.spent += value;
        (bool success, ) = target.call{value: value}(callData);
        require(success, "Call failed");
    }

    function revokeSession(address sessionKey) external onlyOwner {
        sessions[sessionKey].active = false;
    }

    function _isAllowedTarget(Session memory session, address target)
        internal
        pure
        returns (bool)
    {
        for (uint256 i = 0; i < session.allowedTargets.length; i++) {
            if (session.allowedTargets[i] == target) return true;
        }
        return false;
    }

    function verifyOwnerSignature(bytes32 hash, bytes memory sig)
        internal
        view
        returns (bool)
    {
        // ECDSA 验证逻辑...
        return true;
    }
}

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

import "@account-abstraction/contracts/interfaces/IAccount.sol";
import "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import "@account-abstraction/contracts/interfaces/IPaymaster.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Create2.sol";

// ═══════════════════════════════════════════════════════════════
// 1. SimpleAccount：基础智能合约钱包
// ═══════════════════════════════════════════════════════════════
contract SimpleAccount is IAccount {
    using ECDSA for bytes32;

    IEntryPoint public immutable entryPoint;
    address public owner;
    uint256 public nonce;

    modifier onlyEntryPoint() {
        require(msg.sender == address(entryPoint), "Not EntryPoint");
        _;
    }

    constructor(IEntryPoint _entryPoint, address _owner) {
        entryPoint = _entryPoint;
        owner = _owner;
    }

    // EntryPoint 调用的验证入口
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external override onlyEntryPoint returns (uint256 validationData) {
        // nonce 检查
        require(userOp.nonce == nonce, "Invalid nonce");
        nonce++;

        // ECDSA 签名验证
        bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", userOpHash));
        require(hash.recover(userOp.signature) == owner, "Invalid signature");

        // 支付预验证 gas
        if (missingAccountFunds > 0) {
            (bool success, ) = payable(msg.sender).call{value: missingAccountFunds}("");
            (success); // 忽略失败，EntryPoint 会处理
        }

        return 0; // SIG_VALIDATION_SUCCESS
    }

    // 执行任意调用（仅 EntryPoint 可调用）
    function execute(address dest, uint256 value, bytes calldata func) external onlyEntryPoint {
        (bool success, bytes memory result) = dest.call{value: value}(func);
        if (!success) {
            assembly { revert(add(result, 32), mload(result)) }
        }
    }

    // 批量执行
    function executeBatch(
        address[] calldata dests,
        uint256[] calldata values,
        bytes[] calldata funcs
    ) external onlyEntryPoint {
        require(dests.length == values.length && values.length == funcs.length, "Length mismatch");
        for (uint256 i = 0; i < dests.length; i++) {
            (bool success, bytes memory result) = dests[i].call{value: values[i]}(funcs[i]);
            if (!success) {
                assembly { revert(add(result, 32), mload(result)) }
            }
        }
    }

    receive() external payable {}
}

// ═══════════════════════════════════════════════════════════════
// 2. SimpleAccountFactory：确定性创建钱包
// ═══════════════════════════════════════════════════════════════
contract SimpleAccountFactory {
    IEntryPoint public immutable entryPoint;

    constructor(IEntryPoint _entryPoint) {
        entryPoint = _entryPoint;
    }

    function createAccount(address owner, uint256 salt) external returns (SimpleAccount) {
        address addr = getAddress(owner, salt);
        if (addr.code.length > 0) {
            return SimpleAccount(payable(addr));
        }
        return new SimpleAccount{salt: bytes32(salt)}(entryPoint, owner);
    }

    function getAddress(address owner, uint256 salt) public view returns (address) {
        return Create2.computeAddress(
            bytes32(salt),
            keccak256(abi.encodePacked(type(SimpleAccount).creationCode, abi.encode(entryPoint, owner)))
        );
    }
}

// ═══════════════════════════════════════════════════════════════
// 3. VerifyingPaymaster： sponsors 代付 gas
// ═══════════════════════════════════════════════════════════════
contract VerifyingPaymaster is IPaymaster {
    IEntryPoint public immutable entryPoint;
    address public verifyingSigner;  // 由 paymaster 运营方控制
    mapping(address => uint256) public senderNonce;

    constructor(IEntryPoint _entryPoint, address _verifyingSigner) {
        entryPoint = _entryPoint;
        verifyingSigner = _verifyingSigner;
    }

    function validatePaymasterUserOp(
        UserOperation calldata userOp,
        bytes32 /* userOpHash */,
        uint256 /* maxCost */
    ) external override returns (bytes memory context, uint256 validationData) {
        require(msg.sender == address(entryPoint), "Not EntryPoint");

        // paymasterAndData = address(paymaster) + validUntil + signature
        (uint48 validUntil, bytes memory signature) = abi.decode(
            userOp.paymasterAndData[20:],
            (uint48, bytes)
        );

        require(block.timestamp <= validUntil, "Expired");

        // 构造被签名的 hash
        bytes32 hash = keccak256(abi.encodePacked(
            userOp.sender,
            userOp.nonce,
            validUntil,
            block.chainid
        ));

        require(ECDSA.recover(hash, signature) == verifyingSigner, "Invalid paymaster sig");

        return (abi.encode(userOp.sender), 0);
    }

    function postOp(
        PostOpMode /* mode */,
        bytes calldata context,
        uint256 /* actualGasCost */
    ) external override {
        require(msg.sender == address(entryPoint), "Not EntryPoint");
        (address sender) = abi.decode(context, (address));
        senderNonce[sender]++;
    }

    function deposit() external payable {
        entryPoint.depositTo{value: msg.value}(address(this));
    }

    function withdrawTo(address payable to, uint256 amount) external {
        entryPoint.withdrawTo(to, amount);
    }
}