BaseAccount

This method returns the next sequential nonce.

function getNonce() public view virtual returns (uint256) {
    return entryPoint().getNonce(address(this), 0);
}

Subclass should return the current entryPoint used by this account.

function entryPoint() public view virtual returns (IEntryPoint);

Validate user's signature and nonce.

Subclass doesn't need to override this method. Instead, it should override the specific internal validation methods.

function validateUserOp(
    UserOperation calldata userOp,
    bytes32 userOpHash,
    uint256 missingAccountFunds
) external virtual override returns (uint256 validationData) {
    _requireFromEntryPoint();
    validationData = _validateSignature(userOp, userOpHash);
    _validateNonce(userOp.nonce);
    _payPrefund(missingAccountFunds);
}

Ensure the request comes from the known entrypoint.

function _requireFromEntryPoint() internal view virtual {
    require(msg.sender == address(entryPoint()), "account: not from EntryPoint");
}

Validate the signature is valid for this message.

function _validateSignature(UserOperation calldata userOp, bytes32 userOpHash)
    internal
    virtual
    returns (uint256 validationData);

Validate the userOp.signature field

the hash of the request, to check the signature against (also hashes the entrypoint and chain id)

signature and time-range of this operation:

• sigAuthorizer - 0 for valid signature, 1 to mark signature failure, otherwise, an address of an "authorizer" contract.
• validUntil - last timestamp this operation is valid. 0 for "indefinite"
• validAfter - first timestamp this operation is valid.

Validate the nonce of the UserOperation. To limit the nonce to use sequenced UserOps only (no "out of order" UserOps):

• require(nonce < type(uint64).max)

For a hypothetical account that requires the nonce to be out-of-order:

• require(nonce & type(uint64).max == 0)

The actual nonce uniqueness is managed by the EntryPoint, and thus no other action is needed by the account itself.

function _validateNonce(uint256 nonce) internal view virtual {}

uint256 representing the nonce to validate.

Sends to the entrypoint (msg.sender) the missing funds for this transaction. Subclass MAY override this method for better funds management

For example, send to the entryPoint more than the minimum required, so that in future transactions it will not be required to send again.

function _payPrefund(uint256 missingAccountFunds) internal virtual {
    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.)
    }
}

The minimum value this method should send the entrypoint. This value MAY be zero, in case there is enough deposit, or the userOp has a paymaster.