6469424629

Committed 10 Oct 2023 12:41PM UTC coverage: 72.152% (+10.9%) from 61.25%

Build # 6469424629

Build Type

Pull #89

github

Committed by

web-flow

Commit Message

Apply suggestions from code review

Co-authored-by: Mikhail <16622558+mmv08@users.noreply.github.com>

Pull Request Pull Request #89: Closes #82: implement 4337 deploy flow

Run Details

26 of 48 branches covered (0.0%)

Branch coverage included in aggregate %.

12 of 12 new or added lines in 2 files covered. (100.0%)

88 of 110 relevant lines covered (80.0%)

3.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.81

/4337/contracts/test/TestEntryPoint.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.8.0;
import {INonceManager} from "../interfaces/ERC4337.sol";
import {UserOperation, UserOperationLib} from "../UserOperation.sol";

interface Account {
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32,
        uint256 requiredPrefund
    ) external returns (uint256);
}

/**
 * helper contract for EntryPoint, to call userOp.initCode from a "neutral" address,
 * which is explicitly not the entryPoint itself.
 */
contract SenderCreator {
    /**
     * 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);
        }
    }
}

contract TestEntryPoint is INonceManager {
    error NotEnoughFunds(uint256 expected, uint256 available);
    error InvalidNonce(uint256 userNonce);
    SenderCreator public immutable senderCreator;
    mapping(address => uint256) balances;
    mapping(address => mapping(uint192 => uint256)) public nonceSequenceNumber;

    constructor() {
        senderCreator = new SenderCreator();
    }

    receive() external payable {
        balances[msg.sender] = balances[msg.sender] + msg.value;
    }

    function executeUserOp(UserOperation calldata userOp, uint256 requiredPrefund) external {
        if (userOp.sender.code.length == 0) {
            require(userOp.initCode.length >= 20, "Invalid initCode provided");
            require(userOp.sender == senderCreator.createSender(userOp.initCode), "Could not create expected account");
        }

        require(gasleft() > userOp.verificationGasLimit, "Not enough gas for verification");

        Account(userOp.sender).validateUserOp{gas: userOp.verificationGasLimit}(userOp, bytes32(0), requiredPrefund);
        uint256 userBalance = balances[userOp.sender];
        if (userBalance < requiredPrefund) {
            revert NotEnoughFunds(requiredPrefund, userBalance);
        }
        balances[userOp.sender] = userBalance - requiredPrefund;

        if (!_validateAndUpdateNonce(userOp.sender, userOp.nonce)) {
            revert InvalidNonce(userOp.nonce);
        }

        require(gasleft() > userOp.callGasLimit, "Not enough gas for execution");
        userOp.sender.call{gas: userOp.callGasLimit}(userOp.callData);
    }

    function getNonce(address sender, uint192 key) external view override returns (uint256 nonce) {
        return nonceSequenceNumber[sender][key] | (uint256(key) << 64);
    }

    function incrementNonce(uint192 key) external override {
        nonceSequenceNumber[msg.sender][key]++;
    }

    function _validateAndUpdateNonce(address sender, uint256 nonce) internal returns (bool) {
        uint192 key = uint192(nonce >> 64);
        uint64 seq = uint64(nonce);
        return nonceSequenceNumber[sender][key]++ == seq;
    }
}

1	// SPDX-License-Identifier: LGPL-3.0-only
2	pragma solidity >=0.8.0;
3	import {INonceManager} from "../interfaces/ERC4337.sol";
4	import {UserOperation, UserOperationLib} from "../UserOperation.sol";
5
6	interface Account {
7	function validateUserOp(
8	UserOperation calldata userOp,
9	bytes32,
10	uint256 requiredPrefund
11	) external returns (uint256);
12	}
13
14	/**
15	* helper contract for EntryPoint, to call userOp.initCode from a "neutral" address,
16	* which is explicitly not the entryPoint itself.
17	*/
18	contract SenderCreator {
19	/**
20	* call the "initCode" factory to create and return the sender account address
21	* @param initCode the initCode value from a UserOp. contains 20 bytes of factory address, followed by calldata
22	* @return sender the returned address of the created account, or zero address on failure.
23	*/
24	function createSender(bytes calldata initCode) external returns (address sender) {
25	address factory = address(bytes20(initCode[0:20]));	2✔
26	bytes memory initCallData = initCode[20:];	2✔
27	bool success;	2✔
28	/* solhint-disable no-inline-assembly */
29	assembly {	2✔
30	success := call(gas(), factory, 0, add(initCallData, 0x20), mload(initCallData), 0, 32)
31	sender := mload(0)
32	}
33	if (!success) {	2!
34	sender = address(0);	×
35	}
36	}
37	}
38
39	contract TestEntryPoint is INonceManager {
40	error NotEnoughFunds(uint256 expected, uint256 available);
41	error InvalidNonce(uint256 userNonce);
42	SenderCreator public immutable senderCreator;
43	mapping(address => uint256) balances;
44	mapping(address => mapping(uint192 => uint256)) public nonceSequenceNumber;
45
46	constructor() {
47	senderCreator = new SenderCreator();	13✔
48	}
49
50	receive() external payable {
51	balances[msg.sender] = balances[msg.sender] + msg.value;	3✔
52	}
53
54	function executeUserOp(UserOperation calldata userOp, uint256 requiredPrefund) external {
55	if (userOp.sender.code.length == 0) {	6✔
56	require(userOp.initCode.length >= 20, "Invalid initCode provided");	2!
57	require(userOp.sender == senderCreator.createSender(userOp.initCode), "Could not create expected account");	2!
58	}
59
60	require(gasleft() > userOp.verificationGasLimit, "Not enough gas for verification");	6!
61
62	Account(userOp.sender).validateUserOp{gas: userOp.verificationGasLimit}(userOp, bytes32(0), requiredPrefund);	6✔
63	uint256 userBalance = balances[userOp.sender];	6✔
64	if (userBalance < requiredPrefund) {	6!
65	revert NotEnoughFunds(requiredPrefund, userBalance);	×
66	}
67	balances[userOp.sender] = userBalance - requiredPrefund;	6✔
68
69	if (!_validateAndUpdateNonce(userOp.sender, userOp.nonce)) {	6!
70	revert InvalidNonce(userOp.nonce);	×
71	}
72
73	require(gasleft() > userOp.callGasLimit, "Not enough gas for execution");	6!
74	userOp.sender.call{gas: userOp.callGasLimit}(userOp.callData);	6✔
75	}
76
77	function getNonce(address sender, uint192 key) external view override returns (uint256 nonce) {
78	return nonceSequenceNumber[sender][key] \| (uint256(key) << 64);	6✔
79	}
80
81	function incrementNonce(uint192 key) external override {
82	nonceSequenceNumber[msg.sender][key]++;	×
83	}
84
85	function _validateAndUpdateNonce(address sender, uint256 nonce) internal returns (bool) {
86	uint192 key = uint192(nonce >> 64);	6✔
87	uint64 seq = uint64(nonce);	6✔
88	return nonceSequenceNumber[sender][key]++ == seq;	6✔
89	}
90	}

safe-global / safe-modules / 6469424629

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous