Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "account-abstraction/core/Helpers.sol";
import "account-abstraction/core/BasePaymaster.sol";
import "account-abstraction/interfaces/IEntryPoint.sol";
import "account-abstraction/interfaces/IEntryPointSimulations.sol";

contract MEEEntryPoint is BasePaymaster, ReentrancyGuard {
    using UserOperationLib for PackedUserOperation;

    error EmptyMessageValue();
    error InsufficientBalance();

    constructor(IEntryPoint _entryPoint) payable BasePaymaster(_entryPoint) {}

    function handleOps(PackedUserOperation[] calldata ops) public payable {
        if (msg.value == 0) {
            revert EmptyMessageValue();
        }
        entryPoint.depositTo{value: msg.value}(address(this));
        entryPoint.handleOps(ops, payable(msg.sender));
        entryPoint.withdrawTo(payable(msg.sender), entryPoint.getDepositInfo(address(this)).deposit);
    }

    function simulateHandleOp(PackedUserOperation calldata op, address target, bytes calldata callData)
        external
        payable
        returns (IEntryPointSimulations.ExecutionResult memory)
    {
        if (msg.value == 0) {
            revert EmptyMessageValue();
        }
        IEntryPointSimulations entryPointWithSimulations = IEntryPointSimulations(address(entryPoint));
        entryPointWithSimulations.depositTo{value: msg.value}(address(this));
        return entryPointWithSimulations.simulateHandleOp(op, target, callData);
    }

    function simulateValidation(PackedUserOperation calldata op)
        external
        payable
        returns (IEntryPointSimulations.ValidationResult memory)
    {
        if (msg.value == 0) {
            revert EmptyMessageValue();
        }
        IEntryPointSimulations entryPointWithSimulations = IEntryPointSimulations(address(entryPoint));
        entryPointWithSimulations.depositTo{value: msg.value}(address(this));
        return entryPointWithSimulations.simulateValidation(op);
    }

    // accept all userOps
    function _validatePaymasterUserOp(PackedUserOperation calldata userOp, bytes32 userOpHash, uint256 maxCost)
        internal
        virtual
        override
        returns (bytes memory context, uint256 validationData)
    {
        if (entryPoint.getDepositInfo(address(this)).deposit < maxCost) {
            revert InsufficientBalance();
        }
        (uint256 maxGasLimit, uint256 nodeOperatorPremium) =
            abi.decode(userOp.paymasterAndData[PAYMASTER_DATA_OFFSET:], (uint256, uint256));

        return (abi.encode(userOp.sender, userOp.unpackMaxFeePerGas(), maxGasLimit, nodeOperatorPremium), 0);
    }

    /**
     * Post-operation handler.
     * (verified to be called only through the entryPoint)
     * executes userOp and gives back refund to the userOp.sender if userOp.sender has overpaid for execution.
     * @dev if subclass returns a non-empty context from validatePaymasterUserOp, it must also implement this method.
     * @param mode enum with the following options:
     *      opSucceeded - user operation succeeded.
     *      opReverted  - user op reverted. still has to pay for gas.
     *      postOpReverted - user op succeeded, but caused postOp (in mode=opSucceeded) to revert.
     *                       Now this is the 2nd call, after user's op was deliberately reverted.
     * @param context - the context value returned by validatePaymasterUserOp
     * @param actualGasCost - actual gas used so far (without this postOp call).
     */
    function _postOp(PostOpMode mode, bytes calldata context, uint256 actualGasCost, uint256 actualUserOpFeePerGas)
        internal
        virtual
        override
    {
        if (mode == PostOpMode.postOpReverted) {
            return;
        }
        (address sender, uint256 maxFeePerGas, uint256 maxGasLimit, uint256 nodeOperatorPremium) =
            abi.decode(context, (address, uint256, uint256, uint256));

        uint256 refund = calculateRefund(maxGasLimit, maxFeePerGas, actualGasCost, nodeOperatorPremium);
        if (refund > 0) {
            entryPoint.withdrawTo(payable(sender), refund);
        }
    }

    function calculateRefund(
        uint256 maxGasLimit,
        uint256 maxFeePerGas,
        uint256 actualGasCost,
        uint256 nodeOperatorPremium
    ) public pure returns (uint256 refund) {
        uint256 costWithPremium = (actualGasCost * (100 + nodeOperatorPremium)) / 100;

        uint256 maxCost = maxGasLimit * maxFeePerGas;
        if (costWithPremium < maxCost) {
            refund = maxCost - costWithPremium;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.23;

/* solhint-disable no-inline-assembly */


 /*
  * For simulation purposes, validateUserOp (and validatePaymasterUserOp)
  * must return this value in case of signature failure, instead of revert.
  */
uint256 constant SIG_VALIDATION_FAILED = 1;


/*
 * For simulation purposes, validateUserOp (and validatePaymasterUserOp)
 * return this value on success.
 */
uint256 constant SIG_VALIDATION_SUCCESS = 0;


/**
 * Returned data from validateUserOp.
 * validateUserOp returns a uint256, which is created by `_packedValidationData` and
 * parsed by `_parseValidationData`.
 * @param aggregator  - address(0) - The account validated the signature by itself.
 *                      address(1) - The account failed to validate the signature.
 *                      otherwise - This is an address of a signature aggregator that must
 *                                  be used to validate the signature.
 * @param validAfter  - This UserOp is valid only after this timestamp.
 * @param validaUntil - This UserOp is valid only up to this timestamp.
 */
struct ValidationData {
    address aggregator;
    uint48 validAfter;
    uint48 validUntil;
}

/**
 * Extract sigFailed, validAfter, validUntil.
 * Also convert zero validUntil to type(uint48).max.
 * @param validationData - The packed validation data.
 */
function _parseValidationData(
    uint256 validationData
) pure returns (ValidationData memory data) {
    address aggregator = address(uint160(validationData));
    uint48 validUntil = uint48(validationData >> 160);
    if (validUntil == 0) {
        validUntil = type(uint48).max;
    }
    uint48 validAfter = uint48(validationData >> (48 + 160));
    return ValidationData(aggregator, validAfter, validUntil);
}

/**
 * Helper to pack the return value for validateUserOp.
 * @param data - The ValidationData to pack.
 */
function _packValidationData(
    ValidationData memory data
) pure returns (uint256) {
    return
        uint160(data.aggregator) |
        (uint256(data.validUntil) << 160) |
        (uint256(data.validAfter) << (160 + 48));
}

/**
 * Helper to pack the return value for validateUserOp, when not using an aggregator.
 * @param sigFailed  - True for signature failure, false for success.
 * @param validUntil - Last timestamp this UserOperation is valid (or zero for infinite).
 * @param validAfter - First timestamp this UserOperation is valid.
 */
function _packValidationData(
    bool sigFailed,
    uint48 validUntil,
    uint48 validAfter
) pure returns (uint256) {
    return
        (sigFailed ? 1 : 0) |
        (uint256(validUntil) << 160) |
        (uint256(validAfter) << (160 + 48));
}

/**
 * keccak function over calldata.
 * @dev copy calldata into memory, do keccak and drop allocated memory. Strangely, this is more efficient than letting solidity do it.
 */
    function calldataKeccak(bytes calldata data) pure returns (bytes32 ret) {
        assembly ("memory-safe") {
            let mem := mload(0x40)
            let len := data.length
            calldatacopy(mem, data.offset, len)
            ret := keccak256(mem, len)
        }
    }


/**
 * The minimum of two numbers.
 * @param a - First number.
 * @param b - Second number.
 */
    function min(uint256 a, uint256 b) pure returns (uint256) {
        return a < b ? a : b;
    }

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.23;

/* solhint-disable reason-string */

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "../interfaces/IPaymaster.sol";
import "../interfaces/IEntryPoint.sol";
import "./UserOperationLib.sol";
/**
 * Helper class for creating a paymaster.
 * provides helper methods for staking.
 * Validates that the postOp is called only by the entryPoint.
 */
abstract contract BasePaymaster is IPaymaster, Ownable {
    IEntryPoint public immutable entryPoint;

    uint256 internal constant PAYMASTER_VALIDATION_GAS_OFFSET = UserOperationLib.PAYMASTER_VALIDATION_GAS_OFFSET;
    uint256 internal constant PAYMASTER_POSTOP_GAS_OFFSET = UserOperationLib.PAYMASTER_POSTOP_GAS_OFFSET;
    uint256 internal constant PAYMASTER_DATA_OFFSET = UserOperationLib.PAYMASTER_DATA_OFFSET;

    constructor(IEntryPoint _entryPoint) Ownable(msg.sender) {
        _validateEntryPointInterface(_entryPoint);
        entryPoint = _entryPoint;
    }

    //sanity check: make sure this EntryPoint was compiled against the same
    // IEntryPoint of this paymaster
    function _validateEntryPointInterface(IEntryPoint _entryPoint) internal virtual {
        require(IERC165(address(_entryPoint)).supportsInterface(type(IEntryPoint).interfaceId), "IEntryPoint interface mismatch");
    }

    /// @inheritdoc IPaymaster
    function validatePaymasterUserOp(
        PackedUserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 maxCost
    ) external override returns (bytes memory context, uint256 validationData) {
        _requireFromEntryPoint();
        return _validatePaymasterUserOp(userOp, userOpHash, maxCost);
    }

    /**
     * Validate a user operation.
     * @param userOp     - The user operation.
     * @param userOpHash - The hash of the user operation.
     * @param maxCost    - The maximum cost of the user operation.
     */
    function _validatePaymasterUserOp(
        PackedUserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 maxCost
    ) internal virtual returns (bytes memory context, uint256 validationData);

    /// @inheritdoc IPaymaster
    function postOp(
        PostOpMode mode,
        bytes calldata context,
        uint256 actualGasCost,
        uint256 actualUserOpFeePerGas
    ) external override {
        _requireFromEntryPoint();
        _postOp(mode, context, actualGasCost, actualUserOpFeePerGas);
    }

    /**
     * Post-operation handler.
     * (verified to be called only through the entryPoint)
     * @dev If subclass returns a non-empty context from validatePaymasterUserOp,
     *      it must also implement this method.
     * @param mode          - Enum with the following options:
     *                        opSucceeded - User operation succeeded.
     *                        opReverted  - User op reverted. The paymaster still has to pay for gas.
     *                        postOpReverted - never passed in a call to postOp().
     * @param context       - The context value returned by validatePaymasterUserOp
     * @param actualGasCost - Actual gas used so far (without this postOp call).
     * @param actualUserOpFeePerGas - the gas price this UserOp pays. This value is based on the UserOp's maxFeePerGas
     *                        and maxPriorityFee (and basefee)
     *                        It is not the same as tx.gasprice, which is what the bundler pays.
     */
    function _postOp(
        PostOpMode mode,
        bytes calldata context,
        uint256 actualGasCost,
        uint256 actualUserOpFeePerGas
    ) internal virtual {
        (mode, context, actualGasCost, actualUserOpFeePerGas); // unused params
        // subclass must override this method if validatePaymasterUserOp returns a context
        revert("must override");
    }

    /**
     * Add a deposit for this paymaster, used for paying for transaction fees.
     */
    function deposit() public payable {
        entryPoint.depositTo{value: msg.value}(address(this));
    }

    /**
     * Withdraw value from the deposit.
     * @param withdrawAddress - Target to send to.
     * @param amount          - Amount to withdraw.
     */
    function withdrawTo(
        address payable withdrawAddress,
        uint256 amount
    ) public onlyOwner {
        entryPoint.withdrawTo(withdrawAddress, amount);
    }

    /**
     * Add stake for this paymaster.
     * This method can also carry eth value to add to the current stake.
     * @param unstakeDelaySec - The unstake delay for this paymaster. Can only be increased.
     */
    function addStake(uint32 unstakeDelaySec) external payable onlyOwner {
        entryPoint.addStake{value: msg.value}(unstakeDelaySec);
    }

    /**
     * Return current paymaster's deposit on the entryPoint.
     */
    function getDeposit() public view returns (uint256) {
        return entryPoint.balanceOf(address(this));
    }

    /**
     * Unlock the stake, in order to withdraw it.
     * The paymaster can't serve requests once unlocked, until it calls addStake again
     */
    function unlockStake() external onlyOwner {
        entryPoint.unlockStake();
    }

    /**
     * Withdraw the entire paymaster's stake.
     * stake must be unlocked first (and then wait for the unstakeDelay to be over)
     * @param withdrawAddress - The address to send withdrawn value.
     */
    function withdrawStake(address payable withdrawAddress) external onlyOwner {
        entryPoint.withdrawStake(withdrawAddress);
    }

    /**
     * Validate the call is made from a valid entrypoint
     */
    function _requireFromEntryPoint() internal virtual {
        require(msg.sender == address(entryPoint), "Sender not EntryPoint");
    }
}

/**
 ** Account-Abstraction (EIP-4337) singleton EntryPoint implementation.
 ** Only one instance required on each chain.
 **/
// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.5;

/* solhint-disable avoid-low-level-calls */
/* solhint-disable no-inline-assembly */
/* solhint-disable reason-string */

import "./PackedUserOperation.sol";
import "./IStakeManager.sol";
import "./IAggregator.sol";
import "./INonceManager.sol";

interface IEntryPoint is IStakeManager, INonceManager {
    /***
     * An event emitted after each successful request.
     * @param userOpHash    - Unique identifier for the request (hash its entire content, except signature).
     * @param sender        - The account that generates this request.
     * @param paymaster     - If non-null, the paymaster that pays for this request.
     * @param nonce         - The nonce value from the request.
     * @param success       - True if the sender transaction succeeded, false if reverted.
     * @param actualGasCost - Actual amount paid (by account or paymaster) for this UserOperation.
     * @param actualGasUsed - Total gas used by this UserOperation (including preVerification, creation,
     *                        validation and execution).
     */
    event UserOperationEvent(
        bytes32 indexed userOpHash,
        address indexed sender,
        address indexed paymaster,
        uint256 nonce,
        bool success,
        uint256 actualGasCost,
        uint256 actualGasUsed
    );

    /**
     * Account "sender" was deployed.
     * @param userOpHash - The userOp that deployed this account. UserOperationEvent will follow.
     * @param sender     - The account that is deployed
     * @param factory    - The factory used to deploy this account (in the initCode)
     * @param paymaster  - The paymaster used by this UserOp
     */
    event AccountDeployed(
        bytes32 indexed userOpHash,
        address indexed sender,
        address factory,
        address paymaster
    );

    /**
     * An event emitted if the UserOperation "callData" reverted with non-zero length.
     * @param userOpHash   - The request unique identifier.
     * @param sender       - The sender of this request.
     * @param nonce        - The nonce used in the request.
     * @param revertReason - The return bytes from the (reverted) call to "callData".
     */
    event UserOperationRevertReason(
        bytes32 indexed userOpHash,
        address indexed sender,
        uint256 nonce,
        bytes revertReason
    );

    /**
     * An event emitted if the UserOperation Paymaster's "postOp" call reverted with non-zero length.
     * @param userOpHash   - The request unique identifier.
     * @param sender       - The sender of this request.
     * @param nonce        - The nonce used in the request.
     * @param revertReason - The return bytes from the (reverted) call to "callData".
     */
    event PostOpRevertReason(
        bytes32 indexed userOpHash,
        address indexed sender,
        uint256 nonce,
        bytes revertReason
    );

    /**
     * UserOp consumed more than prefund. The UserOperation is reverted, and no refund is made.
     * @param userOpHash   - The request unique identifier.
     * @param sender       - The sender of this request.
     * @param nonce        - The nonce used in the request.
     */
    event UserOperationPrefundTooLow(
        bytes32 indexed userOpHash,
        address indexed sender,
        uint256 nonce
    );

    /**
     * An event emitted by handleOps(), before starting the execution loop.
     * Any event emitted before this event, is part of the validation.
     */
    event BeforeExecution();

    /**
     * Signature aggregator used by the following UserOperationEvents within this bundle.
     * @param aggregator - The aggregator used for the following UserOperationEvents.
     */
    event SignatureAggregatorChanged(address indexed aggregator);

    /**
     * A custom revert error of handleOps, to identify the offending op.
     * Should be caught in off-chain handleOps simulation and not happen on-chain.
     * Useful for mitigating DoS attempts against batchers or for troubleshooting of factory/account/paymaster reverts.
     * NOTE: If simulateValidation passes successfully, there should be no reason for handleOps to fail on it.
     * @param opIndex - Index into the array of ops to the failed one (in simulateValidation, this is always zero).
     * @param reason  - Revert reason. The string starts with a unique code "AAmn",
     *                  where "m" is "1" for factory, "2" for account and "3" for paymaster issues,
     *                  so a failure can be attributed to the correct entity.
     */
    error FailedOp(uint256 opIndex, string reason);

    /**
     * A custom revert error of handleOps, to report a revert by account or paymaster.
     * @param opIndex - Index into the array of ops to the failed one (in simulateValidation, this is always zero).
     * @param reason  - Revert reason. see FailedOp(uint256,string), above
     * @param inner   - data from inner cought revert reason
     * @dev note that inner is truncated to 2048 bytes
     */
    error FailedOpWithRevert(uint256 opIndex, string reason, bytes inner);

    error PostOpReverted(bytes returnData);

    /**
     * Error case when a signature aggregator fails to verify the aggregated signature it had created.
     * @param aggregator The aggregator that failed to verify the signature
     */
    error SignatureValidationFailed(address aggregator);

    // Return value of getSenderAddress.
    error SenderAddressResult(address sender);

    // UserOps handled, per aggregator.
    struct UserOpsPerAggregator {
        PackedUserOperation[] userOps;
        // Aggregator address
        IAggregator aggregator;
        // Aggregated signature
        bytes signature;
    }

    /**
     * Execute a batch of UserOperations.
     * No signature aggregator is used.
     * If any account requires an aggregator (that is, it returned an aggregator when
     * performing simulateValidation), then handleAggregatedOps() must be used instead.
     * @param ops         - The operations to execute.
     * @param beneficiary - The address to receive the fees.
     */
    function handleOps(
        PackedUserOperation[] calldata ops,
        address payable beneficiary
    ) external;

    /**
     * Execute a batch of UserOperation with Aggregators
     * @param opsPerAggregator - The operations to execute, grouped by aggregator (or address(0) for no-aggregator accounts).
     * @param beneficiary      - The address to receive the fees.
     */
    function handleAggregatedOps(
        UserOpsPerAggregator[] calldata opsPerAggregator,
        address payable beneficiary
    ) external;

    /**
     * Generate a request Id - unique identifier for this request.
     * The request ID is a hash over the content of the userOp (except the signature), the entrypoint and the chainid.
     * @param userOp - The user operation to generate the request ID for.
     * @return hash the hash of this UserOperation
     */
    function getUserOpHash(
        PackedUserOperation calldata userOp
    ) external view returns (bytes32);

    /**
     * Gas and return values during simulation.
     * @param preOpGas         - The gas used for validation (including preValidationGas)
     * @param prefund          - The required prefund for this operation
     * @param accountValidationData   - returned validationData from account.
     * @param paymasterValidationData - return validationData from paymaster.
     * @param paymasterContext - Returned by validatePaymasterUserOp (to be passed into postOp)
     */
    struct ReturnInfo {
        uint256 preOpGas;
        uint256 prefund;
        uint256 accountValidationData;
        uint256 paymasterValidationData;
        bytes paymasterContext;
    }

    /**
     * Returned aggregated signature info:
     * The aggregator returned by the account, and its current stake.
     */
    struct AggregatorStakeInfo {
        address aggregator;
        StakeInfo stakeInfo;
    }

    /**
     * Get counterfactual sender address.
     * Calculate the sender contract address that will be generated by the initCode and salt in the UserOperation.
     * This method always revert, and returns the address in SenderAddressResult error
     * @param initCode - The constructor code to be passed into the UserOperation.
     */
    function getSenderAddress(bytes memory initCode) external;

    error DelegateAndRevert(bool success, bytes ret);

    /**
     * Helper method for dry-run testing.
     * @dev calling this method, the EntryPoint will make a delegatecall to the given data, and report (via revert) the result.
     *  The method always revert, so is only useful off-chain for dry run calls, in cases where state-override to replace
     *  actual EntryPoint code is less convenient.
     * @param target a target contract to make a delegatecall from entrypoint
     * @param data data to pass to target in a delegatecall
     */
    function delegateAndRevert(address target, bytes calldata data) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.5;

import "./PackedUserOperation.sol";
import "./IEntryPoint.sol";

interface IEntryPointSimulations is IEntryPoint {
    // Return value of simulateHandleOp.
    struct ExecutionResult {
        uint256 preOpGas;
        uint256 paid;
        uint256 accountValidationData;
        uint256 paymasterValidationData;
        bool targetSuccess;
        bytes targetResult;
    }

    /**
     * Successful result from simulateValidation.
     * If the account returns a signature aggregator the "aggregatorInfo" struct is filled in as well.
     * @param returnInfo     Gas and time-range returned values
     * @param senderInfo     Stake information about the sender
     * @param factoryInfo    Stake information about the factory (if any)
     * @param paymasterInfo  Stake information about the paymaster (if any)
     * @param aggregatorInfo Signature aggregation info (if the account requires signature aggregator)
     *                       Bundler MUST use it to verify the signature, or reject the UserOperation.
     */
    struct ValidationResult {
        ReturnInfo returnInfo;
        StakeInfo senderInfo;
        StakeInfo factoryInfo;
        StakeInfo paymasterInfo;
        AggregatorStakeInfo aggregatorInfo;
    }

    /**
     * Simulate a call to account.validateUserOp and paymaster.validatePaymasterUserOp.
     * @dev The node must also verify it doesn't use banned opcodes, and that it doesn't reference storage
     *      outside the account's data.
     * @param userOp - The user operation to validate.
     * @return the validation result structure
     */
    function simulateValidation(
        PackedUserOperation calldata userOp
    )
    external
    returns (
        ValidationResult memory
    );

    /**
     * Simulate full execution of a UserOperation (including both validation and target execution)
     * It performs full validation of the UserOperation, but ignores signature error.
     * An optional target address is called after the userop succeeds,
     * and its value is returned (before the entire call is reverted).
     * Note that in order to collect the the success/failure of the target call, it must be executed
     * with trace enabled to track the emitted events.
     * @param op The UserOperation to simulate.
     * @param target         - If nonzero, a target address to call after userop simulation. If called,
     *                         the targetSuccess and targetResult are set to the return from that call.
     * @param targetCallData - CallData to pass to target address.
     * @return the execution result structure
     */
    function simulateHandleOp(
        PackedUserOperation calldata op,
        address target,
        bytes calldata targetCallData
    )
    external
    returns (
        ExecutionResult memory
    );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.5;

import "./PackedUserOperation.sol";

/**
 * The interface exposed by a paymaster contract, who agrees to pay the gas for user's operations.
 * A paymaster must hold a stake to cover the required entrypoint stake and also the gas for the transaction.
 */
interface IPaymaster {
    enum PostOpMode {
        // User op succeeded.
        opSucceeded,
        // User op reverted. Still has to pay for gas.
        opReverted,
        // Only used internally in the EntryPoint (cleanup after postOp reverts). Never calling paymaster with this value
        postOpReverted
    }

    /**
     * Payment validation: check if paymaster agrees to pay.
     * Must verify sender is the entryPoint.
     * Revert to reject this request.
     * Note that bundlers will reject this method if it changes the state, unless the paymaster is trusted (whitelisted).
     * The paymaster pre-pays using its deposit, and receive back a refund after the postOp method returns.
     * @param userOp          - The user operation.
     * @param userOpHash      - Hash of the user's request data.
     * @param maxCost         - The maximum cost of this transaction (based on maximum gas and gas price from userOp).
     * @return context        - Value to send to a postOp. Zero length to signify postOp is not required.
     * @return validationData - Signature and time-range of this operation, encoded the same as the return
     *                          value of validateUserOperation.
     *                          <20-byte> sigAuthorizer - 0 for valid signature, 1 to mark signature failure,
     *                                                    other values are invalid for paymaster.
     *                          <6-byte> validUntil - last timestamp this operation is valid. 0 for "indefinite"
     *                          <6-byte> validAfter - first timestamp this operation is valid
     *                          Note that the validation code cannot use block.timestamp (or block.number) directly.
     */
    function validatePaymasterUserOp(
        PackedUserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 maxCost
    ) external returns (bytes memory context, uint256 validationData);

    /**
     * Post-operation handler.
     * Must verify sender is the entryPoint.
     * @param mode          - Enum with the following options:
     *                        opSucceeded - User operation succeeded.
     *                        opReverted  - User op reverted. The paymaster still has to pay for gas.
     *                        postOpReverted - never passed in a call to postOp().
     * @param context       - The context value returned by validatePaymasterUserOp
     * @param actualGasCost - Actual gas used so far (without this postOp call).
     * @param actualUserOpFeePerGas - the gas price this UserOp pays. This value is based on the UserOp's maxFeePerGas
     *                        and maxPriorityFee (and basefee)
     *                        It is not the same as tx.gasprice, which is what the bundler pays.
     */
    function postOp(
        PostOpMode mode,
        bytes calldata context,
        uint256 actualGasCost,
        uint256 actualUserOpFeePerGas
    ) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.23;

/* solhint-disable no-inline-assembly */

import "../interfaces/PackedUserOperation.sol";
import {calldataKeccak, min} from "./Helpers.sol";

/**
 * Utility functions helpful when working with UserOperation structs.
 */
library UserOperationLib {

    uint256 public constant PAYMASTER_VALIDATION_GAS_OFFSET = 20;
    uint256 public constant PAYMASTER_POSTOP_GAS_OFFSET = 36;
    uint256 public constant PAYMASTER_DATA_OFFSET = 52;
    /**
     * Get sender from user operation data.
     * @param userOp - The user operation data.
     */
    function getSender(
        PackedUserOperation calldata userOp
    ) internal pure returns (address) {
        address data;
        //read sender from userOp, which is first userOp member (saves 800 gas...)
        assembly {
            data := calldataload(userOp)
        }
        return address(uint160(data));
    }

    /**
     * Relayer/block builder might submit the TX with higher priorityFee,
     * but the user should not pay above what he signed for.
     * @param userOp - The user operation data.
     */
    function gasPrice(
        PackedUserOperation calldata userOp
    ) internal view returns (uint256) {
        unchecked {
            (uint256 maxPriorityFeePerGas, uint256 maxFeePerGas) = unpackUints(userOp.gasFees);
            if (maxFeePerGas == maxPriorityFeePerGas) {
                //legacy mode (for networks that don't support basefee opcode)
                return maxFeePerGas;
            }
            return min(maxFeePerGas, maxPriorityFeePerGas + block.basefee);
        }
    }

    /**
     * Pack the user operation data into bytes for hashing.
     * @param userOp - The user operation data.
     */
    function encode(
        PackedUserOperation calldata userOp
    ) internal pure returns (bytes memory ret) {
        address sender = getSender(userOp);
        uint256 nonce = userOp.nonce;
        bytes32 hashInitCode = calldataKeccak(userOp.initCode);
        bytes32 hashCallData = calldataKeccak(userOp.callData);
        bytes32 accountGasLimits = userOp.accountGasLimits;
        uint256 preVerificationGas = userOp.preVerificationGas;
        bytes32 gasFees = userOp.gasFees;
        bytes32 hashPaymasterAndData = calldataKeccak(userOp.paymasterAndData);

        return abi.encode(
            sender, nonce,
            hashInitCode, hashCallData,
            accountGasLimits, preVerificationGas, gasFees,
            hashPaymasterAndData
        );
    }

    function unpackUints(
        bytes32 packed
    ) internal pure returns (uint256 high128, uint256 low128) {
        return (uint128(bytes16(packed)), uint128(uint256(packed)));
    }

    //unpack just the high 128-bits from a packed value
    function unpackHigh128(bytes32 packed) internal pure returns (uint256) {
        return uint256(packed) >> 128;
    }

    // unpack just the low 128-bits from a packed value
    function unpackLow128(bytes32 packed) internal pure returns (uint256) {
        return uint128(uint256(packed));
    }

    function unpackMaxPriorityFeePerGas(PackedUserOperation calldata userOp)
    internal pure returns (uint256) {
        return unpackHigh128(userOp.gasFees);
    }

    function unpackMaxFeePerGas(PackedUserOperation calldata userOp)
    internal pure returns (uint256) {
        return unpackLow128(userOp.gasFees);
    }

    function unpackVerificationGasLimit(PackedUserOperation calldata userOp)
    internal pure returns (uint256) {
        return unpackHigh128(userOp.accountGasLimits);
    }

    function unpackCallGasLimit(PackedUserOperation calldata userOp)
    internal pure returns (uint256) {
        return unpackLow128(userOp.accountGasLimits);
    }

    function unpackPaymasterVerificationGasLimit(PackedUserOperation calldata userOp)
    internal pure returns (uint256) {
        return uint128(bytes16(userOp.paymasterAndData[PAYMASTER_VALIDATION_GAS_OFFSET : PAYMASTER_POSTOP_GAS_OFFSET]));
    }

    function unpackPostOpGasLimit(PackedUserOperation calldata userOp)
    internal pure returns (uint256) {
        return uint128(bytes16(userOp.paymasterAndData[PAYMASTER_POSTOP_GAS_OFFSET : PAYMASTER_DATA_OFFSET]));
    }

    function unpackPaymasterStaticFields(
        bytes calldata paymasterAndData
    ) internal pure returns (address paymaster, uint256 validationGasLimit, uint256 postOpGasLimit) {
        return (
            address(bytes20(paymasterAndData[: PAYMASTER_VALIDATION_GAS_OFFSET])),
            uint128(bytes16(paymasterAndData[PAYMASTER_VALIDATION_GAS_OFFSET : PAYMASTER_POSTOP_GAS_OFFSET])),
            uint128(bytes16(paymasterAndData[PAYMASTER_POSTOP_GAS_OFFSET : PAYMASTER_DATA_OFFSET]))
        );
    }

    /**
     * Hash the user operation data.
     * @param userOp - The user operation data.
     */
    function hash(
        PackedUserOperation calldata userOp
    ) internal pure returns (bytes32) {
        return keccak256(encode(userOp));
    }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.5;

/**
 * User Operation struct
 * @param sender                - The sender account of this request.
 * @param nonce                 - Unique value the sender uses to verify it is not a replay.
 * @param initCode              - If set, the account contract will be created by this constructor/
 * @param callData              - The method call to execute on this account.
 * @param accountGasLimits      - Packed gas limits for validateUserOp and gas limit passed to the callData method call.
 * @param preVerificationGas    - Gas not calculated by the handleOps method, but added to the gas paid.
 *                                Covers batch overhead.
 * @param gasFees               - packed gas fields maxPriorityFeePerGas and maxFeePerGas - Same as EIP-1559 gas parameters.
 * @param paymasterAndData      - If set, this field holds the paymaster address, verification gas limit, postOp gas limit and paymaster-specific extra data
 *                                The paymaster will pay for the transaction instead of the sender.
 * @param signature             - Sender-verified signature over the entire request, the EntryPoint address and the chain ID.
 */
struct PackedUserOperation {
    address sender;
    uint256 nonce;
    bytes initCode;
    bytes callData;
    bytes32 accountGasLimits;
    uint256 preVerificationGas;
    bytes32 gasFees;
    bytes paymasterAndData;
    bytes signature;
}

// SPDX-License-Identifier: GPL-3.0-only
pragma solidity >=0.7.5;

/**
 * Manage deposits and stakes.
 * Deposit is just a balance used to pay for UserOperations (either by a paymaster or an account).
 * Stake is value locked for at least "unstakeDelay" by the staked entity.
 */
interface IStakeManager {
    event Deposited(address indexed account, uint256 totalDeposit);

    event Withdrawn(
        address indexed account,
        address withdrawAddress,
        uint256 amount
    );

    // Emitted when stake or unstake delay are modified.
    event StakeLocked(
        address indexed account,
        uint256 totalStaked,
        uint256 unstakeDelaySec
    );

    // Emitted once a stake is scheduled for withdrawal.
    event StakeUnlocked(address indexed account, uint256 withdrawTime);

    event StakeWithdrawn(
        address indexed account,
        address withdrawAddress,
        uint256 amount
    );

    /**
     * @param deposit         - The entity's deposit.
     * @param staked          - True if this entity is staked.
     * @param stake           - Actual amount of ether staked for this entity.
     * @param unstakeDelaySec - Minimum delay to withdraw the stake.
     * @param withdrawTime    - First block timestamp where 'withdrawStake' will be callable, or zero if already locked.
     * @dev Sizes were chosen so that deposit fits into one cell (used during handleOp)
     *      and the rest fit into a 2nd cell (used during stake/unstake)
     *      - 112 bit allows for 10^15 eth
     *      - 48 bit for full timestamp
     *      - 32 bit allows 150 years for unstake delay
     */
    struct DepositInfo {
        uint256 deposit;
        bool staked;
        uint112 stake;
        uint32 unstakeDelaySec;
        uint48 withdrawTime;
    }

    // API struct used by getStakeInfo and simulateValidation.
    struct StakeInfo {
        uint256 stake;
        uint256 unstakeDelaySec;
    }

    /**
     * Get deposit info.
     * @param account - The account to query.
     * @return info   - Full deposit information of given account.
     */
    function getDepositInfo(
        address account
    ) external view returns (DepositInfo memory info);

    /**
     * Get account balance.
     * @param account - The account to query.
     * @return        - The deposit (for gas payment) of the account.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * Add to the deposit of the given account.
     * @param account - The account to add to.
     */
    function depositTo(address account) external payable;

    /**
     * Add to the account's stake - amount and delay
     * any pending unstake is first cancelled.
     * @param _unstakeDelaySec - The new lock duration before the deposit can be withdrawn.
     */
    function addStake(uint32 _unstakeDelaySec) external payable;

    /**
     * Attempt to unlock the stake.
     * The value can be withdrawn (using withdrawStake) after the unstake delay.
     */
    function unlockStake() external;

    /**
     * Withdraw from the (unlocked) stake.
     * Must first call unlockStake and wait for the unstakeDelay to pass.
     * @param withdrawAddress - The address to send withdrawn value.
     */
    function withdrawStake(address payable withdrawAddress) external;

    /**
     * Withdraw from the deposit.
     * @param withdrawAddress - The address to send withdrawn value.
     * @param withdrawAmount  - The amount to withdraw.
     */
    function withdrawTo(
        address payable withdrawAddress,
        uint256 withdrawAmount
    ) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.5;

import "./PackedUserOperation.sol";

/**
 * Aggregated Signatures validator.
 */
interface IAggregator {
    /**
     * Validate aggregated signature.
     * Revert if the aggregated signature does not match the given list of operations.
     * @param userOps   - Array of UserOperations to validate the signature for.
     * @param signature - The aggregated signature.
     */
    function validateSignatures(
        PackedUserOperation[] calldata userOps,
        bytes calldata signature
    ) external view;

    /**
     * Validate signature of a single userOp.
     * This method should be called by bundler after EntryPointSimulation.simulateValidation() returns
     * the aggregator this account uses.
     * First it validates the signature over the userOp. Then it returns data to be used when creating the handleOps.
     * @param userOp        - The userOperation received from the user.
     * @return sigForUserOp - The value to put into the signature field of the userOp when calling handleOps.
     *                        (usually empty, unless account and aggregator support some kind of "multisig".
     */
    function validateUserOpSignature(
        PackedUserOperation calldata userOp
    ) external view returns (bytes memory sigForUserOp);

    /**
     * Aggregate multiple signatures into a single value.
     * This method is called off-chain to calculate the signature to pass with handleOps()
     * bundler MAY use optimized custom code perform this aggregation.
     * @param userOps              - Array of UserOperations to collect the signatures from.
     * @return aggregatedSignature - The aggregated signature.
     */
    function aggregateSignatures(
        PackedUserOperation[] calldata userOps
    ) external view returns (bytes memory aggregatedSignature);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.5;

interface INonceManager {

    /**
     * Return the next nonce for this sender.
     * Within a given key, the nonce values are sequenced (starting with zero, and incremented by one on each userop)
     * But UserOp with different keys can come with arbitrary order.
     *
     * @param sender the account address
     * @param key the high 192 bit of the nonce
     * @return nonce a full nonce to pass for next UserOp with this sender.
     */
    function getNonce(address sender, uint192 key)
    external view returns (uint256 nonce);

    /**
     * Manually increment the nonce of the sender.
     * This method is exposed just for completeness..
     * Account does NOT need to call it, neither during validation, nor elsewhere,
     * as the EntryPoint will update the nonce regardless.
     * Possible use-case is call it with various keys to "initialize" their nonces to one, so that future
     * UserOperations will not pay extra for the first transaction with a given key.
     */
    function incrementNonce(uint192 key) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

{
  "remappings": [
    "openzeppelin/=node_modules/@openzeppelin/contracts/",
    "account-abstraction/=node_modules/account-abstraction/contracts/",
    "erc7739Validator/=node_modules/erc7739-validator-base/src/",
    "solady/=node_modules/solady/src/",
    "forge-std/=lib/forge-std/src/",
    "@ERC4337/=node_modules/@ERC4337/",
    "@erc7579/=node_modules/@erc7579/",
    "@gnosis.pm/=node_modules/@gnosis.pm/",
    "@openzeppelin/=node_modules/@openzeppelin/",
    "@prb/=node_modules/@prb/",
    "@prb/math/=node_modules/erc7739-validator-base/node_modules/@prb/math/src/",
    "@rhinestone/=node_modules/@rhinestone/",
    "@safe-global/=node_modules/@safe-global/",
    "@zerodev/=node_modules/@zerodev/",
    "ExcessivelySafeCall/=node_modules/erc7739-validator-base/node_modules/excessively-safe-call/src/",
    "account-abstraction-v0.6/=node_modules/account-abstraction-v0.6/",
    "ds-test/=node_modules/ds-test/",
    "enumerableset4337/=node_modules/erc7739-validator-base/node_modules/@erc7579/enumerablemap4337/src/",
    "erc4337-validation/=node_modules/erc7739-validator-base/node_modules/@rhinestone/erc4337-validation/src/",
    "erc7579/=node_modules/erc7579/",
    "erc7739-validator-base/=node_modules/erc7739-validator-base/",
    "excessively-safe-call/=node_modules/excessively-safe-call/",
    "hardhat-deploy/=node_modules/hardhat-deploy/",
    "hardhat/=node_modules/hardhat/",
    "kernel/=node_modules/erc7739-validator-base/node_modules/@zerodev/kernel/src/",
    "module-bases/=node_modules/erc7739-validator-base/node_modules/@rhinestone/module-bases/src/",
    "modulekit/=node_modules/erc7739-validator-base/node_modules/@rhinestone/modulekit/src/",
    "safe7579/=node_modules/erc7739-validator-base/node_modules/@rhinestone/safe7579/src/",
    "sentinellist/=node_modules/erc7739-validator-base/node_modules/@rhinestone/sentinellist/src/",
    "solarray/=node_modules/solarray/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 999
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IEntryPoint","name":"_entryPoint","type":"address"}],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"EmptyMessageValue","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint32","name":"unstakeDelaySec","type":"uint32"}],"name":"addStake","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxGasLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"actualGasCost","type":"uint256"},{"internalType":"uint256","name":"nodeOperatorPremium","type":"uint256"}],"name":"calculateRefund","outputs":[{"internalType":"uint256","name":"refund","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"entryPoint","outputs":[{"internalType":"contract IEntryPoint","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"initCode","type":"bytes"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes32","name":"accountGasLimits","type":"bytes32"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"bytes32","name":"gasFees","type":"bytes32"},{"internalType":"bytes","name":"paymasterAndData","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct PackedUserOperation[]","name":"ops","type":"tuple[]"}],"name":"handleOps","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum IPaymaster.PostOpMode","name":"mode","type":"uint8"},{"internalType":"bytes","name":"context","type":"bytes"},{"internalType":"uint256","name":"actualGasCost","type":"uint256"},{"internalType":"uint256","name":"actualUserOpFeePerGas","type":"uint256"}],"name":"postOp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"initCode","type":"bytes"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes32","name":"accountGasLimits","type":"bytes32"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"bytes32","name":"gasFees","type":"bytes32"},{"internalType":"bytes","name":"paymasterAndData","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct PackedUserOperation","name":"op","type":"tuple"},{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"}],"name":"simulateHandleOp","outputs":[{"components":[{"internalType":"uint256","name":"preOpGas","type":"uint256"},{"internalType":"uint256","name":"paid","type":"uint256"},{"internalType":"uint256","name":"accountValidationData","type":"uint256"},{"internalType":"uint256","name":"paymasterValidationData","type":"uint256"},{"internalType":"bool","name":"targetSuccess","type":"bool"},{"internalType":"bytes","name":"targetResult","type":"bytes"}],"internalType":"struct IEntryPointSimulations.ExecutionResult","name":"","type":"tuple"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"initCode","type":"bytes"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes32","name":"accountGasLimits","type":"bytes32"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"bytes32","name":"gasFees","type":"bytes32"},{"internalType":"bytes","name":"paymasterAndData","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct PackedUserOperation","name":"op","type":"tuple"}],"name":"simulateValidation","outputs":[{"components":[{"components":[{"internalType":"uint256","name":"preOpGas","type":"uint256"},{"internalType":"uint256","name":"prefund","type":"uint256"},{"internalType":"uint256","name":"accountValidationData","type":"uint256"},{"internalType":"uint256","name":"paymasterValidationData","type":"uint256"},{"internalType":"bytes","name":"paymasterContext","type":"bytes"}],"internalType":"struct IEntryPoint.ReturnInfo","name":"returnInfo","type":"tuple"},{"components":[{"internalType":"uint256","name":"stake","type":"uint256"},{"internalType":"uint256","name":"unstakeDelaySec","type":"uint256"}],"internalType":"struct IStakeManager.StakeInfo","name":"senderInfo","type":"tuple"},{"components":[{"internalType":"uint256","name":"stake","type":"uint256"},{"internalType":"uint256","name":"unstakeDelaySec","type":"uint256"}],"internalType":"struct IStakeManager.StakeInfo","name":"factoryInfo","type":"tuple"},{"components":[{"internalType":"uint256","name":"stake","type":"uint256"},{"internalType":"uint256","name":"unstakeDelaySec","type":"uint256"}],"internalType":"struct IStakeManager.StakeInfo","name":"paymasterInfo","type":"tuple"},{"components":[{"internalType":"address","name":"aggregator","type":"address"},{"components":[{"internalType":"uint256","name":"stake","type":"uint256"},{"internalType":"uint256","name":"unstakeDelaySec","type":"uint256"}],"internalType":"struct IStakeManager.StakeInfo","name":"stakeInfo","type":"tuple"}],"internalType":"struct IEntryPoint.AggregatorStakeInfo","name":"aggregatorInfo","type":"tuple"}],"internalType":"struct IEntryPointSimulations.ValidationResult","name":"","type":"tuple"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlockStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"initCode","type":"bytes"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes32","name":"accountGasLimits","type":"bytes32"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"bytes32","name":"gasFees","type":"bytes32"},{"internalType":"bytes","name":"paymasterAndData","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct PackedUserOperation","name":"userOp","type":"tuple"},{"internalType":"bytes32","name":"userOpHash","type":"bytes32"},{"internalType":"uint256","name":"maxCost","type":"uint256"}],"name":"validatePaymasterUserOp","outputs":[{"internalType":"bytes","name":"context","type":"bytes"},{"internalType":"uint256","name":"validationData","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"withdrawAddress","type":"address"}],"name":"withdrawStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"withdrawAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTo","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000000000071727de22e5e9d8baf0edac6f37da032

-----Decoded View---------------
Arg [0] : _entryPoint (address): 0x0000000071727De22E5E9d8BAf0edAc6f37da032

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000071727de22e5e9d8baf0edac6f37da032