8661138122

Committed 12 Apr 2024 11:10AM UTC coverage: 85.315% (+0.5%) from 84.828%

Build # 8661138122

Build Type

push

github

Committed by

web-flow

Commit Message

Add NatSpec Documentation To The Safe Launchpad (#376)

Related to #308

This PR adds NatSpec documentation to the `SafeSignerLaunchpad` contract
for all methods. This is done in preparation for an auditing these
contracts and as a precursor to getting 100% test coverage.

In writing this PR, I found some issues with the current launchpad
implementation that need to be addressed pre-audit:
- We allow accounts that haven't been properly initialized, which can be
a security risk. We should do checks similar to the Safe `setup` method
to prevent double initialization and the validation should revert if the
account is not initialized.
- We are using revert messages instead of errors.

Additionally, I would like to suggest that we change the implementation
to use a **single** setup instead of doing a pre- and post- setup
delegatecall. This would greatly simplify the implementation and
security assumptions of the launchpad. The downside is that the setup
cannot break 4337 rules, but we do not have a use-case for this, so I
wouldn't implement it.

Run Details

28 of 42 branches covered (66.67%)

Branch coverage included in aggregate %.

13 of 16 new or added lines in 1 file covered. (81.25%)

2 existing lines in 1 file now uncovered.

94 of 101 relevant lines covered (93.07%)

9.26 hits per line

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

74.39

/modules/passkey/contracts/4337/SafeECDSASignerLaunchpad.sol

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.8.0 <0.9.0;

import {IAccount} from "@account-abstraction/contracts/interfaces/IAccount.sol";
import {PackedUserOperation} from "@account-abstraction/contracts/interfaces/PackedUserOperation.sol";
import {_packValidationData} from "@account-abstraction/contracts/core/Helpers.sol";
import {SafeStorage} from "@safe-global/safe-contracts/contracts/libraries/SafeStorage.sol";

import {ICustomECDSASignerFactory} from "../interfaces/ICustomECDSASignerFactory.sol";
import {ISafe} from "../interfaces/ISafe.sol";
import {ERC1271} from "../libraries/ERC1271.sol";

/**
 * @title Safe Launchpad for Custom ECDSA Signing Schemes.
 * @dev A launchpad account implementation that enables the creation of Safes that use custom ECDSA signing schemes that
 * require additional contract deployments over ERC-4337. Note that it is not safe to rely on this launchpad for
 * deploying Safes that has an initial threshold greater than 1. This is because the first user operation (which can
 * freely change the owner structure) will only ever require a single signature to execute, so effectively the initial
 * owner will always have ultimate control over the Safe during the first user operation and can undo any changes to the
 * `threshold` during the `setup` phase.
 * @custom:security-contact bounty@safe.global
 */
contract SafeECDSASignerLaunchpad is IAccount, SafeStorage {
    /**
     * @notice The EIP-712 type-hash for the domain separator used for verifying Safe initialization signatures.
     * @custom:computed-as keccak256("EIP712Domain(uint256 chainId,address verifyingContract)")
     */
    bytes32 private constant DOMAIN_SEPARATOR_TYPEHASH = 0x47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218;

    /**
     * @notice The storage slot used for the initialization hash of account.
     * @custom:computed-as keccak256("SafeSignerLaunchpad.initHash") - 1
     * @dev This value is intentionally computed to be a hash -1 as a precaution to avoid any potential issues from
     * unintended hash collisions.
     */
    uint256 private constant INIT_HASH_SLOT = 0xf69b06f613646416443af565ceba6ea1636a94376678b14dc8481b819746897f;

    /**
     * @notice The keccak256 hash of the EIP-712 SafeInit struct, representing the structure of a ERC-4337 compatible deferred Safe initialization.
     *  {address} singleton - The singleton to evolve into during the setup.
     *  {address} signerFactory - The custom ECDSA signer factory to use for creating an owner.
     *  {uint256} signerX - The X coordinate of the public key of the custom ECDSA signing scheme.
     *  {uint256} signerY - The Y coordinate of the public key of the custom ECDSA signing scheme.
     *  {uint256} signerVerifier - The ECDSA verifier contract used by the custom signing scheme.
     *  {address} setupTo - The contract to `DELEGATECALL` during setup.
     *  {bytes} setupData - The calldata for the setup `DELEGATECALL`.
     *  {address} fallbackHandler - The fallback handler to initialize the Safe with.
     * @custom:computed-as keccak256("SafeInit(address singleton,address signerFactory,uint256 signerX,uint256 signerY,address signerVerifier,address setupTo,bytes setupData,address fallbackHandler)")
     */
    bytes32 private constant SAFE_INIT_TYPEHASH = 0x7f7af906ef00923ea8f1b598abfc8ac66033c2807e9facdf52353f813dd7c747;

    /**
     * @notice The keccak256 hash of the EIP-712 SafeInitOp struct, representing the user operation to execute alongside initialization.
     *  {bytes32} userOpHash - The user operation hash being executed.
     *  {uint48} validAfter - A timestamp representing from when the user operation is valid.
     *  {uint48} validUntil - A timestamp representing until when the user operation is valid, or 0 to indicated "forever".
     *  {address} entryPoint - The address of the entry point that will execute the user operation.
     * @custom:computed-as keccak256("SafeInitOp(bytes32 userOpHash,uint48 validAfter,uint48 validUntil,address entryPoint)")
     */
    bytes32 private constant SAFE_INIT_OP_TYPEHASH = 0x25838d3914a61e3531f21f12b8cd3110a5f9d478292d07dd197859a5c4eaacb2;

    /**
     * @dev Address of the launchpad contract itself. it is used for determining whether or not the contract is being
     * `DELEGATECALL`-ed from a proxy.
     */
    address private immutable SELF;

    /**
     * @notice The address of the ERC-4337 entry point contract that this launchpad supports.
     */
    address public immutable SUPPORTED_ENTRYPOINT;

    /**
     * @notice Create a new launchpad contract instance.
     * @param entryPoint The address of the ERC-4337 entry point contract that this launchpad supports.
     */
    constructor(address entryPoint) {
        require(entryPoint != address(0), "Invalid entry point");

        SELF = address(this);
        SUPPORTED_ENTRYPOINT = entryPoint;
    }

    /**
     * @notice Validates the call is done via a proxy contract via `DELEGATECALL`, and that the launchpad is not being
     * called directly.
     */
    modifier onlyProxy() {
        require(singleton == SELF, "Not called from proxy");
        _;
    }

    /**
     * @notice Validates the call is initiated by the supported entry point.
     */
    modifier onlySupportedEntryPoint() {
        require(msg.sender == SUPPORTED_ENTRYPOINT, "Unsupported entry point");
        _;
    }

    /**
     * @notice Accept transfers.
     * @dev The launchpad accepts transfers to allow funding of the account in case it was deployed and initialized
     * without pre-funding.
     */
    receive() external payable {}

    /**
     * @notice Performs pre-validation setup by storing the hash of the {SafeInit} and optionally `DELEGATECALL`s to a
     * `preInitializer` contract to perform some initial setup.
     * @dev Requirements:
     * - The function can only be called by a proxy contract.
     * - The `DELEGATECALL` to the `preInitializer` address must succeed.
     * @param initHash The initialization hash.
     * @param preInitializer The address to `DELEGATECALL`.
     * @param preInitializerData The pre-initialization call data.
     */
    function preValidationSetup(bytes32 initHash, address preInitializer, bytes calldata preInitializerData) external onlyProxy {
        _setInitHash(initHash);
        if (preInitializer != address(0)) {
            (bool success, ) = preInitializer.delegatecall(preInitializerData);
            require(success, "Pre-initialization failed");
        }
    }

    /**
     * @notice Compute an {SafeInit} hash that uniquely identifies a Safe configuration.
     * @dev The hash is generated using the keccak256 hash function and the EIP-712 standard. It includes setup
     * parameters to ensure that deployments with the Safe proxy factory have a unique and deterministic address for a
     * given configuration.
     * @param singleton The singleton to evolve into during the setup.
     * @param signerFactory The custom ECDSA signer factory to use for creating an owner.
     * @param signerX The X coordinate of the signer's public key.
     * @param signerY The Y coordinate of the signer's public key.
     * @param signerVerifier The address of the contract that verifies the signer's signature.
     * @param setupTo The contract to `DELEGATECALL` during setup.
     * @param setupData The calldata for the setup `DELEGATECALL`.
     * @param fallbackHandler The fallback handler to initialize the Safe with.
     * @return initHash The unique initialization hash for the Safe.
     */
    function getInitHash(
        address singleton,
        address signerFactory,
        uint256 signerX,
        uint256 signerY,
        address signerVerifier,
        address setupTo,
        bytes memory setupData,
        address fallbackHandler
    ) public view returns (bytes32 initHash) {
        initHash = keccak256(
            abi.encodePacked(
                bytes1(0x19),
                bytes1(0x01),
                domainSeparator(),
                keccak256(
                    abi.encode(
                        SAFE_INIT_TYPEHASH,
                        singleton,
                        signerFactory,
                        signerX,
                        signerY,
                        signerVerifier,
                        setupTo,
                        keccak256(setupData),
                        fallbackHandler
                    )
                )
            )
        );
    }

    /**
     * @notice Compute the {SafeInitOp} hash of the first user operation that initializes the Safe.
     * @dev The hash is generated using the keccak256 hash function and the EIP-712 standard. It is signed by the Safe
     * owner that is specified as part of the {SafeInit}. Using a completely separate hash from the {SafeInit} allows
     * the account address to remain the same regardless of the first user operation that gets executed by the account.
     * @param userOpHash The ERC-4337 user operation hash.
     * @param validAfter The timestamp the user operation is valid from.
     * @param validUntil The timestamp the user operation is valid until.
     * @return operationHash The Safe initialization user operation hash.
     */
    function getOperationHash(bytes32 userOpHash, uint48 validAfter, uint48 validUntil) public view returns (bytes32 operationHash) {
        operationHash = keccak256(
            abi.encodePacked(
                bytes1(0x19),
                bytes1(0x01),
                domainSeparator(),
                keccak256(abi.encode(SAFE_INIT_OP_TYPEHASH, userOpHash, validAfter, validUntil, SUPPORTED_ENTRYPOINT))
            )
        );
    }

    /**
     * @notice Validates a user operation provided by the entry point.
     * @inheritdoc IAccount
     */
    function validateUserOp(
        PackedUserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external override onlyProxy onlySupportedEntryPoint returns (uint256 validationData) {
        address signerFactory;
        uint256 signerX;
        uint256 signerY;
        address signerVerifier;
        {
            require(this.initializeThenUserOp.selector == bytes4(userOp.callData[:4]), "invalid user operation data");

            address singleton;
            address setupTo;
            bytes memory setupData;
            address fallbackHandler;
            (singleton, signerFactory, signerX, signerY, signerVerifier, setupTo, setupData, fallbackHandler, ) = abi.decode(
                userOp.callData[4:],
                (address, address, uint256, uint256, address, address, bytes, address, bytes)
            );
            bytes32 initHash = getInitHash(singleton, signerFactory, signerX, signerY, signerVerifier, setupTo, setupData, fallbackHandler);

            require(initHash == _initHash(), "invalid init hash");
        }

        validationData = _validateSignatures(userOp, userOpHash, signerFactory, signerX, signerY, signerVerifier);
        if (missingAccountFunds > 0) {
            // solhint-disable-next-line no-inline-assembly
            assembly ("memory-safe") {
                // The `pop` is necessary here because solidity 0.5.0 enforces "strict" assembly blocks and "statements
                // (elements of a block) are disallowed if they return something onto the stack at the end". This is not
                // well documented, the quote is taken from <https://github.com/ethereum/solidity/issues/1820>. The
                // compiler will throw an error if we keep the success value on the stack
                pop(call(gas(), caller(), missingAccountFunds, 0, 0, 0, 0))
            }
        }
    }

    /**
     * @notice Completes the account initialization and then executes a user operation.
     * @dev This function is only ever called by the entry point as part of the execution phase of the user operation.
     * It is responsible for promoting the account into a Safe. Validation of the parameters, that they match the
     * {SafeInit} hash that was specified at account construction, is done by {validateUserOp} as part of the the
     * ERC-4337 user operation validation phase.
     * @param singleton The Safe singleton address to promote the account into.
     * @param signerFactory The custom ECDSA signer factory to use for creating an owner.
     * @param signerX The X coordinate of the signer's public key.
     * @param signerY The Y coordinate of the signer's public key.
     * @param signerVerifier The address of the contract that verifies the signer's signature.
     * @param setupTo The contract to `DELEGATECALL` during setup.
     * @param setupData The calldata for the setup `DELEGATECALL`.
     * @param fallbackHandler The fallback handler to initialize the Safe with.
     * @param callData The calldata to `DELEGATECALL` self with in order to actually execute the user operation.
     */
    function initializeThenUserOp(
        address singleton,
        address signerFactory,
        uint256 signerX,
        uint256 signerY,
        address signerVerifier,
        address setupTo,
        bytes calldata setupData,
        address fallbackHandler,
        bytes memory callData
    ) external onlySupportedEntryPoint {
        SafeStorage.singleton = singleton;
        {
            address[] memory owners = new address[](1);
            owners[0] = ICustomECDSASignerFactory(signerFactory).createSigner(signerX, signerY, signerVerifier);

            ISafe(address(this)).setup(owners, 1, setupTo, setupData, fallbackHandler, address(0), 0, payable(address(0)));
        }

        (bool success, bytes memory returnData) = address(this).delegatecall(callData);
        if (!success) {
            // solhint-disable-next-line no-inline-assembly
            assembly ("memory-safe") {
                revert(add(returnData, 0x20), mload(returnData))
            }
        }

        _setInitHash(0);
    }

    /**
     * @notice Computes the EIP-712 domain separator for Safe launchpad operations.
     * @return domainSeparatorHash The EIP-712 domain separator hash for this contract.
     */
    function domainSeparator() public view returns (bytes32) {
        return keccak256(abi.encode(DOMAIN_SEPARATOR_TYPEHASH, block.chainid, SELF));
    }

    /**
     * @dev Validates that the user operation is correctly signed and returns an ERC-4337 packed validation data
     * of `validAfter || validUntil || authorizer`:
     *  - `authorizer`: 20-byte address, 0 for valid signature or 1 to mark signature failure (this module does not make use of signature aggregators).
     *  - `validUntil`: 6-byte timestamp value, or zero for "infinite". The user operation is valid only up to this time.
     *  - `validAfter`: 6-byte timestamp. The user operation is valid only after this time.
     * @param userOp User operation struct.
     * @return validationData An integer indicating the result of the validation.
     */
    function _validateSignatures(
        PackedUserOperation calldata userOp,
        bytes32 userOpHash,
        address signerFactory,
        uint256 signerX,
        uint256 signerY,
        address signerVerifier
    ) internal view returns (uint256 validationData) {
        uint48 validAfter;
        uint48 validUntil;
        bytes calldata signature;
        {
            bytes calldata sig = userOp.signature;
            validAfter = uint48(bytes6(sig[0:6]));
            validUntil = uint48(bytes6(sig[6:12]));
            signature = sig[12:];
        }

        bytes32 operationHash = getOperationHash(userOpHash, validAfter, validUntil);
        try
            ICustomECDSASignerFactory(signerFactory).isValidSignatureForSigner(operationHash, signature, signerX, signerY, signerVerifier)
        returns (bytes4 magicValue) {
            // The timestamps are validated by the entry point, therefore we will not check them again
            validationData = _packValidationData(magicValue != ERC1271.MAGIC_VALUE, validUntil, validAfter);
        } catch {
            validationData = _packValidationData(true, validUntil, validAfter);
        }
    }

    /**
     * @notice Reads the configured initialization hash from storage.
     * @return value The value of the init hash read from storage.
     */
    function _initHash() public view returns (bytes32 value) {
        // solhint-disable-next-line no-inline-assembly
        assembly ("memory-safe") {
            value := sload(INIT_HASH_SLOT)
        }
    }

    /**
     * @notice Sets an initialization hash in storage.
     * @param value The value of the init hash to set in storage.
     */
    function _setInitHash(bytes32 value) internal {
        // solhint-disable-next-line no-inline-assembly
        assembly ("memory-safe") {
            sstore(INIT_HASH_SLOT, value)
        }
    }

    /**
     * @notice Returns whether or not an account is a contract.
     * @dev The current implementation the accounts code size is non-zero to determine whether or not the account is a
     * contract.
     * @param account The account to check.
     * @return isContract Whether or not the account is a contract.
     */
    function _isContract(address account) internal view returns (bool isContract) {
        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly ("memory-safe") {
            size := extcodesize(account)
        }
        isContract = size > 0;
    }
}

1	// SPDX-License-Identifier: LGPL-3.0-only
2	pragma solidity >=0.8.0 <0.9.0;
3
4	import {IAccount} from "@account-abstraction/contracts/interfaces/IAccount.sol";
5	import {PackedUserOperation} from "@account-abstraction/contracts/interfaces/PackedUserOperation.sol";
6	import {_packValidationData} from "@account-abstraction/contracts/core/Helpers.sol";
7	import {SafeStorage} from "@safe-global/safe-contracts/contracts/libraries/SafeStorage.sol";
8
9	import {ICustomECDSASignerFactory} from "../interfaces/ICustomECDSASignerFactory.sol";
10	import {ISafe} from "../interfaces/ISafe.sol";
11	import {ERC1271} from "../libraries/ERC1271.sol";
12
13	/**
14	* @title Safe Launchpad for Custom ECDSA Signing Schemes.
15	* @dev A launchpad account implementation that enables the creation of Safes that use custom ECDSA signing schemes that
16	* require additional contract deployments over ERC-4337. Note that it is not safe to rely on this launchpad for
17	* deploying Safes that has an initial threshold greater than 1. This is because the first user operation (which can
18	* freely change the owner structure) will only ever require a single signature to execute, so effectively the initial
19	* owner will always have ultimate control over the Safe during the first user operation and can undo any changes to the
20	* `threshold` during the `setup` phase.
21	* @custom:security-contact bounty@safe.global
22	*/
23	contract SafeECDSASignerLaunchpad is IAccount, SafeStorage {
24	/**
25	* @notice The EIP-712 type-hash for the domain separator used for verifying Safe initialization signatures.
26	* @custom:computed-as keccak256("EIP712Domain(uint256 chainId,address verifyingContract)")
27	*/
28	bytes32 private constant DOMAIN_SEPARATOR_TYPEHASH = 0x47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218;
29
30	/**
31	* @notice The storage slot used for the initialization hash of account.
32	* @custom:computed-as keccak256("SafeSignerLaunchpad.initHash") - 1
33	* @dev This value is intentionally computed to be a hash -1 as a precaution to avoid any potential issues from
34	* unintended hash collisions.
35	*/
36	uint256 private constant INIT_HASH_SLOT = 0xf69b06f613646416443af565ceba6ea1636a94376678b14dc8481b819746897f;
37
38	/**
39	* @notice The keccak256 hash of the EIP-712 SafeInit struct, representing the structure of a ERC-4337 compatible deferred Safe initialization.
40	* {address} singleton - The singleton to evolve into during the setup.
41	* {address} signerFactory - The custom ECDSA signer factory to use for creating an owner.
42	* {uint256} signerX - The X coordinate of the public key of the custom ECDSA signing scheme.
43	* {uint256} signerY - The Y coordinate of the public key of the custom ECDSA signing scheme.
44	* {uint256} signerVerifier - The ECDSA verifier contract used by the custom signing scheme.
45	* {address} setupTo - The contract to `DELEGATECALL` during setup.
46	* {bytes} setupData - The calldata for the setup `DELEGATECALL`.
47	* {address} fallbackHandler - The fallback handler to initialize the Safe with.
48	* @custom:computed-as keccak256("SafeInit(address singleton,address signerFactory,uint256 signerX,uint256 signerY,address signerVerifier,address setupTo,bytes setupData,address fallbackHandler)")
49	*/
50	bytes32 private constant SAFE_INIT_TYPEHASH = 0x7f7af906ef00923ea8f1b598abfc8ac66033c2807e9facdf52353f813dd7c747;
51
52	/**
53	* @notice The keccak256 hash of the EIP-712 SafeInitOp struct, representing the user operation to execute alongside initialization.
54	* {bytes32} userOpHash - The user operation hash being executed.
55	* {uint48} validAfter - A timestamp representing from when the user operation is valid.
56	* {uint48} validUntil - A timestamp representing until when the user operation is valid, or 0 to indicated "forever".
57	* {address} entryPoint - The address of the entry point that will execute the user operation.
58	* @custom:computed-as keccak256("SafeInitOp(bytes32 userOpHash,uint48 validAfter,uint48 validUntil,address entryPoint)")
59	*/
60	bytes32 private constant SAFE_INIT_OP_TYPEHASH = 0x25838d3914a61e3531f21f12b8cd3110a5f9d478292d07dd197859a5c4eaacb2;
61
62	/**
63	* @dev Address of the launchpad contract itself. it is used for determining whether or not the contract is being
64	* `DELEGATECALL`-ed from a proxy.
65	*/
66	address private immutable SELF;
67
68	/**
69	* @notice The address of the ERC-4337 entry point contract that this launchpad supports.
70	*/
71	address public immutable SUPPORTED_ENTRYPOINT;
72
73	/**
74	* @notice Create a new launchpad contract instance.
75	* @param entryPoint The address of the ERC-4337 entry point contract that this launchpad supports.
76	*/
77	constructor(address entryPoint) {
78	require(entryPoint != address(0), "Invalid entry point");	13!
79
80	SELF = address(this);	13✔
81	SUPPORTED_ENTRYPOINT = entryPoint;	13✔
82	}
83
84	/**
85	* @notice Validates the call is done via a proxy contract via `DELEGATECALL`, and that the launchpad is not being
86	* called directly.
87	*/
88	modifier onlyProxy() {
89	require(singleton == SELF, "Not called from proxy");	3!
90	_;	3✔
91	}
92
93	/**
94	* @notice Validates the call is initiated by the supported entry point.
95	*/
96	modifier onlySupportedEntryPoint() {
97	require(msg.sender == SUPPORTED_ENTRYPOINT, "Unsupported entry point");	2!
98	_;	2✔
99	}
100
101	/**
102	* @notice Accept transfers.
103	* @dev The launchpad accepts transfers to allow funding of the account in case it was deployed and initialized
104	* without pre-funding.
105	*/
106	receive() external payable {}
107
108	/**
109	* @notice Performs pre-validation setup by storing the hash of the {SafeInit} and optionally `DELEGATECALL`s to a
110	* `preInitializer` contract to perform some initial setup.
111	* @dev Requirements:
112	* - The function can only be called by a proxy contract.
113	* - The `DELEGATECALL` to the `preInitializer` address must succeed.
114	* @param initHash The initialization hash.
115	* @param preInitializer The address to `DELEGATECALL`.
116	* @param preInitializerData The pre-initialization call data.
117	*/
118	function preValidationSetup(bytes32 initHash, address preInitializer, bytes calldata preInitializerData) external onlyProxy {	2!
119	_setInitHash(initHash);	2✔
120	if (preInitializer != address(0)) {	2!
NEW 121	(bool success, ) = preInitializer.delegatecall(preInitializerData);	×
UNCOV 122	require(success, "Pre-initialization failed");	×
123	}
124	}
125
126	/**
127	* @notice Compute an {SafeInit} hash that uniquely identifies a Safe configuration.
128	* @dev The hash is generated using the keccak256 hash function and the EIP-712 standard. It includes setup
129	* parameters to ensure that deployments with the Safe proxy factory have a unique and deterministic address for a
130	* given configuration.
131	* @param singleton The singleton to evolve into during the setup.
132	* @param signerFactory The custom ECDSA signer factory to use for creating an owner.
133	* @param signerX The X coordinate of the signer's public key.
134	* @param signerY The Y coordinate of the signer's public key.
135	* @param signerVerifier The address of the contract that verifies the signer's signature.
136	* @param setupTo The contract to `DELEGATECALL` during setup.
137	* @param setupData The calldata for the setup `DELEGATECALL`.
138	* @param fallbackHandler The fallback handler to initialize the Safe with.
139	* @return initHash The unique initialization hash for the Safe.
140	*/
141	function getInitHash(
142	address singleton,
143	address signerFactory,
144	uint256 signerX,
145	uint256 signerY,
146	address signerVerifier,
147	address setupTo,
148	bytes memory setupData,
149	address fallbackHandler
150	) public view returns (bytes32 initHash) {
151	initHash = keccak256(	2✔
152	abi.encodePacked(
153	bytes1(0x19),
154	bytes1(0x01),
155	domainSeparator(),
156	keccak256(
157	abi.encode(
158	SAFE_INIT_TYPEHASH,
159	singleton,
160	signerFactory,
161	signerX,
162	signerY,
163	signerVerifier,
164	setupTo,
165	keccak256(setupData),
166	fallbackHandler
167	)
168	)
169	)
170	);
171	}
172
173	/**
174	* @notice Compute the {SafeInitOp} hash of the first user operation that initializes the Safe.
175	* @dev The hash is generated using the keccak256 hash function and the EIP-712 standard. It is signed by the Safe
176	* owner that is specified as part of the {SafeInit}. Using a completely separate hash from the {SafeInit} allows
177	* the account address to remain the same regardless of the first user operation that gets executed by the account.
178	* @param userOpHash The ERC-4337 user operation hash.
179	* @param validAfter The timestamp the user operation is valid from.
180	* @param validUntil The timestamp the user operation is valid until.
181	* @return operationHash The Safe initialization user operation hash.
182	*/
183	function getOperationHash(bytes32 userOpHash, uint48 validAfter, uint48 validUntil) public view returns (bytes32 operationHash) {
184	operationHash = keccak256(	1✔
185	abi.encodePacked(
186	bytes1(0x19),
187	bytes1(0x01),
188	domainSeparator(),
189	keccak256(abi.encode(SAFE_INIT_OP_TYPEHASH, userOpHash, validAfter, validUntil, SUPPORTED_ENTRYPOINT))
190	)
191	);
192	}
193
194	/**
195	* @notice Validates a user operation provided by the entry point.
196	* @inheritdoc IAccount
197	*/
198	function validateUserOp(
199	PackedUserOperation calldata userOp,
200	bytes32 userOpHash,
201	uint256 missingAccountFunds
202	) external override onlyProxy onlySupportedEntryPoint returns (uint256 validationData) {	2!
203	address signerFactory;	1✔
204	uint256 signerX;	1✔
205	uint256 signerY;	1✔
206	address signerVerifier;	1✔
207	{	1✔
208	require(this.initializeThenUserOp.selector == bytes4(userOp.callData[:4]), "invalid user operation data");	1!
209
210	address singleton;	1✔
211	address setupTo;	1✔
212	bytes memory setupData;	1✔
213	address fallbackHandler;	1✔
214	(singleton, signerFactory, signerX, signerY, signerVerifier, setupTo, setupData, fallbackHandler, ) = abi.decode(	1✔
215	userOp.callData[4:],
216	(address, address, uint256, uint256, address, address, bytes, address, bytes)
217	);
218	bytes32 initHash = getInitHash(singleton, signerFactory, signerX, signerY, signerVerifier, setupTo, setupData, fallbackHandler);	1✔
219
220	require(initHash == _initHash(), "invalid init hash");	1!
221	}
222
223	validationData = _validateSignatures(userOp, userOpHash, signerFactory, signerX, signerY, signerVerifier);	1✔
224	if (missingAccountFunds > 0) {	1!
225	// solhint-disable-next-line no-inline-assembly
226	assembly ("memory-safe") {	1✔
227	// The `pop` is necessary here because solidity 0.5.0 enforces "strict" assembly blocks and "statements
228	// (elements of a block) are disallowed if they return something onto the stack at the end". This is not
229	// well documented, the quote is taken from <https://github.com/ethereum/solidity/issues/1820>. The
230	// compiler will throw an error if we keep the success value on the stack
231	pop(call(gas(), caller(), missingAccountFunds, 0, 0, 0, 0))
232	}
233	}
234	}
235
236	/**
237	* @notice Completes the account initialization and then executes a user operation.
238	* @dev This function is only ever called by the entry point as part of the execution phase of the user operation.
239	* It is responsible for promoting the account into a Safe. Validation of the parameters, that they match the
240	* {SafeInit} hash that was specified at account construction, is done by {validateUserOp} as part of the the
241	* ERC-4337 user operation validation phase.
242	* @param singleton The Safe singleton address to promote the account into.
243	* @param signerFactory The custom ECDSA signer factory to use for creating an owner.
244	* @param signerX The X coordinate of the signer's public key.
245	* @param signerY The Y coordinate of the signer's public key.
246	* @param signerVerifier The address of the contract that verifies the signer's signature.
247	* @param setupTo The contract to `DELEGATECALL` during setup.
248	* @param setupData The calldata for the setup `DELEGATECALL`.
249	* @param fallbackHandler The fallback handler to initialize the Safe with.
250	* @param callData The calldata to `DELEGATECALL` self with in order to actually execute the user operation.
251	*/
252	function initializeThenUserOp(
253	address singleton,
254	address signerFactory,
255	uint256 signerX,
256	uint256 signerY,
257	address signerVerifier,
258	address setupTo,
259	bytes calldata setupData,
260	address fallbackHandler,
261	bytes memory callData
262	) external onlySupportedEntryPoint {	1!
263	SafeStorage.singleton = singleton;	1✔
264	{	1✔
265	address[] memory owners = new address[](1);	1✔
266	owners[0] = ICustomECDSASignerFactory(signerFactory).createSigner(signerX, signerY, signerVerifier);	1✔
267
268	ISafe(address(this)).setup(owners, 1, setupTo, setupData, fallbackHandler, address(0), 0, payable(address(0)));	1✔
269	}
270
271	(bool success, bytes memory returnData) = address(this).delegatecall(callData);	1✔
272	if (!success) {	1!
273	// solhint-disable-next-line no-inline-assembly
274	assembly ("memory-safe") {	×
275	revert(add(returnData, 0x20), mload(returnData))
276	}
277	}
278
279	_setInitHash(0);	1✔
280	}
281
282	/**
283	* @notice Computes the EIP-712 domain separator for Safe launchpad operations.
284	* @return domainSeparatorHash The EIP-712 domain separator hash for this contract.
285	*/
286	function domainSeparator() public view returns (bytes32) {
287	return keccak256(abi.encode(DOMAIN_SEPARATOR_TYPEHASH, block.chainid, SELF));	3✔
288	}
289
290	/**
291	* @dev Validates that the user operation is correctly signed and returns an ERC-4337 packed validation data
292	* of `validAfter \|\| validUntil \|\| authorizer`:
293	* - `authorizer`: 20-byte address, 0 for valid signature or 1 to mark signature failure (this module does not make use of signature aggregators).
294	* - `validUntil`: 6-byte timestamp value, or zero for "infinite". The user operation is valid only up to this time.
295	* - `validAfter`: 6-byte timestamp. The user operation is valid only after this time.
296	* @param userOp User operation struct.
297	* @return validationData An integer indicating the result of the validation.
298	*/
299	function _validateSignatures(
300	PackedUserOperation calldata userOp,
301	bytes32 userOpHash,
302	address signerFactory,
303	uint256 signerX,
304	uint256 signerY,
305	address signerVerifier
306	) internal view returns (uint256 validationData) {
307	uint48 validAfter;	1✔
308	uint48 validUntil;	1✔
309	bytes calldata signature;	1✔
310	{	1✔
311	bytes calldata sig = userOp.signature;	1✔
312	validAfter = uint48(bytes6(sig[0:6]));	1✔
313	validUntil = uint48(bytes6(sig[6:12]));	1✔
314	signature = sig[12:];	1✔
315	}
316
317	bytes32 operationHash = getOperationHash(userOpHash, validAfter, validUntil);	1✔
318	try	1✔
319	ICustomECDSASignerFactory(signerFactory).isValidSignatureForSigner(operationHash, signature, signerX, signerY, signerVerifier)
320	returns (bytes4 magicValue) {
321	// The timestamps are validated by the entry point, therefore we will not check them again
322	validationData = _packValidationData(magicValue != ERC1271.MAGIC_VALUE, validUntil, validAfter);	1✔
323	} catch {
NEW 324	validationData = _packValidationData(true, validUntil, validAfter);	×
325	}
326	}
327
328	/**
329	* @notice Reads the configured initialization hash from storage.
330	* @return value The value of the init hash read from storage.
331	*/
332	function _initHash() public view returns (bytes32 value) {
333	// solhint-disable-next-line no-inline-assembly
334	assembly ("memory-safe") {	1✔
335	value := sload(INIT_HASH_SLOT)
336	}
337	}
338
339	/**
340	* @notice Sets an initialization hash in storage.
341	* @param value The value of the init hash to set in storage.
342	*/
343	function _setInitHash(bytes32 value) internal {
344	// solhint-disable-next-line no-inline-assembly
345	assembly ("memory-safe") {	3✔
346	sstore(INIT_HASH_SLOT, value)
347	}
348	}
349
350	/**
351	* @notice Returns whether or not an account is a contract.
352	* @dev The current implementation the accounts code size is non-zero to determine whether or not the account is a
353	* contract.
354	* @param account The account to check.
355	* @return isContract Whether or not the account is a contract.
356	*/
357	function _isContract(address account) internal view returns (bool isContract) {
UNCOV 358	uint256 size;	×
359	// solhint-disable-next-line no-inline-assembly
360	assembly ("memory-safe") {	×
361	size := extcodesize(account)
362	}
NEW 363	isContract = size > 0;	×
364	}
365	}

safe-global / safe-modules / 8661138122

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