EIP7702DeleGatorCore.sol

// SPDX-License-Identifier: MIT AND Apache-2.0
pragma solidity 0.8.23;

import { IEntryPoint } from "@account-abstraction/interfaces/IEntryPoint.sol";
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { IERC1271 } from "@openzeppelin/contracts/interfaces/IERC1271.sol";
import { IERC1155Receiver } from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import { IERC721Receiver } from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import { ModeLib } from "@erc7579/lib/ModeLib.sol";
import { ExecutionLib } from "@erc7579/lib/ExecutionLib.sol";
import { ExecutionHelper } from "@erc7579/core/ExecutionHelper.sol";
import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";

import { ERC1271Lib } from "../libraries/ERC1271Lib.sol";
import { IDeleGatorCore } from "../interfaces/IDeleGatorCore.sol";
import { IDelegationManager } from "../interfaces/IDelegationManager.sol";
import { IERC7821 } from "../interfaces/IERC7821.sol";
import {
    CallType, ExecType, ModeSelector, ModePayload, Execution, Delegation, PackedUserOperation, ModeCode
} from "../utils/Types.sol";
import { CALLTYPE_SINGLE, CALLTYPE_BATCH, EXECTYPE_DEFAULT, EXECTYPE_TRY, MODE_DEFAULT } from "../utils/Constants.sol";

/**
 * @title EIP7702DeleGatorCore
 * @notice This contract contains the shared logic for a DeleGator SCA implementation.
 * @dev Implements the interface needed for a DelegationManager to interact with a DeleGator implementation.
 * @dev DeleGator implementations can inherit this to enable Delegation and ERC4337 structure.
 * @dev Any child contract adding state variables must use namespaced storage for safe upgrades.
 */
