EIP-4337 (Account Abstraction Using Alt Mempool)

Account 合约是 AccountFactory 合约通过 create2 创建，所以钱包开发者还需要实现 AccountFactory 合约。这里 SimpleAccountFactory 有 AccountFactory 的简单实现。

由于 Account 合约是使用 create2 创建的，所以用户在部署 Account 合约之前就可以得到 Account 合约的地址了，就可以进行收款了。只有当用户第一次使用 Account 合约时（比如往外转账），才有必要部署 Account 合约，具体方法是在 UserOperation 的 initCode 字段中指定 AccountFactory 合约地址和创建 Account 的参数，下一节将介绍具体细节。

首次提交 User Operation 时，必须设置 User Operation 的 initCode 字段。EntryPoint 发现 Account 合约（User Operation 的 sender 字段）在链上不存在时，会根据 initCode 字段来创建 Account 合约。具体方法是：

1. 把 initCode 的前 20 字节解释为 AccountFactory 合约的地址；
   
2. 把 initCode 从第 21 字节开始的数据作为调用 AccountFactory 时的 calldata。
   

EntryPoint 会调用下面函数来创建 Account 合约：

    /**
     * call the "initCode" factory to create and return the sender account address
     * @param initCode the initCode value from a UserOp. contains 20 bytes of factory address, followed by calldata
     * @return sender the returned address of the created account, or zero address on failure.
     */
    function createSender(bytes calldata initCode) external returns (address sender) {
        address factory = address(bytes20(initCode[0 : 20]));
        bytes memory initCallData = initCode[20 :];
        bool success;
        /* solhint-disable no-inline-assembly */
        assembly {
            success := call(gas(), factory, 0, add(initCallData, 0x20), mload(initCallData), 0, 32)
            sender := mload(0)
        }
        if (!success) {
            sender = address(0);
        }
    }

摘自：https://etherscan.io/address/0x0576a174D229E3cFA37253523E645A78A0C91B57#code

为了防止恶意的 Paymaster 进行 DoS 攻击，Paymaster 需要先质押一些 ETH 到 EntryPoint 合约中，下面解释下这个问题。

EIP 4337 中有这样的描述：

If the paymaster’s validatePaymasterUserOp returns a “context”, then handleOps must call postOp on the paymaster after making the main execution call. It must guarantee the execution of postOp, by making the main execution inside an inner call context, and if the inner call context reverts attempting to call postOp again in an outer call context.

Maliciously crafted paymasters can DoS the system. To prevent this, we use a reputation system. paymaster must either limit its storage usage, or have a stake. see the reputation, throttling and banning section for details.

上面的大概意思是：EntryPoint 调用 IPaymaster(paymaster).validatePaymasterUserOp 方法后，如果它的第一个返回值 context 有数据，则 EntryPoint 在执行完 User Operation 中的逻辑后必须保证执行 IPaymaster(paymaster).postOp 。目前采用的做法是：把执行 User Operation 和调用 postOp 封装在函数 innerHandleOp 中，使用 try/catch 来执行 innerHandleOp，如果 innerHandleOp 抛出异常，则会在 catch 语句中再执行一次 postOp（不过这次指定的 mode 参数为 PostOpMode.postOpReverted，它和前一次调用 postOp 时指定的 mode 参数不一样，这样 postOp 中就能知道是什么场景被调用的了），下面是精简的代码（完整代码请参考 EntryPoint.sol#L58 ）：

    function innerHandleOp(...) {
        IPaymaster.PostOpMode mode = IPaymaster.PostOpMode.opSucceeded;
        bool success = Exec.call(mUserOp.sender, 0, callData, callGasLimit);    // 执行 User Operation 的逻辑
        if (!success) {
                mode = IPaymaster.PostOpMode.opReverted;
            }
        }
        _handlePostOp(, mode, )           // 这里会第一次调用 postOp，mode 参数可能为 PostOpMode.opSucceeded 或者 PostOpMode.opReverted
    }

    function _executeUserOp(...) {        // 在 handleOps 的 Execution Loop 中执行
        try innerHandleOp(...) {
            // ......
        } catch {
            // ......
            _handlePostOp(, PostOpMode.postOpReverted, )  // 这里第二次调用 postOp，如果 revert 的话，会导致整个交易失败
        }
    }