abstract contract EIP7702DeleGatorCore is
    ExecutionHelper,
    IERC165,
    IERC7821,
    IDeleGatorCore,
    IERC721Receiver,
    IERC1155Receiver,
    EIP712
{
    using ModeLib for ModeCode;
    using ModeLib for ModeSelector;
    using ExecutionLib for bytes;

    ////////////////////////////// State //////////////////////////////

    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
    address private immutable __self = address(this);

    /// @dev The DelegationManager contract that has root access to this contract
    IDelegationManager public immutable delegationManager;

    /// @dev The EntryPoint contract that has root access to this contract
    IEntryPoint public immutable entryPoint;

    /// @dev The typehash for the PackedUserOperation struct
    bytes32 public constant PACKED_USER_OP_TYPEHASH = keccak256(
        "PackedUserOperation(address sender,uint256 nonce,bytes initCode,bytes callData,bytes32 accountGasLimits,uint256 preVerificationGas,bytes32 gasFees,bytes paymasterAndData)"
    );

    ////////////////////////////// Events //////////////////////////////

    /// @dev Emitted once in the constructor when the DelegationManager is assigned
    event SetDelegationManager(IDelegationManager indexed newDelegationManager);

    /// @dev Emitted once in the constructor when the EntryPoint is assigned
    event SetEntryPoint(IEntryPoint indexed entryPoint);

    /// @dev Event emitted when prefunding is sent.
    event SentPrefund(address indexed sender, uint256 amount, bool success);

    ////////////////////////////// Errors //////////////////////////////

    /// @dev Error thrown when the caller is not this contract.
    error NotSelf();

    /// @dev Error thrown when the caller is not the entry point.
    error NotEntryPoint();

    /// @dev Error thrown when the caller is not the EntryPoint or this contract.
    error NotEntryPointOrSelf();

    /// @dev Error thrown when the caller is not the delegation manager.
    error NotDelegationManager();

    /// @dev The call is from an unauthorized context.
    error UnauthorizedCallContext();

    /// @dev Error thrown when an execution with an unsupported CallType was made.
    error UnsupportedCallType(CallType callType);

    /// @dev Error thrown when an execution with an unsupported ExecType was made.
    error UnsupportedExecType(ExecType execType);

    /// @dev The EIP712 name can not be longer than 31 bytes.
    error InvalidEIP712NameLength();

    /// @dev The EIP712 version can not be longer than 31 bytes.
    error InvalidEIP712VersionLength();

    ////////////////////////////// Modifiers //////////////////////////////

    /**
     * @dev Prevents direct calls to the implementation.
     * @dev Check that the execution is being performed through a delegatecall call.
     */
    modifier onlyProxy() {
        if (address(this) == __self) revert UnauthorizedCallContext();
        _;
    }

    /**
     * @notice Require the function call to come from the EntryPoint.
     * @dev Check that the caller is the entry point
     */
    modifier onlyEntryPoint() {
        if (msg.sender != address(entryPoint)) revert NotEntryPoint();
        _;
    }

    /**
     * @notice Require the function call to come from the EntryPoint or this contract.
     * @dev Check that the caller is either the delegator contract itself or the entry point
     */
    modifier onlyEntryPointOrSelf() {
        if (msg.sender != address(entryPoint) && msg.sender != address(this)) revert NotEntryPointOrSelf();
        _;
    }

    /**
     * @notice Require the function call to come from the DelegationManager.
     * @dev Check that the caller is the stored delegation manager.
     */
    modifier onlyDelegationManager() {
        if (msg.sender != address(delegationManager)) revert NotDelegationManager();
        _;
    }

    ////////////////////////////// Constructor //////////////////////////////

    /**
     * @notice Initializes the DeleGatorCore contract
     * @param _delegationManager the address of the trusted DelegationManager contract that will have root access to this contract
     * @param _entryPoint the address of entry point
     * @param _name Name of the contract
     * @param _domainVersion Domain version of the contract
     */
    constructor(
        IDelegationManager _delegationManager,
        IEntryPoint _entryPoint,
        string memory _name,
        string memory _domainVersion
    )
        EIP712(_name, _domainVersion)
    {
        // Short name and version do not use storage in EIP712
        if (bytes(_name).length > 31) revert InvalidEIP712NameLength();
        if (bytes(_domainVersion).length > 31) revert InvalidEIP712VersionLength();

        delegationManager = _delegationManager;
        entryPoint = _entryPoint;
        emit SetDelegationManager(_delegationManager);
        emit SetEntryPoint(_entryPoint);
    }

    ////////////////////////////// External Methods //////////////////////////////

    /**
     * @notice Allows this contract to receive the chains native token
     */
    receive() external payable { }

    /**
     * @notice Redeems a delegation on the DelegationManager and executes the specified executions on behalf of the root delegator.
     * @param _permissionContexts An array of bytes where each element is made up of an array
     * of `Delegation` structs that are used to validate the authority given to execute the corresponding execution on the
     * root delegator, ordered from leaf to root.
     * @param _modes An array of `ModeCode` structs representing the mode of execution for each execution callData.
     * @param _executionCallDatas An array of `Execution` structs representing the executions to be executed.
     */
    function redeemDelegations(
        bytes[] calldata _permissionContexts,
        ModeCode[] calldata _modes,
        bytes[] calldata _executionCallDatas
    )
        external
        onlyEntryPointOrSelf
    {
        delegationManager.redeemDelegations(_permissionContexts, _modes, _executionCallDatas);
    }

    /**
     * @notice Executes an Execution from this contract
     * @dev This method is intended to be called through a UserOp which ensures the invoker has sufficient permissions
     * @dev This convenience method defaults to reverting on failure and a single execution.
     * @param _execution The Execution to be executed
     */
    function execute(Execution calldata _execution) external payable onlyEntryPointOrSelf {
        _execute(_execution.target, _execution.value, _execution.callData);
    }

    /**
     * @notice Executes an Execution from this contract
     * @dev Related: @erc7579/MSAAdvanced.sol and ERC-7821
     * @dev This method must be called from the entry point or self
     * @param _mode The ModeCode for the execution
     * @param _executionCalldata The calldata for the execution
     */
    function execute(ModeCode _mode, bytes calldata _executionCalldata) external payable onlyEntryPointOrSelf {
        (CallType callType_, ExecType execType_,,) = _mode.decode();

        // Check if calltype is batch or single
        if (callType_ == CALLTYPE_BATCH) {
            // destructure executionCallData according to batched exec
            Execution[] calldata executions_ = _executionCalldata.decodeBatch();
            // Check if execType is revert or try
            if (execType_ == EXECTYPE_DEFAULT) _execute(executions_);
            else if (execType_ == EXECTYPE_TRY) _tryExecute(executions_);
            else revert UnsupportedExecType(execType_);
        } else if (callType_ == CALLTYPE_SINGLE) {
            // Destructure executionCallData according to single exec
            (address target_, uint256 value_, bytes calldata callData_) = _executionCalldata.decodeSingle();
            // Check if execType is revert or try
            if (execType_ == EXECTYPE_DEFAULT) {
                _execute(target_, value_, callData_);
            } else if (execType_ == EXECTYPE_TRY) {
                bytes[] memory returnData_ = new bytes[](1);
                bool success_;
                (success_, returnData_[0]) = _tryExecute(target_, value_, callData_);
                if (!success_) emit TryExecuteUnsuccessful(0, returnData_[0]);
            } else {
                revert UnsupportedExecType(execType_);
            }
        } else {
            revert UnsupportedCallType(callType_);
        }
    }

    /**
     * @inheritdoc IDeleGatorCore
     * @dev Related: @erc7579/MSAAdvanced.sol
     */
    function executeFromExecutor(
        ModeCode _mode,
        bytes calldata _executionCalldata
    )
        external
        payable
        onlyDelegationManager
        returns (bytes[] memory returnData_)
    {
        (CallType callType_, ExecType execType_,,) = _mode.decode();

        // Check if calltype is batch or single
        if (callType_ == CALLTYPE_BATCH) {
            // Destructure executionCallData according to batched exec
            Execution[] calldata executions_ = _executionCalldata.decodeBatch();
            // check if execType is revert or try
            if (execType_ == EXECTYPE_DEFAULT) returnData_ = _execute(executions_);
            else if (execType_ == EXECTYPE_TRY) returnData_ = _tryExecute(executions_);
            else revert UnsupportedExecType(execType_);
        } else if (callType_ == CALLTYPE_SINGLE) {
            // Destructure executionCallData according to single exec
            (address target_, uint256 value_, bytes calldata callData_) = _executionCalldata.decodeSingle();
            returnData_ = new bytes[](1);
            bool success_;
            // check if execType is revert or try
            if (execType_ == EXECTYPE_DEFAULT) {
                returnData_[0] = _execute(target_, value_, callData_);
            } else if (execType_ == EXECTYPE_TRY) {
                (success_, returnData_[0]) = _tryExecute(target_, value_, callData_);
                if (!success_) emit TryExecuteUnsuccessful(0, returnData_[0]);
            } else {
                revert UnsupportedExecType(execType_);
            }
        } else {
            revert UnsupportedCallType(callType_);
        }
    }

    /**
     * @notice Validates a UserOp signature and sends any necessary funds to the EntryPoint
     * @dev Related: ERC4337
     * @param _userOp The UserOp struct to validate
     * @param _missingAccountFunds The missing funds from the account
     * @return validationData_ The validation data
     */
    function validateUserOp(
        PackedUserOperation calldata _userOp,
        bytes32, // Ignore UserOpHash from the Entry Point
        uint256 _missingAccountFunds
    )
        external
        onlyEntryPoint
        onlyProxy
        returns (uint256 validationData_)
    {
        validationData_ = _validateUserOpSignature(_userOp, getPackedUserOperationTypedDataHash(_userOp));
        _payPrefund(_missingAccountFunds);
    }

    /**
     * @inheritdoc IERC1271
     * @notice Verifies the signatures of the signers.
     * @dev Related: ERC4337, Delegation
     * @param _hash The hash of the data signed.
     * @param _signature The signatures of the signers.
     * @return magicValue_ A bytes4 magic value which is EIP1271_MAGIC_VALUE(0x1626ba7e) if the signature is valid, returns
     * SIG_VALIDATION_FAILED(0xffffffff) if there is a signature mismatch and reverts (for all other errors).
     */
    function isValidSignature(
        bytes32 _hash,
        bytes calldata _signature
    )
        external
        view
        override
        onlyProxy
        returns (bytes4 magicValue_)
    {
        return _isValidSignature(_hash, _signature);
    }

    /// @inheritdoc IERC721Receiver
    function onERC721Received(address, address, uint256, bytes memory) external view override onlyProxy returns (bytes4) {
        return this.onERC721Received.selector;
    }

    /// @inheritdoc IERC1155Receiver
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    )
        external
        view
        override
        onlyProxy
        returns (bytes4)
    {
        return this.onERC1155Received.selector;
    }

    /// @inheritdoc IERC1155Receiver
    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    )
        external
        view
        override
        onlyProxy
        returns (bytes4)
    {
        return this.onERC1155BatchReceived.selector;
    }

    /**
     * @notice Deposits more funds for this account in the entry point
     * @dev Related: ERC4337
     */
    function addDeposit() external payable onlyProxy {
        entryPoint.depositTo{ value: msg.value }(address(this));
    }

    /**
     * @notice This method withdraws funds of this account from the entry point
     * @dev Related: ERC4337
     * @param _withdrawAddress Address to withdraw the amount to
     * @param _withdrawAmount Amount to be withdraw from the entry point
     */
    function withdrawDeposit(address payable _withdrawAddress, uint256 _withdrawAmount) external onlyEntryPointOrSelf {
        entryPoint.withdrawTo(_withdrawAddress, _withdrawAmount);
    }

    /**
     * @notice Disables a delegation from being used
     * @param _delegation The delegation to be disabled
     */
    function disableDelegation(Delegation calldata _delegation) external onlyEntryPointOrSelf {
        delegationManager.disableDelegation(_delegation);
    }

    /**
     * @notice Enables a delegation to be used
     * @dev Delegations only need to be enabled if they have been disabled
     * @param _delegation The delegation to be enabled
     */
    function enableDelegation(Delegation calldata _delegation) external onlyEntryPointOrSelf {
        delegationManager.enableDelegation(_delegation);
    }

    /**
     * @notice Checks if the delegation is disabled
     * @param _delegationHash the hash of the delegation to check for disabled status.
     * @return bool is the delegation disabled
     */
    function isDelegationDisabled(bytes32 _delegationHash) external view returns (bool) {
        return delegationManager.disabledDelegations(_delegationHash);
    }

    /**
     * @notice Gets the current account's deposit in the entry point
     * @dev Related: ERC4337
     * @return uint256 The current account's deposit in the entry point
     */
    function getDeposit() external view returns (uint256) {
        return entryPoint.balanceOf(address(this));
    }

    /**
     * @notice Returns the next sequential nonce using a static key
     * @dev Related: ERC4337
     * @return uint256 The next sequential nonce
     */
    function getNonce() external view returns (uint256) {
        return entryPoint.getNonce(address(this), 0);
    }

    /**
     * @notice Returns the next sequential nonce using a custom key
     * @dev Related: ERC4337
     * @return uint256 The next sequential nonce for the key provided
     * @param _key The key to use for the nonce
     */
    function getNonce(uint192 _key) external view returns (uint256) {
        return entryPoint.getNonce(address(this), _key);
    }

    /**
     * @notice This method returns the domain hash used for signing typed data
     * @return bytes32 The domain hash
     */
    function getDomainHash() external view returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @notice Returns a boolean indicating if a mode is supported
     * @param _mode The mode to validate
     * @notice Returns true if the mode is supported, and false otherwise
     */
    function supportsExecutionMode(ModeCode _mode) external view virtual override returns (bool) {
        (CallType callType_, ExecType execType_, ModeSelector modeSelector_, ModePayload modePayload_) = _mode.decode();

        return (
            (callType_ == CALLTYPE_SINGLE || callType_ == CALLTYPE_BATCH)
                && (execType_ == EXECTYPE_DEFAULT || execType_ == EXECTYPE_TRY) && (modeSelector_ == MODE_DEFAULT)
                && (ModePayload.unwrap(modePayload_) == bytes22(0x00))
        );
    }

    /**
     * @notice Returns the formatted hash to sign for an EIP712 typed data signature
     * @param _userOp the UserOp to hash
     * @notice Returns an EIP712 typed data hash for a given UserOp
     */
    function getPackedUserOperationTypedDataHash(PackedUserOperation calldata _userOp) public view returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), getPackedUserOperationHash(_userOp));
    }

    /**
     * @inheritdoc IERC165
     * @dev Supports the following interfaces: IDeleGatorCore, IERC721Receiver, IERC1155Receiver, IERC165, IERC1271
     */
    function supportsInterface(bytes4 _interfaceId) public view virtual override(IERC165) onlyProxy returns (bool) {
        return _interfaceId == type(IDeleGatorCore).interfaceId || _interfaceId == type(IERC721Receiver).interfaceId
            || _interfaceId == type(IERC1155Receiver).interfaceId || _interfaceId == type(IERC165).interfaceId
            || _interfaceId == type(IERC1271).interfaceId || _interfaceId == type(IERC7821).interfaceId;
    }

    /**
     * Provides the typed data hash for a PackedUserOperation
     * @param _userOp the PackedUserOperation to hash
     */
    function getPackedUserOperationHash(PackedUserOperation calldata _userOp) public pure returns (bytes32) {
        return keccak256(
            abi.encode(
                PACKED_USER_OP_TYPEHASH,
                _userOp.sender,
                _userOp.nonce,
                keccak256(_userOp.initCode),
                keccak256(_userOp.callData),
                _userOp.accountGasLimits,
                _userOp.preVerificationGas,
                _userOp.gasFees,
                keccak256(_userOp.paymasterAndData)
            )
        );
    }

    ////////////////////////////// Internal Methods //////////////////////////////

    /**
     * @notice Sends the entrypoint (msg.sender) any needed funds for the transaction.
     * @param _missingAccountFunds 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.
     */
    function _payPrefund(uint256 _missingAccountFunds) internal {
        if (_missingAccountFunds != 0) {
            (bool success_,) = payable(msg.sender).call{ value: _missingAccountFunds, gas: type(uint256).max }("");
            (success_);
            // Ignore failure (it's EntryPoint's job to verify, not account.)
            emit SentPrefund(msg.sender, _missingAccountFunds, success_);
        }
    }

    /**
     * @notice The logic to verify if the signature is valid for this contract
     * @dev This is an internal function that should be overridden by the implementing contract based on the signature scheme used.
     * @dev Related: ERC4337
     * @param _hash The hash of the data signed.
     * @param _signature The signatures of the signers.
     * @return A bytes4 magic value which is EIP1271_MAGIC_VALUE(0x1626ba7e) if the signature is valid, returns
     * SIG_VALIDATION_FAILED(0xffffffff) if there is a signature mismatch and reverts (for all other errors).
     */
    function _isValidSignature(bytes32 _hash, bytes calldata _signature) internal view virtual returns (bytes4);

    /**
     * @notice Validates a UserOp signature and returns a code indicating if the signature is valid or not
     * @dev This method calls the DeleGator implementations `_isValidSignature` to validate the signature according to the
     * implementations auth scheme.
     * @dev Returns 0 if the signature is valid, 1 if the signature is invalid.
     * @dev Related: ERC4337
     * @param _userOp The UserOp
     * @param _userOpHash UserOp hash produced with typed data
     * @return validationData_ A code indicating if the signature is valid or not
     */
    function _validateUserOpSignature(
        PackedUserOperation calldata _userOp,
        bytes32 _userOpHash
    )
        internal
        view
        returns (uint256 validationData_)
    {
        bytes4 result_ = _isValidSignature(_userOpHash, _userOp.signature);
        if (result_ == ERC1271Lib.EIP1271_MAGIC_VALUE) {
            return 0;
        } else {
            return 1;
        }
    }
}