我们注意到，如果 catch 处的 _handlePostOp 发生 revert，则会导致整个 bundle 的所有 User Operation 全部失败。 如果 Paymaster 在实现 postOp 时故意 revert，则将导致同一个交易中的其它 User Operation 也都失败，这是一种 DoS 攻击，为了阻止这种攻击，EIP 4337 中设计了 Stake 机制，这使得进行这种 DoS 攻击的代价大大增加。

可以通过 EntryPoint 的下面方法来管理 Stake 的资产：

    // add a paymaster stake (must be called by the paymaster)
    function addStake(uint32 _unstakeDelaySec) external payable

    // unlock the stake (must wait unstakeDelay before can withdraw)
    function unlockStake() external

    // withdraw the unlocked stake
    function withdrawStake(address payable withdrawAddress) external

Bundler 需要实现下面 RPC：

eth_sendUserOperation
eth_estimateUserOperationGas
eth_getUserOperationByHash
eth_getUserOperationReceipt
eth_supportedEntryPoints

参考：https://eips.ethereum.org/EIPS/eip-4337#rpc-methods-eth-namespace

Bundler 调用链上 EntryPoint 合约来处理 User Operation 时会消耗 Gas，这个 Gas 显然最终要补偿给 Bundler。

下面分两种情况讨论 Bundler 是如何得到 Gas 费：

1. 不使用 Paymaster 时（即 User Operation 的 paymasterAndData 字段为空）。EntryPoint 合约的 handleOps 方法在它的 Verification Loop 中调用 Account 合约的 validateUserOp(userOp, userOpHash, aggregator, missingAccountFunds) 方法时，最后一个参数 missingAccountFunds 指定的就是 Account 合约需要转给 EntryPoint 合约的 Gas 费，在实现 validateUserOp 时，至少需要把这么多数量的 Gas 转给 EntryPoint 合约。如果转账的数量多于 missingAccountFunds ，则 EntryPoint 合约会给这个 Account 合约记帐（称为 Gas 帐户，它是 EntryPoint 合约的一个 mapping，可用于下次手续费的使用），通过 EntryPoint 合约中的方法 balanceOf/depositTo/withdrawTo 可以查看/增加/减少 Gas 账户。
   
2. 使用 Paymaster 时（即 User Operation 的 paymasterAndData 字段不为空）。必须事先在 EntryPoint 合约中为 Paymaster 充值一些手续费（也是通过 EntryPoint 合约中的方法 balanceOf/depositTo/withdrawTo 可以查看/增加/减少这个 Gas 帐户）。因为，EntryPoint 合约的 handleOps 方法在它的 Verification Loop 中调用 IPaymaster(paymaster).validatePaymasterUserOp 前会检查 Gas 账户上 Paymaster 的手续费是否足够，如果足够就直接从 Gas 帐户中扣除；如果不够就报错。有一些方式来维持这个 Gas 账户上有足够的 ETH，如：A、每次在 EntryPoint 合约调用 IPaymaster(paymaster).validatePaymasterUserOp 时，paymaster 合约通过调用 EntryPoint 的 depositTo 来往 Gas 帐户充值；B、部署监控程序监控这个账户余额，低于某阈值了，就调用 EntryPoint 的 depositTo 来充值。
   

在节 2.4 中我们知道，EntryPoint 在执行 User Operation 时，有两个大循环：Verification Loop 和 Execution Loop。上面介绍的扣 Gas 费是在 Verification Loop 中，它只是预估的一个值，如果真实执行所消耗的 Gas 比这个少，则会在执行完 Execution Loop 时把多扣的 Gas 退还到 Gas 帐户中，参见：https://github.com/eth-infinitism/account-abstraction/blob/cedd0f66a156141f96677c7b89dd551351d8cfc1/contracts/core/EntryPoint.sol#L578

下面是一个简单的 EIP 4337 智能合约钱包，它实现的校验逻辑很简单：一个 EOA 帐户（即合约中的 _owner）控制一个 EIP 4337 智能合约钱包（这里只是演示 EIP 4337 智能合约钱包的开发，它并没有什么实用性）：

// SPDX-License-Identifier: MIT
// 下面代码中没有 nonce 的管理，可用于新版本 EntryPoint（0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789），不能用于旧版 EntryPoint
pragma solidity ^0.8.19;

struct UserOperation {
    address sender;
    uint256 nonce;
    bytes initCode;
    bytes callData;
    uint256 callGasLimit;
    uint256 verificationGasLimit;
    uint256 preVerificationGas;
    uint256 maxFeePerGas;
    uint256 maxPriorityFeePerGas;
    bytes paymasterAndData;
    bytes signature;
}

contract SimpleAccount {
    address private immutable _entryPoint;
    address _owner;

    uint256 constant internal SIG_VALIDATION_FAILED = 1;

    /* In order to receive native token, must implementation receive() or fallback() */
    receive() external payable {}

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

    /**
     * Validate user's signature and send missingAccountFunds to entrypoint (msg.sender)
     */
    function validateUserOp(UserOperation calldata userOp, bytes32 userOpHash, uint256 missingAccountFunds) external returns (uint256 validationData) {
        require(msg.sender == _entryPoint, "account: not EntryPoint");

        // Step 1: Verify signature
        bytes32 preHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", userOpHash)); // msg before sign
        bytes memory signature = userOp.signature;
        if (signature.length == 65) { // EIP-2098 short signature (64 bytes) is currently not supported
            // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol
            bytes32 r;
            bytes32 s;
            uint8 v;
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
                // The `ecrecover` EVM opcode allows for malleable (non-unique) signatures,
                // we rejects them by requiring the `s` value to be in the lower half order
                return SIG_VALIDATION_FAILED;
            }
            address signer = ecrecover(preHash, v, r, s);
            if (signer == address(0)) {
                return SIG_VALIDATION_FAILED;
            }
            if (signer != _owner) {
                return SIG_VALIDATION_FAILED;
            }
        } else {
            return SIG_VALIDATION_FAILED;
        }

        // Step 2: Send missingAccountFunds to the entrypoint (msg.sender)
        if (missingAccountFunds != 0) {
            (bool success,) = payable(msg.sender).call{value : missingAccountFunds, gas : type(uint256).max}("");
            (success);
            //ignore failure (its EntryPoint's job to verify, not account.)
        }

        return 0;
    }

    /**
     * execute a transaction (called directly from owner, or by entryPoint)
     */
    function execute(address dest, uint256 value, bytes calldata data) external {
        require(msg.sender == _entryPoint || msg.sender == _owner, "account: not Owner or EntryPoint");

        (bool success, bytes memory result) = dest.call{value : value}(data);
        if (!success) {
            assembly {
                revert(add(result, 32), mload(result))
            }
        }
    }
}

contract SimpleAccountFactory {
    event AccountCreated(address addr);

    constructor() {
    }

    function createAccount(bytes32 _salt, address _accountOwner, address _entryPoint) public returns (address) {
        // This syntax is a newer way to invoke create2 without assembly, you just need to pass salt
        // https://docs.soliditylang.org/en/latest/control-structures.html#salted-contract-creations-create2
        address addr = address(new SimpleAccount{salt: _salt}(_accountOwner, _entryPoint));
        emit AccountCreated(addr);
        return addr;
    }

    function getAddress(bytes32 _salt, address _accountOwner, address _entryPoint) public view returns (address) {
        address deployer = address(this);
        bytes32 bytecodeHash = keccak256(abi.encodePacked(
                type(SimpleAccount).creationCode,
                abi.encode(
                    address(_accountOwner),
                    address(_entryPoint)
                )));
        return computeAddress(_salt, bytecodeHash, deployer);
    }

    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := keccak256(start, 85)
        }
    }
}

测试步骤：

1. 部署 SimpleAccountFactory 合约；
   
2. 调用 SimpleAccountFactory 合约的 createAccount 方法来部署 SimpleAccount 合约；
   
3. 往部署好的 SimpleAccount 合约中转入少量的 ETH，
   
4. 构造 User Operation（由于 SimpleAccount 提前部署了，所以 initCode 可以为空），通过 Bundler 的 RPC eth_sendUserOperation 提交给 Bundler。