Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {Create2FailedDeployment, InvalidInitializationInput} from "../../../shared/common/Errors.sol";
import {SingleOwnerMSCA} from "../../account/semi/SingleOwnerMSCA.sol";
import {PluginManager} from "../../managers/PluginManager.sol";
import {IEntryPoint} from "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";

/**
 * @dev Account factory that creates the semi-MSCA that enshrines single owner into the account storage.
 *      No plugin installation is required during account creation.
 */
contract SingleOwnerMSCAFactory {
    // logic implementation
    SingleOwnerMSCA public immutable accountImplementation;
    IEntryPoint public immutable entryPoint;

    event FactoryDeployed(address indexed factory, address accountImplementation, address entryPoint);
    event AccountCreated(address indexed proxy, address sender, bytes32 salt);

    /**
     * @dev Salted deterministic deployment using create2 and a specific logic SingleOwnerMSCA implementation.
     *      Tx/userOp is either gated by userOpValidationFunction or runtimeValidationFunction, and SingleOwnerMSCA
     *      is a minimum account with a pre built-in owner validation, so we do not require the user to install any
     * plugins
     *      during the deployment. No hooks can be injected during the account deployment, so for a future installation
     *      of more complicated plugins, please call installPlugin via a separate tx/userOp after account deployment.
     */
    constructor(address _entryPointAddr, address _pluginManagerAddr) {
        entryPoint = IEntryPoint(_entryPointAddr);
        PluginManager _pluginManager = PluginManager(_pluginManagerAddr);
        accountImplementation = new SingleOwnerMSCA(entryPoint, _pluginManager);
        emit FactoryDeployed(address(this), address(accountImplementation), _entryPointAddr);
    }

    /**
     * @dev Salted deterministic deployment using create2 and a specific logic SingleOwnerMSCA implementation.
     *      Tx/userOp is either gated by userOpValidationFunction or runtimeValidationFunction, and SingleOwnerMSCA
     *      is a minimum account with a pre built-in owner validation, so we do not require the user to install any
     * plugins
     *      during the deployment. No hooks can be injected during the account deployment, so for a future installation
     *      of more complicated plugins, please call installPlugin via a separate tx/userOp after account deployment.
     * @param _sender sender of the account deployment tx, it could be set to owner. If you don't have the owner
     * information during account creation,
     *                please use something unique, consistent and private to yourself. In the context of single owner
     * semi-MSCA, this field is mostly
     *                for consistency because we also use owner to mix the salt.
     * @param _salt salt that allows for deterministic deployment
     * @param _initializingData abi.encode(address), address should not be zero
     */
    function createAccount(address _sender, bytes32 _salt, bytes memory _initializingData)
        public
        returns (SingleOwnerMSCA account)
    {
        address owner = abi.decode(_initializingData, (address));
        (address counterfactualAddr, bytes32 mixedSalt) = _getAddress(_sender, _salt, owner);
        if (counterfactualAddr.code.length > 0) {
            return SingleOwnerMSCA(payable(counterfactualAddr));
        }
        // only perform implementation upgrade by setting empty _data in ERC1967Proxy
        // meanwhile we also initialize proxy storage, which calls PluginManager._installPlugin directly to bypass
        // validateNativeFunction checks
        account = SingleOwnerMSCA(
            payable(
                new ERC1967Proxy{salt: mixedSalt}(
                    address(accountImplementation), abi.encodeCall(SingleOwnerMSCA.initializeSingleOwnerMSCA, (owner))
                )
            )
        );
        if (address(account) != counterfactualAddr) {
            revert Create2FailedDeployment();
        }
        emit AccountCreated(counterfactualAddr, _sender, _salt);
    }

    /**
     * @dev Pre-compute the counterfactual address prior to calling createAccount.
     *      After decoding, owner is used in salt, byteCodeHash and func init call to minimize the front-running risk.
     * @param _sender sender of the account deployment tx, it could be set to owner. If you don't have the owner
     * information during account creation,
     *                please use something unique, consistent and private to yourself. In the context of single owner
     * semi-MSCA, this field is mostly
     *                for consistency because we also use owner to mix the salt.
     * @param _salt salt that allows for deterministic deployment
     * @param _initializingData abi.encode(address), address should not be zero
     */
    function getAddress(address _sender, bytes32 _salt, bytes memory _initializingData)
        public
        view
        returns (address addr, bytes32 mixedSalt)
    {
        address owner = abi.decode(_initializingData, (address));
        return _getAddress(_sender, _salt, owner);
    }

    /**
     * @dev Pre-compute the counterfactual address prior to calling createAccount.
     *      After decoding, owner is used in salt, byteCodeHash and func init call to minimize the front-running risk.
     * @param _sender sender of the account deployment tx, it could be set to owner. If you don't have the owner
     * information during account creation,
     *                please use something unique, consistent and private to yourself. In the context of single owner
     * semi-MSCA, this field is mostly
     *                for consistency because we also use owner to mix the salt.
     * @param _salt salt that allows for deterministic deployment
     * @param _owner owner of the semi MSCA
     */
    function _getAddress(address _sender, bytes32 _salt, address _owner)
        internal
        view
        returns (address addr, bytes32 mixedSalt)
    {
        if (_owner == address(0)) {
            revert InvalidInitializationInput();
        }
        mixedSalt = keccak256(abi.encodePacked(_sender, _owner, _salt));
        bytes32 code = keccak256(
            abi.encodePacked(
                type(ERC1967Proxy).creationCode,
                abi.encode(
                    address(accountImplementation), abi.encodeCall(SingleOwnerMSCA.initializeSingleOwnerMSCA, (_owner))
                )
            )
        );
        addr = Create2.computeAddress(mixedSalt, code, address(this));
        return (addr, mixedSalt);
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

/**
 * @notice Throws when the caller is unexpected.
 */
error UnauthorizedCaller();

/**
 * @notice Throws when the selector is not found.
 */
error NotFoundSelector();

/**
 * @notice Throws when authorizer is invalid.
 */
error InvalidAuthorizer();

error InvalidValidationFunctionId(uint8 functionId);

error InvalidFunctionReference();

error ItemAlreadyExists();

error ItemDoesNotExist();

error InvalidLimit();

error InvalidExecutionFunction(bytes4 selector);

error InvalidInitializationInput();

error Create2FailedDeployment();

error InvalidLength();

error Unsupported();

error NotImplemented(bytes4 selector, uint8 functionId);

error InvalidItem();

// v2 NotImplemented
error NotImplementedFunction(bytes4 selector, uint32 entityId);

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {DefaultCallbackHandler} from "../../../../../callback/DefaultCallbackHandler.sol";

import {
    EIP1271_INVALID_SIGNATURE,
    EIP1271_VALID_SIGNATURE,
    EMPTY_FUNCTION_REFERENCE,
    EMPTY_FUNCTION_REFERENCE,
    SENTINEL_BYTES21,
    SIG_VALIDATION_FAILED,
    SIG_VALIDATION_SUCCEEDED,
    WALLET_VERSION_1
} from "../../../../../common/Constants.sol";
import {ExecutionUtils} from "../../../../../utils/ExecutionUtils.sol";
import {
    InvalidAuthorizer,
    InvalidValidationFunctionId,
    NotFoundSelector,
    UnauthorizedCaller
} from "../../../shared/common/Errors.sol";
import {ValidationData} from "../../../shared/common/Structs.sol";
import {ValidationDataLib} from "../../../shared/libs/ValidationDataLib.sol";
import {
    PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE,
    RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
} from "../../common/Constants.sol";
import {ExecutionDetail, FunctionReference, RepeatableBytes21DLL} from "../../common/Structs.sol";
import {IPlugin} from "../../interfaces/IPlugin.sol";
import {FunctionReferenceLib} from "../../libs/FunctionReferenceLib.sol";
import {RepeatableFunctionReferenceDLLLib} from "../../libs/RepeatableFunctionReferenceDLLLib.sol";
import {WalletStorageV1Lib} from "../../libs/WalletStorageV1Lib.sol";
import {PluginManager} from "../../managers/PluginManager.sol";
import {BaseMSCA} from "../BaseMSCA.sol";
import {IEntryPoint} from "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import {UserOperation} from "@account-abstraction/contracts/interfaces/UserOperation.sol";
import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.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 {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

import {BaseERC712CompliantAccount} from "../../../../../erc712/BaseERC712CompliantAccount.sol";
import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

/**
 * @dev Semi-MSCA that enshrines single owner into the account storage.
 */
contract SingleOwnerMSCA is BaseMSCA, DefaultCallbackHandler, UUPSUpgradeable, IERC1271, BaseERC712CompliantAccount {
    using ExecutionUtils for address;
    using ECDSA for bytes32;
    using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
    using FunctionReferenceLib for bytes21;
    using FunctionReferenceLib for FunctionReference;
    using ValidationDataLib for ValidationData;

    enum FunctionId {
        NATIVE_RUNTIME_VALIDATION_OWNER_OR_SELF,
        NATIVE_USER_OP_VALIDATION_OWNER
    }

    string public constant NAME = "Circle_SingleOwnerMSCA";
    bytes32 private constant _HASHED_NAME = keccak256(bytes(NAME));
    bytes32 private constant _HASHED_VERSION = keccak256(bytes(WALLET_VERSION_1));
    bytes32 private constant _MESSAGE_TYPEHASH = keccak256("CircleSingleOwnerMSCAMessage(bytes32 hash)");

    event SingleOwnerMSCAInitialized(address indexed account, address indexed entryPointAddress, address owner);
    event OwnershipTransferred(address indexed account, address indexed previousOwner, address indexed newOwner);

    error InvalidOwnerForMSCA(address account, address owner);
    error NoOwnershipPluginDefined();

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

    constructor(IEntryPoint _newEntryPoint, PluginManager _newPluginManager)
        BaseMSCA(_newEntryPoint, _newPluginManager)
    {
        // lock the implementation contract so it can only be called from proxies
        _disableWalletStorageInitializers();
    }

    /// @notice Initializes the account with a set of plugins
    /// @dev No dependencies or hooks can be injected with this installation. For a full installation, please use
    /// installPlugin.
    /// @param owner The initial owner
    function initializeSingleOwnerMSCA(address owner) external walletStorageInitializer {
        if (owner == address(0)) {
            revert InvalidOwnerForMSCA(address(this), owner);
        }
        _transferNativeOwnership(owner);
        emit SingleOwnerMSCAInitialized(address(this), address(entryPoint), owner);
    }

    /// @inheritdoc IERC1271
    function isValidSignature(bytes32 hash, bytes memory signature) external view override returns (bytes4) {
        address owner = WalletStorageV1Lib.getLayout().owner;
        if (owner == address(0)) {
            // isValidSignature is installed via plugin, so it should fallback to the plugin
            (bool success, bytes memory returnData) = WalletStorageV1Lib.getLayout().executionDetails[IERC1271
                .isValidSignature
                .selector].plugin.staticcall(abi.encodeCall(IERC1271.isValidSignature, (hash, signature)));
            if (!success) {
                return EIP1271_INVALID_SIGNATURE;
            }
            return abi.decode(returnData, (bytes4));
        } else {
            // use address(this) to prevent replay attacks
            bytes32 replaySafeHash = getReplaySafeMessageHash(hash);
            if (SignatureChecker.isValidSignatureNow(owner, replaySafeHash, signature)) {
                return EIP1271_VALID_SIGNATURE;
            }
            return EIP1271_INVALID_SIGNATURE;
        }
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current msg.sender.
     */
    function transferNativeOwnership(address newOwner) public onlyFromEntryPointOrOwnerOrSelf validateNativeFunction {
        if (newOwner == address(0)) {
            revert InvalidOwnerForMSCA(address(this), newOwner);
        }
        _transferNativeOwnership(newOwner);
    }

    /**
     * @dev Leaves the contract without owner. Can only be initiated by the current owner.
     *
     * NOTE: Irreversible. Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner. Please
     * make sure you've already have other backup validations before calling this method.
     * If the user wants to switch to the validations provided by plugins, please call this
     * function after you install the plugin, so owner will be disabled.
     */
    function renounceNativeOwnership() public onlyFromEntryPointOrOwnerOrSelf validateNativeFunction {
        // we need a ownership plugin in place before renouncing native ownership
        if (WalletStorageV1Lib.getLayout().executionDetails[IERC1271.isValidSignature.selector].plugin == address(0)) {
            revert NoOwnershipPluginDefined();
        }
        _transferNativeOwnership(address(0));
    }

    /**
     * @dev Returns the current owner.
     */
    function getNativeOwner() public view returns (address) {
        return WalletStorageV1Lib.getLayout().owner;
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(BaseMSCA, DefaultCallbackHandler)
        returns (bool)
    {
        // BaseMSCA has already implemented ERC165
        return BaseMSCA.supportsInterface(interfaceId) || interfaceId == type(IERC721Receiver).interfaceId
            || interfaceId == type(IERC1155Receiver).interfaceId || interfaceId == type(IERC1271).interfaceId;
    }

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

    /**
     * @dev We run the native validation function if it's enabled, otherwise we fallback to the plugin validation
     * functions.
     *      In either case, we run the hooks from plugins if there's any.
     */
    function _authenticateAndAuthorizeUserOp(UserOperation calldata userOp, bytes32 userOpHash)
        internal
        override
        returns (uint256 validationData)
    {
        // onlyFromEntryPoint is applied in the caller
        // if there is no function defined for the selector, or if userOp.callData.length < 4, then execution MUST
        // revert
        if (userOp.callData.length < 4) {
            revert NotFoundSelector();
        }
        bytes4 selector = bytes4(userOp.callData[0:4]);
        if (selector == bytes4(0)) {
            revert NotFoundSelector();
        }
        ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[selector];
        // check validation function for non native case first
        FunctionReference memory validationFunction = executionDetail.userOpValidationFunction;
        address owner = WalletStorageV1Lib.getLayout().owner;
        if (owner == address(0)) {
            bytes21 packedValidationFunction = validationFunction.pack();
            if (
                packedValidationFunction == EMPTY_FUNCTION_REFERENCE
                    || packedValidationFunction == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
                    || packedValidationFunction == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
            ) {
                revert InvalidValidationFunctionId(validationFunction.functionId);
            }
        }
        // pre hook
        ValidationData memory unpackedValidationData =
            _processPreUserOpValidationHooks(executionDetail, userOp, userOpHash);
        uint256 currentValidationData;
        // userOp validation
        // no native validation function
        if (owner == address(0)) {
            IPlugin userOpValidatorPlugin = IPlugin(validationFunction.plugin);
            // execute the validation function with the user operation and its hash as parameters using the call opcode
            currentValidationData = userOpValidatorPlugin.userOpValidationFunction(
                executionDetail.userOpValidationFunction.functionId, userOp, userOpHash
            );
        } else {
            if (SignatureChecker.isValidSignatureNow(owner, userOpHash.toEthSignedMessageHash(), userOp.signature)) {
                currentValidationData = SIG_VALIDATION_SUCCEEDED;
            } else {
                currentValidationData = SIG_VALIDATION_FAILED;
            }
        }

        // intercept with last result
        unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
        if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1)) {
            // only revert on unexpected values
            revert InvalidAuthorizer();
        }
        validationData = unpackedValidationData._packValidationData();
    }

    function _processPreRuntimeHooksAndValidation(bytes4 selector) internal override {
        if (msg.sender == address(entryPoint)) {
            // entryPoint should go through validateUserOp flow which calls userOpValidationFunction
            return;
        }
        ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[selector];
        FunctionReference memory validationFunction = executionDetail.runtimeValidationFunction;
        RepeatableBytes21DLL storage preRuntimeValidationHooksDLL = executionDetail.preRuntimeValidationHooks;
        uint256 totalUniqueHookCount = preRuntimeValidationHooksDLL.getUniqueItems();
        FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        FunctionReference[] memory preRuntimeValidationHooks;
        FunctionReference memory nextHook;
        for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
            (preRuntimeValidationHooks, nextHook) = preRuntimeValidationHooksDLL.getPaginated(startHook, 10);
            for (uint256 j = 0; j < preRuntimeValidationHooks.length; ++j) {
                // revert on EMPTY_FUNCTION_REFERENCE, RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE,
                // PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
                // if any revert, the outer call MUST revert
                bytes21 packedPreRuntimeValidationHook = preRuntimeValidationHooks[j].pack();
                if (
                    packedPreRuntimeValidationHook == EMPTY_FUNCTION_REFERENCE
                        || packedPreRuntimeValidationHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
                        || packedPreRuntimeValidationHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
                ) {
                    revert InvalidValidationFunctionId(preRuntimeValidationHooks[j].functionId);
                }
                IPlugin preRuntimeValidationHookPlugin = IPlugin(preRuntimeValidationHooks[j].plugin);
                try preRuntimeValidationHookPlugin.preRuntimeValidationHook(
                    preRuntimeValidationHooks[j].functionId, msg.sender, msg.value, msg.data
                ) {} catch (bytes memory revertReason) {
                    revert PreRuntimeValidationHookFailed(
                        preRuntimeValidationHooks[j].plugin, preRuntimeValidationHooks[j].functionId, revertReason
                    );
                }
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        address owner = WalletStorageV1Lib.getLayout().owner;
        // no native validation function
        if (owner == address(0)) {
            bytes21 packedValidationFunction = validationFunction.pack();
            if (
                packedValidationFunction == EMPTY_FUNCTION_REFERENCE
                    || packedValidationFunction == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
            ) {
                revert InvalidValidationFunctionId(validationFunction.functionId);
            }
            // call runtimeValidationFunction if it's not always allowed
            if (packedValidationFunction != RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE) {
                try IPlugin(validationFunction.plugin).runtimeValidationFunction(
                    validationFunction.functionId, msg.sender, msg.value, msg.data
                ) {} catch (bytes memory revertReason) {
                    revert RuntimeValidationFailed(
                        validationFunction.plugin, validationFunction.functionId, revertReason
                    );
                }
            }
            return;
        } else {
            // the msg.sender should be the owner of the account or itself
            if (msg.sender == owner || msg.sender == address(this)) {
                return;
            } else {
                revert UnauthorizedCaller();
            }
        }
    }

    /// @inheritdoc UUPSUpgradeable
    function upgradeTo(address newImplementation) public override onlyProxy validateNativeFunction {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /// @inheritdoc UUPSUpgradeable
    function upgradeToAndCall(address newImplementation, bytes memory data)
        public
        payable
        override
        onlyProxy
        validateNativeFunction
    {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data, true);
    }

    /**
     * @dev The function is overridden here so more granular ACLs to the upgrade mechanism should be enforced by
     * plugins.
     */
    function _authorizeUpgrade(address newImplementation) internal override {}

    function _processPreUserOpValidationHooks(
        ExecutionDetail storage executionDetail,
        UserOperation calldata userOp,
        bytes32 userOpHash
    ) internal override returns (ValidationData memory unpackedValidationData) {
        unpackedValidationData = ValidationData(0, 0xFFFFFFFFFFFF, address(0));
        // if the function selector has associated pre user operation validation hooks, then those hooks MUST be run
        // sequentially
        uint256 totalUniqueHookCount = executionDetail.preUserOpValidationHooks.getUniqueItems();
        FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        FunctionReference[] memory preUserOpValidatorHooks;
        FunctionReference memory nextHook;
        uint256 currentValidationData;
        for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
            (preUserOpValidatorHooks, nextHook) = executionDetail.preUserOpValidationHooks.getPaginated(startHook, 10);
            for (uint256 j = 0; j < preUserOpValidatorHooks.length; ++j) {
                bytes21 packedUserOpValidatorHook = preUserOpValidatorHooks[j].pack();
                // if any revert, the outer call MUST revert
                if (
                    packedUserOpValidatorHook == EMPTY_FUNCTION_REFERENCE
                        || packedUserOpValidatorHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
                        || packedUserOpValidatorHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
                ) {
                    revert InvalidHookFunctionId(preUserOpValidatorHooks[j].functionId);
                }
                IPlugin preUserOpValidationHookPlugin = IPlugin(preUserOpValidatorHooks[j].plugin);
                currentValidationData = preUserOpValidationHookPlugin.preUserOpValidationHook(
                    preUserOpValidatorHooks[j].functionId, userOp, userOpHash
                );
                unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
                // if any return an authorizer value other than 0 or 1, execution MUST revert
                if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1))
                {
                    revert InvalidAuthorizer();
                }
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        return unpackedValidationData;
    }

    function _checkFromEPOrOwnerOrSelf() internal view {
        // all need to go through validation first, which means being initiated by the owner or account
        if (
            msg.sender != address(entryPoint) && msg.sender != WalletStorageV1Lib.getLayout().owner
                && msg.sender != address(this)
        ) {
            revert UnauthorizedCaller();
        }
    }

    /// @inheritdoc BaseERC712CompliantAccount
    function _getAccountTypeHash() internal pure override returns (bytes32) {
        return _MESSAGE_TYPEHASH;
    }

    /// @inheritdoc BaseERC712CompliantAccount
    function _getAccountName() internal pure override returns (bytes32) {
        return _HASHED_NAME;
    }

    /// @inheritdoc BaseERC712CompliantAccount
    function _getAccountVersion() internal pure override returns (bytes32) {
        return _HASHED_VERSION;
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {EMPTY_FUNCTION_REFERENCE} from "../../../../common/Constants.sol";
import {InvalidFunctionReference} from "../../shared/common/Errors.sol";
import {AddressDLL} from "../../shared/common/Structs.sol";
import {AddressDLLLib} from "../../shared/libs/AddressDLLLib.sol";
import {
    PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE,
    RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
} from "../common/Constants.sol";
import "../common/PluginManifest.sol";
import "../common/Structs.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {FunctionReferenceDLLLib} from "../libs/FunctionReferenceDLLLib.sol";
import {FunctionReferenceLib} from "../libs/FunctionReferenceLib.sol";
import {RepeatableFunctionReferenceDLLLib} from "../libs/RepeatableFunctionReferenceDLLLib.sol";
import {SelectorRegistryLib} from "../libs/SelectorRegistryLib.sol";
import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";

/**
 * @dev Default implementation of https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to
 * support installing and uninstalling plugins.
 */
contract PluginManager {
    using AddressDLLLib for AddressDLL;
    using FunctionReferenceDLLLib for Bytes21DLL;
    using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
    using FunctionReferenceLib for FunctionReference;
    using FunctionReferenceLib for bytes21;
    using SelectorRegistryLib for bytes4;

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

    enum AssociatedFunctionType {
        HOOK,
        VALIDATION_FUNCTION
    }

    error PluginNotImplementInterface();
    error InvalidPluginManifest();
    error InvalidPluginManifestHash();
    error InvalidPluginDependency(address plugin);
    error PluginUsedByOthers(address plugin);
    error ExecutionDetailAlreadySet(address plugin, bytes4 selector);
    error ExecuteFromPluginExternalAlreadySet(address plugin, address externalAddress);
    error ExecuteFromPluginExternalAlreadyUnset(address plugin, address externalAddress);
    error ValidationFunctionAlreadySet(bytes4 selector);
    error FailToCallOnInstall(address plugin, bytes revertReason);
    error OnlyDelegated();
    error HookDependencyNotPermitted();
    error InvalidExecutionSelector(address plugin, bytes4 selector);

    modifier onlyDelegated() {
        if (address(this) == __self) {
            revert OnlyDelegated();
        }
        _;
    }

    /// @dev Refer to IPluginManager
    function install(
        address plugin,
        bytes32 manifestHash,
        bytes memory pluginInstallData,
        FunctionReference[] memory dependencies,
        address msca
    ) external onlyDelegated {
        // revert if the plugin does not implement ERC-165 or does not support the IPlugin interface
        if (!ERC165Checker.supportsInterface(plugin, type(IPlugin).interfaceId)) {
            revert PluginNotImplementInterface();
        }
        WalletStorageV1Lib.Layout storage storageLayout = WalletStorageV1Lib.getLayout();
        // revert internally if the plugin has already been installed on the modular account
        storageLayout.installedPlugins.append(plugin);
        IPlugin pluginToInstall = IPlugin(plugin);
        // revert if manifestHash does not match the computed Keccak-256 hash of the plugin’s returned manifest
        PluginManifest memory pluginManifest = pluginToInstall.pluginManifest();
        if (manifestHash != keccak256(abi.encode(pluginManifest))) {
            revert InvalidPluginManifestHash();
        }
        // store the plugin manifest hash
        storageLayout.pluginDetails[plugin].manifestHash = manifestHash;
        uint256 length = pluginManifest.interfaceIds.length;
        for (uint256 i = 0; i < length; ++i) {
            storageLayout.supportedInterfaces[pluginManifest.interfaceIds[i]] += 1;
        }
        // revert if any address in dependencies does not support the interface at its matching index in the manifest’s
        // dependencyInterfaceIds,
        // or if the two array lengths do not match,
        // or if any of the dependencies are not already installed on the modular account
        length = dependencies.length;
        if (length != pluginManifest.dependencyInterfaceIds.length) {
            revert InvalidPluginDependency(plugin);
        }
        for (uint256 i = 0; i < length; ++i) {
            address dependencyPluginAddr = dependencies[i].plugin;
            // if dependencyPluginAddr is msca address, then we don't actually introduce any new plugin dependency
            // other than native dependency, so we do not need to perform any plugin dependency related logic
            if (dependencyPluginAddr == msca) {
                continue;
            }
            if (!ERC165Checker.supportsInterface(dependencyPluginAddr, pluginManifest.dependencyInterfaceIds[i])) {
                revert InvalidPluginDependency(dependencyPluginAddr);
            }
            // the dependency plugin needs to be installed first
            if (!storageLayout.installedPlugins.contains(dependencyPluginAddr)) {
                revert InvalidPluginDependency(dependencyPluginAddr);
            }
            // each dependency’s record MUST also be updated to reflect that it has a new dependent
            // record the plugin dependency, will revert if it's already installed
            storageLayout.pluginDetails[plugin].dependencies.append(dependencies[i]);
            // increment the dependency's dependentCounter since the current plugin is dependent on dependencyPlugin
            storageLayout.pluginDetails[dependencyPluginAddr].dependentCounter += 1;
        }

        // record if this plugin is allowed to spend native token
        if (pluginManifest.canSpendNativeToken) {
            storageLayout.pluginDetails[plugin].canSpendNativeToken = true;
        }

        // record execution details
        //////////////////////////////////////////////
        // install execution functions and hooks
        //////////////////////////////////////////////
        length = pluginManifest.executionFunctions.length;
        for (uint256 i = 0; i < length; ++i) {
            bytes4 selector = pluginManifest.executionFunctions[i];
            if (storageLayout.executionDetails[selector].plugin != address(0)) {
                revert ExecutionDetailAlreadySet(plugin, selector);
            }
            if (
                selector._isNativeFunctionSelector() || selector._isErc4337FunctionSelector()
                    || selector._isIPluginFunctionSelector()
            ) {
                revert InvalidExecutionSelector(plugin, selector);
            }
            storageLayout.executionDetails[selector].plugin = plugin;
        }

        // install pre and post execution hooks
        length = pluginManifest.executionHooks.length;
        for (uint256 i = 0; i < length; ++i) {
            bytes4 selector = pluginManifest.executionHooks[i].selector;
            FunctionReference memory preExecHook = _resolveManifestFunction(
                pluginManifest.executionHooks[i].preExecHook,
                plugin,
                dependencies,
                ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
                AssociatedFunctionType.HOOK
            );
            FunctionReference memory postExecHook = _resolveManifestFunction(
                pluginManifest.executionHooks[i].postExecHook,
                plugin,
                dependencies,
                ManifestAssociatedFunctionType.NONE,
                AssociatedFunctionType.HOOK
            );
            _addHookGroup(storageLayout.executionDetails[selector].executionHooks, preExecHook, postExecHook);
        }

        //////////////////////////////////////////////
        // install validation functions and hooks
        //////////////////////////////////////////////
        // install userOpValidationFunctions
        length = pluginManifest.userOpValidationFunctions.length;
        for (uint256 i = 0; i < length; ++i) {
            bytes4 selector = pluginManifest.userOpValidationFunctions[i].executionSelector;
            if (storageLayout.executionDetails[selector].userOpValidationFunction.pack() != EMPTY_FUNCTION_REFERENCE) {
                revert ValidationFunctionAlreadySet(selector);
            }
            storageLayout.executionDetails[selector].userOpValidationFunction = _resolveManifestFunction(
                pluginManifest.userOpValidationFunctions[i].associatedFunction,
                plugin,
                dependencies,
                ManifestAssociatedFunctionType.NONE,
                AssociatedFunctionType.VALIDATION_FUNCTION
            );
        }
        // install runtimeValidationFunctions
        length = pluginManifest.runtimeValidationFunctions.length;
        for (uint256 i = 0; i < length; ++i) {
            bytes4 selector = pluginManifest.runtimeValidationFunctions[i].executionSelector;
            if (storageLayout.executionDetails[selector].runtimeValidationFunction.pack() != EMPTY_FUNCTION_REFERENCE) {
                revert ValidationFunctionAlreadySet(selector);
            }
            storageLayout.executionDetails[selector].runtimeValidationFunction = _resolveManifestFunction(
                pluginManifest.runtimeValidationFunctions[i].associatedFunction,
                plugin,
                dependencies,
                ManifestAssociatedFunctionType.RUNTIME_VALIDATION_ALWAYS_ALLOW, // risk burning gas from the account
                AssociatedFunctionType.VALIDATION_FUNCTION
            );
        }
        // install preUserOpValidationHooks
        length = pluginManifest.preUserOpValidationHooks.length;
        // force override to be safe
        FunctionReference[] memory emptyDependencies = new FunctionReference[](0);
        for (uint256 i = 0; i < length; ++i) {
            bytes4 selector = pluginManifest.preUserOpValidationHooks[i].executionSelector;
            // revert internally
            storageLayout.executionDetails[selector].preUserOpValidationHooks.append(
                _resolveManifestFunction(
                    pluginManifest.preUserOpValidationHooks[i].associatedFunction,
                    plugin,
                    emptyDependencies,
                    ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
                    AssociatedFunctionType.HOOK
                )
            );
        }
        // install preRuntimeValidationHooks
        length = pluginManifest.preRuntimeValidationHooks.length;
        for (uint256 i = 0; i < length; ++i) {
            // revert internally
            storageLayout.executionDetails[pluginManifest.preRuntimeValidationHooks[i].executionSelector]
                .preRuntimeValidationHooks
                .append(
                _resolveManifestFunction(
                    pluginManifest.preRuntimeValidationHooks[i].associatedFunction,
                    plugin,
                    emptyDependencies,
                    ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
                    AssociatedFunctionType.HOOK
                )
            );
        }

        // store the plugin’s permitted function selectors and external contract calls to be able to validate calls
        // to executeFromPlugin and executeFromPluginExternal
        //////////////////////////////////////////////
        // permissions for executeFromPlugin
        //////////////////////////////////////////////
        // native functions or execution functions already installed on the MSCA that this plugin will be able to call
        length = pluginManifest.permittedExecutionSelectors.length;
        for (uint256 i = 0; i < length; ++i) {
            // enable PermittedPluginCall
            storageLayout.permittedPluginCalls[plugin][pluginManifest.permittedExecutionSelectors[i]] = true;
        }

        //////////////////////////////////////////////
        // permissions for executeFromPluginExternal
        //////////////////////////////////////////////
        // is the plugin permitted to call any external contracts and selectors
        if (pluginManifest.permitAnyExternalAddress) {
            storageLayout.pluginDetails[plugin].anyExternalAddressPermitted = true;
        } else {
            // more limited access - record external contract calls that this plugin will be able to make
            length = pluginManifest.permittedExternalCalls.length;
            for (uint256 i = 0; i < length; ++i) {
                ManifestExternalCallPermission memory externalCallPermission = pluginManifest.permittedExternalCalls[i];
                PermittedExternalCall storage permittedExternalCall =
                    storageLayout.permittedExternalCalls[plugin][externalCallPermission.externalAddress];
                if (permittedExternalCall.addressPermitted) {
                    revert ExecuteFromPluginExternalAlreadySet(plugin, externalCallPermission.externalAddress);
                }
                permittedExternalCall.addressPermitted = true;
                if (externalCallPermission.permitAnySelector) {
                    permittedExternalCall.anySelector = true;
                } else {
                    uint256 permittedExternalCallSelectorsLength = externalCallPermission.selectors.length;
                    for (uint256 j = 0; j < permittedExternalCallSelectorsLength; ++j) {
                        permittedExternalCall.selectors[externalCallPermission.selectors[j]] = true;
                    }
                }
            }
        }

        // call onInstall to initialize plugin data for the modular account
        // solhint-disable-next-line no-empty-blocks
        try IPlugin(plugin).onInstall(pluginInstallData) {}
        catch (bytes memory revertReason) {
            revert FailToCallOnInstall(plugin, revertReason);
        }
    }

    /// @dev Refer to IPluginManager
    function uninstall(address plugin, bytes memory config, bytes memory pluginUninstallData)
        external
        onlyDelegated
        returns (bool)
    {
        WalletStorageV1Lib.Layout storage storageLayout = WalletStorageV1Lib.getLayout();
        // revert internally if plugin was not installed before
        storageLayout.installedPlugins.remove(plugin);
        PluginManifest memory pluginManifest;
        if (config.length > 0) {
            // the modular account MAY implement the capability for the manifest to be encoded in the config field as a
            // parameter
            pluginManifest = abi.decode(config, (PluginManifest));
        } else {
            pluginManifest = IPlugin(plugin).pluginManifest();
        }
        // revert if the hash of the manifest used at install time does not match the computed Keccak-256 hash of the
        // plugin’s current manifest
        if (storageLayout.pluginDetails[plugin].manifestHash != keccak256(abi.encode(pluginManifest))) {
            revert InvalidPluginManifestHash();
        }
        // revert if there is at least 1 other installed plugin that depends on validation functions or hooks added by
        // this plugin;
        // plugins used as dependencies must not be uninstalled while dependent plugins exist
        if (storageLayout.pluginDetails[plugin].dependentCounter != 0) {
            revert PluginUsedByOthers(plugin);
        }
        // each dependency’s record SHOULD be updated to reflect that it has no longer has this plugin as a dependent
        _removeDependencies(plugin, storageLayout);
        // remove records for the plugin’s dependencies, injected permitted call hooks, permitted function selectors,
        // and permitted external contract calls
        // uninstall the components in reverse order (by component type) of their installation
        //////////////////////////////////////////////
        // permissions for executeFromPluginExternal
        //////////////////////////////////////////////
        if (pluginManifest.permitAnyExternalAddress) {
            storageLayout.pluginDetails[plugin].anyExternalAddressPermitted = false;
        }
        uint256 length;
        if (!pluginManifest.permitAnyExternalAddress) {
            length = pluginManifest.permittedExternalCalls.length;
            for (uint256 i = 0; i < length; ++i) {
                ManifestExternalCallPermission memory externalCallPermission = pluginManifest.permittedExternalCalls[i];
                PermittedExternalCall storage permittedExternalCall =
                    storageLayout.permittedExternalCalls[plugin][externalCallPermission.externalAddress];
                if (!permittedExternalCall.addressPermitted) {
                    revert ExecuteFromPluginExternalAlreadyUnset(plugin, externalCallPermission.externalAddress);
                }
                permittedExternalCall.addressPermitted = false;
                if (externalCallPermission.permitAnySelector) {
                    permittedExternalCall.anySelector = false;
                } else {
                    uint256 permittedExternalCallSelectorsLength = externalCallPermission.selectors.length;
                    for (uint256 j = 0; j < permittedExternalCallSelectorsLength; ++j) {
                        permittedExternalCall.selectors[externalCallPermission.selectors[j]] = false;
                    }
                }
            }
        }

        length = pluginManifest.permittedExecutionSelectors.length;
        for (uint256 i = 0; i < length; ++i) {
            // disable PermittedPluginCall
            storageLayout.permittedPluginCalls[plugin][pluginManifest.permittedExecutionSelectors[i]] = false;
        }

        //////////////////////////////////////////////
        // uninstall validation functions and hooks
        //////////////////////////////////////////////
        // uninstall preRuntimeValidationHooks
        FunctionReference[] memory emptyDependencies = new FunctionReference[](0);
        length = pluginManifest.preRuntimeValidationHooks.length;
        for (uint256 i = 0; i < length; ++i) {
            // revert internally
            storageLayout.executionDetails[pluginManifest.preRuntimeValidationHooks[i].executionSelector]
                .preRuntimeValidationHooks
                .remove(
                _resolveManifestFunction(
                    pluginManifest.preRuntimeValidationHooks[i].associatedFunction,
                    plugin,
                    emptyDependencies,
                    ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
                    AssociatedFunctionType.HOOK
                )
            );
        }
        // uninstall preUserOpValidationHooks
        length = pluginManifest.preUserOpValidationHooks.length;
        for (uint256 i = 0; i < length; ++i) {
            // revert internally
            storageLayout.executionDetails[pluginManifest.preUserOpValidationHooks[i].executionSelector]
                .preUserOpValidationHooks
                .remove(
                _resolveManifestFunction(
                    pluginManifest.preUserOpValidationHooks[i].associatedFunction,
                    plugin,
                    emptyDependencies,
                    ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
                    AssociatedFunctionType.HOOK
                )
            );
        }
        // uninstall runtimeValidationFunctions
        FunctionReference memory emptyFunctionReference = EMPTY_FUNCTION_REFERENCE.unpack();
        length = pluginManifest.runtimeValidationFunctions.length;
        for (uint256 i = 0; i < length; ++i) {
            storageLayout.executionDetails[pluginManifest.runtimeValidationFunctions[i].executionSelector]
                .runtimeValidationFunction = emptyFunctionReference;
        }
        // uninstall userOpValidationFunctions
        length = pluginManifest.userOpValidationFunctions.length;
        for (uint256 i = 0; i < length; ++i) {
            storageLayout.executionDetails[pluginManifest.userOpValidationFunctions[i].executionSelector]
                .userOpValidationFunction = emptyFunctionReference;
        }

        //////////////////////////////////////////////
        // uninstall execution functions and hooks
        //////////////////////////////////////////////
        _removeExecutionHooks(plugin, pluginManifest.executionHooks, storageLayout);
        length = pluginManifest.executionFunctions.length;
        for (uint256 i = 0; i < length; ++i) {
            storageLayout.executionDetails[pluginManifest.executionFunctions[i]].plugin = address(0);
        }

        length = pluginManifest.interfaceIds.length;
        for (uint256 i = 0; i < length; ++i) {
            storageLayout.supportedInterfaces[pluginManifest.interfaceIds[i]] -= 1;
        }
        // reset all members that are not mappings and also recurse into the members unless they're mappings
        delete storageLayout.pluginDetails[plugin];
        // call the plugin’s onUninstall callback with the data provided in the uninstallData parameter;
        // This serves to clear the plugin state for the modular account;
        // If onUninstall reverts, execution SHOULD continue to allow the uninstall to complete
        bool onUninstallSucceeded = true;
        // solhint-disable-next-line no-empty-blocks
        try IPlugin(plugin).onUninstall(pluginUninstallData) {}
        catch {
            // leave it up to the caller if we want to revert if the plugin storage isn't cleaned up
            onUninstallSucceeded = false;
        }
        return onUninstallSucceeded;
    }

    /**
     * @dev Resolve manifest function.
     *      For functions of type `ManifestAssociatedFunctionType.DEPENDENCY`, the MSCA MUST find the plugin address
     *      of the function at `dependencies[dependencyIndex]` during the call to `installPlugin(config)`.
     *      A plugin can no longer use hooks from other plugins to be added on Execution and/or Validation function
     * selectors
     *      in its own manifest. We'll revert if hook is provided as dependency from an external plugin.
     * @param allowedMagicValue which magic value (if any) is permissible for the function type to resolve.
     * @param associatedFunctionType the type of associated function, either a validation function or a hook, as opposed
     * to execution functions
     */
    function _resolveManifestFunction(
        ManifestFunction memory manifestFunction,
        address plugin,
        FunctionReference[] memory dependencies,
        ManifestAssociatedFunctionType allowedMagicValue,
        AssociatedFunctionType associatedFunctionType
    ) internal pure returns (FunctionReference memory) {
        // revert if it's hook and provided as dependency
        if (
            associatedFunctionType == AssociatedFunctionType.HOOK
                && manifestFunction.functionType == ManifestAssociatedFunctionType.DEPENDENCY
        ) {
            revert HookDependencyNotPermitted();
        }
        if (manifestFunction.functionType == ManifestAssociatedFunctionType.SELF) {
            return FunctionReference(plugin, manifestFunction.functionId);
        } else if (manifestFunction.functionType == ManifestAssociatedFunctionType.DEPENDENCY) {
            // out of boundary
            if (manifestFunction.dependencyIndex >= dependencies.length) {
                revert InvalidPluginManifest();
            }
            return dependencies[manifestFunction.dependencyIndex];
        } else if (manifestFunction.functionType == ManifestAssociatedFunctionType.RUNTIME_VALIDATION_ALWAYS_ALLOW) {
            if (allowedMagicValue == ManifestAssociatedFunctionType.RUNTIME_VALIDATION_ALWAYS_ALLOW) {
                return RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE.unpack();
            } else {
                revert InvalidPluginManifest();
            }
        } else if (manifestFunction.functionType == ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY) {
            if (allowedMagicValue == ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY) {
                return PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE.unpack();
            } else {
                revert InvalidPluginManifest();
            }
        } else {
            return EMPTY_FUNCTION_REFERENCE.unpack();
        }
    }

    function _addHookGroup(
        HookGroup storage hookGroup,
        FunctionReference memory preExecHook,
        FunctionReference memory postExecHook
    ) internal {
        bytes21 packedPreExecHook = preExecHook.pack();
        if (packedPreExecHook == EMPTY_FUNCTION_REFERENCE) {
            if (postExecHook.pack() == EMPTY_FUNCTION_REFERENCE) {
                // pre and post hooks cannot be null at the same time
                revert InvalidFunctionReference();
            }
            hookGroup.postOnlyHooks.append(postExecHook);
        } else {
            hookGroup.preHooks.append(preExecHook);
            if (postExecHook.pack() != EMPTY_FUNCTION_REFERENCE) {
                hookGroup.preToPostHooks[packedPreExecHook].append(postExecHook);
            }
        }
    }

    function _removeHookGroup(
        HookGroup storage hookGroup,
        FunctionReference memory preExecHook,
        FunctionReference memory postExecHook
    ) internal {
        bytes21 packedPreExecHook = preExecHook.pack();
        if (packedPreExecHook == EMPTY_FUNCTION_REFERENCE) {
            // pre and post hooks cannot be null at the same time
            hookGroup.postOnlyHooks.remove(postExecHook);
        } else {
            hookGroup.preHooks.remove(preExecHook);
            // remove postExecHook if any
            if (postExecHook.pack() != EMPTY_FUNCTION_REFERENCE) {
                hookGroup.preToPostHooks[packedPreExecHook].remove(postExecHook);
            }
        }
    }

    function _removeDependencies(address plugin, WalletStorageV1Lib.Layout storage storageLayout) internal {
        Bytes21DLL storage pluginDependencies = storageLayout.pluginDetails[plugin].dependencies;
        uint256 length = pluginDependencies.size();
        FunctionReference memory startFR = EMPTY_FUNCTION_REFERENCE.unpack();
        FunctionReference[] memory dependencies;
        for (uint256 i = 0; i < length; ++i) {
            (dependencies, startFR) = pluginDependencies.getPaginated(startFR, 100);
            for (uint256 j = 0; j < dependencies.length; ++j) {
                storageLayout.pluginDetails[dependencies[j].plugin].dependentCounter -= 1;
                storageLayout.pluginDetails[plugin].dependencies.remove(dependencies[j]);
            }
            if (startFR.pack() == EMPTY_FUNCTION_REFERENCE) {
                break;
            }
        }
    }

    function _removeExecutionHooks(
        address plugin,
        ManifestExecutionHook[] memory executionHooks,
        WalletStorageV1Lib.Layout storage storageLayout
    ) internal {
        uint256 length = executionHooks.length;
        FunctionReference[] memory dependencies = new FunctionReference[](0);
        for (uint256 i = 0; i < length; ++i) {
            bytes4 selector = executionHooks[i].selector;
            FunctionReference memory preExecHook = _resolveManifestFunction(
                executionHooks[i].preExecHook,
                plugin,
                dependencies,
                ManifestAssociatedFunctionType.PRE_HOOK_ALWAYS_DENY,
                AssociatedFunctionType.HOOK
            );
            FunctionReference memory postExecHookToRemove = _resolveManifestFunction(
                executionHooks[i].postExecHook,
                plugin,
                dependencies,
                ManifestAssociatedFunctionType.NONE,
                AssociatedFunctionType.HOOK
            );
            _removeHookGroup(storageLayout.executionDetails[selector].executionHooks, preExecHook, postExecHookToRemove);
        }
    }
}

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

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

import "./UserOperation.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 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.
     */
    event SignatureAggregatorChanged(address indexed aggregator);

    /**
     * a custom revert error of handleOps, to identify the offending op.
     *  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.
     *   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.
     */
    error FailedOp(uint256 opIndex, string reason);

    /**
     * error case when a signature aggregator fails to verify the aggregated signature it had created.
     */
    error SignatureValidationFailed(address aggregator);

    /**
     * Successful result from simulateValidation.
     * @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)
     */
    error ValidationResult(ReturnInfo returnInfo,
        StakeInfo senderInfo, StakeInfo factoryInfo, StakeInfo paymasterInfo);

    /**
     * Successful result from simulateValidation, if the account returns a signature aggregator
     * @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
     */
    error ValidationResultWithAggregation(ReturnInfo returnInfo,
        StakeInfo senderInfo, StakeInfo factoryInfo, StakeInfo paymasterInfo,
        AggregatorStakeInfo aggregatorInfo);

    /**
     * return value of getSenderAddress
     */
    error SenderAddressResult(address sender);

    /**
     * return value of simulateHandleOp
     */
    error ExecutionResult(uint256 preOpGas, uint256 paid, uint48 validAfter, uint48 validUntil, bool targetSuccess, bytes targetResult);

    //UserOps handled, per aggregator
    struct UserOpsPerAggregator {
        UserOperation[] userOps;

        // aggregator address
        IAggregator aggregator;
        // aggregated signature
        bytes signature;
    }

    /**
     * Execute a batch of UserOperation.
     * 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(UserOperation[] 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.
     */
    function getUserOpHash(UserOperation calldata userOp) external view returns (bytes32);

    /**
     * Simulate a call to account.validateUserOp and paymaster.validatePaymasterUserOp.
     * @dev this method always revert. Successful result is ValidationResult error. other errors are failures.
     * @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.
     */
    function simulateValidation(UserOperation calldata userOp) external;

    /**
     * gas and return values during simulation
     * @param preOpGas the gas used for validation (including preValidationGas)
     * @param prefund the required prefund for this operation
     * @param sigFailed validateUserOp's (or paymaster's) signature check failed
     * @param validAfter - first timestamp this UserOp is valid (merging account and paymaster time-range)
     * @param validUntil - last timestamp this UserOp is valid (merging account and paymaster time-range)
     * @param paymasterContext returned by validatePaymasterUserOp (to be passed into postOp)
     */
    struct ReturnInfo {
        uint256 preOpGas;
        uint256 prefund;
        bool sigFailed;
        uint48 validAfter;
        uint48 validUntil;
        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;


    /**
     * simulate full execution of a UserOperation (including both validation and target execution)
     * this method will always revert with "ExecutionResult".
     * 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
     */
    function simulateHandleOp(UserOperation calldata op, address target, bytes calldata targetCallData) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)

pragma solidity ^0.8.0;

import "../Proxy.sol";
import "./ERC1967Upgrade.sol";

/**
 * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
 * implementation address that can be changed. This address is stored in storage in the location specified by
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
 * implementation behind the proxy.
 */
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
    /**
     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
     *
     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
     * function call, and allows initializing the storage of the proxy like a Solidity constructor.
     */
    constructor(address _logic, bytes memory _data) payable {
        _upgradeToAndCall(_logic, _data, false);
    }

    /**
     * @dev Returns the current implementation address.
     */
    function _implementation() internal view virtual override returns (address impl) {
        return ERC1967Upgrade._getImplementation();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Create2.sol)

pragma solidity ^0.8.0;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {
        require(address(this).balance >= amount, "Create2: insufficient balance");
        require(bytecode.length != 0, "Create2: bytecode length is zero");
        /// @solidity memory-safe-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        require(addr != address(0), "Create2: Failed on deploy");
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := keccak256(start, 85)
        }
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {IERC777Recipient} from "@openzeppelin/contracts/interfaces/IERC777Recipient.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";

/**
 * @dev Token callback handler. Allowing account receiving these tokens.
 * @notice The user will have to register itself in the ERC1820 global registry
 *         in order to fully support ERC777 token operations upon the installation of this plugin.
 */
contract DefaultCallbackHandler is IERC721Receiver, IERC1155Receiver, IERC777Recipient {
    function supportsInterface(bytes4 interfaceId) external view virtual override returns (bool) {
        return interfaceId == type(IERC721Receiver).interfaceId || interfaceId == type(IERC1155Receiver).interfaceId
            || interfaceId == type(IERC165).interfaceId;
    }

    function onERC1155Received(address, address, uint256, uint256, bytes calldata)
        external
        pure
        override
        returns (bytes4)
    {
        return IERC1155Receiver.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(address, address, uint256[] calldata, uint256[] calldata, bytes calldata)
        external
        pure
        override
        returns (bytes4)
    {
        return IERC1155Receiver.onERC1155BatchReceived.selector;
    }

    function onERC721Received(address, address, uint256, bytes calldata) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }

    // ERC777
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint256 amount,
        bytes calldata userData,
        bytes calldata operatorData
    ) external pure override {}
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

// ERC4337 constants

// return value in case of signature failure, with no time-range.
// equivalent to _packValidationData(true,0,0);
uint256 constant SIG_VALIDATION_FAILED = 1;
uint256 constant SIG_VALIDATION_SUCCEEDED = 0;

// sentinel values
// any values less than or equal to this will not be allowed in storage
bytes21 constant SENTINEL_BYTES21 = bytes21(0);
bytes23 constant SENTINEL_BYTES23 = bytes23(0);
bytes4 constant SENTINEL_BYTES4 = bytes4(0);
bytes32 constant SENTINEL_BYTES32 = bytes32(0);

// empty or unset function reference
// we don't store the empty function reference
bytes21 constant EMPTY_FUNCTION_REFERENCE = bytes21(0);

// wallet constants
string constant WALLET_AUTHOR = "Circle Internet Financial";
string constant WALLET_VERSION_1 = "1.0.0";

// plugin constants
string constant PLUGIN_AUTHOR = "Circle Internet Financial";
string constant PLUGIN_VERSION_1 = "1.0.0";

// bytes4(keccak256("isValidSignature(bytes32,bytes)")
bytes4 constant EIP1271_VALID_SIGNATURE = 0x1626ba7e;
bytes4 constant EIP1271_INVALID_SIGNATURE = 0xffffffff;

// keccak256('')
bytes32 constant EMPTY_HASH = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;

uint256 constant ZERO = 0;

bytes32 constant ZERO_BYTES32 = bytes32(0);
bytes24 constant EMPTY_MODULE_ENTITY = bytes24(0);

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

// solhint-disable no-inline-assembly

/**
 * Utility functions helpful when making different kinds of contract calls in Solidity.
 * For inline assembly, please refer to https://docs.soliditylang.org/en/latest/assembly.html
 * For opcodes, please refer to https://ethereum.org/en/developers/docs/evm/opcodes/ and https://www.evm.codes/
 */
library ExecutionUtils {
    function call(address to, uint256 value, bytes memory data)
        internal
        returns (bool success, bytes memory returnData)
    {
        assembly {
            success := call(gas(), to, value, add(data, 0x20), mload(data), 0, 0)
            let len := returndatasize()
            let ptr := mload(0x40)
            mstore(0x40, add(ptr, add(len, 0x20)))
            mstore(ptr, len)
            returndatacopy(add(ptr, 0x20), 0, len)
            returnData := ptr
        }
    }

    function revertWithData(bytes memory returnData) internal pure {
        assembly {
            revert(add(returnData, 32), mload(returnData))
        }
    }

    function callAndRevert(address to, uint256 value, bytes memory data) internal {
        (bool success, bytes memory returnData) = call(to, value, data);
        if (!success) {
            revertWithData(returnData);
        }
    }

    function callWithReturnDataOrRevert(address to, uint256 value, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returnData) = call(to, value, data);
        if (!success) {
            // bubble up revert reason
            revertWithData(returnData);
        }
        return returnData;
    }

    /// @dev Return data or revert.
    function delegateCall(address to, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returnData) = to.delegatecall(data);
        if (!success) {
            // bubble up revert reason
            revertWithData(returnData);
        }
        return returnData;
    }

    /// @dev Allocates memory for and retrieves return data from the previous external function call. The end of the
    /// allocated data may not be aligned to 32 bytes, which means the next free memory slot might fall somewhere
    /// between two 32-byte words. Therefore the memory address is aligned to the next 32-byte boundary to ensure
    /// efficient memory usage. The function also stores the size of the return data and copies the return data
    /// itself into the allocated memory.
    /// @return returnData the data returned by the last external function call.
    /// @notice The function ensures memory alignment by adding 63 (0x3f = 0x1f + 0x20) and clearing the last 5 bits,
    /// ensuring the memory is pushed to the nearest multiple of 32 bytes. This avoids unaligned memory access,
    /// which can lead to inefficiencies.
    function fetchReturnData() internal pure returns (bytes memory returnData) {
        assembly ("memory-safe") {
            // allocate memory for the return data starting at the free memory pointer
            returnData := mload(0x40)
            // update the free memory pointer after adding the size of the return data and ensuring it is aligned to the
            // next 32-byte boundary
            mstore(0x40, add(returnData, and(add(returndatasize(), 0x3f), not(0x1f))))
            // store the size of the return data at the start of the allocated memory
            mstore(returnData, returndatasize())
            // copy the return data to the allocated memory space
            returndatacopy(add(returnData, 0x20), 0, returndatasize())
        }
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

/**
 * @dev Returned data from validateUserOp.
 * validateUserOp returns a uint256, with is created by `_packedValidationData` and parsed by `_parseValidationData`
 * @param validAfter - this UserOp is valid only after this timestamp.
 * @param validaUntil - this UserOp is valid only up to this timestamp.
 * @param authorizer - 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.
 */
struct ValidationData {
    uint48 validAfter;
    uint48 validUntil;
    address authorizer;
}

struct AddressDLL {
    mapping(address => address) next;
    mapping(address => address) prev;
    uint256 count;
}

struct Bytes4DLL {
    mapping(bytes4 => bytes4) next;
    mapping(bytes4 => bytes4) prev;
    uint256 count;
}

struct Bytes32DLL {
    mapping(bytes32 => bytes32) next;
    mapping(bytes32 => bytes32) prev;
    uint256 count;
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {ValidationData} from "../common/Structs.sol";

library ValidationDataLib {
    error WrongTimeBounds();

    /**
     * @dev Intercept the time bounds [validAfter, validUntil], as well as signature validation result (favoring the
     * failure).
     */
    function _intersectValidationData(ValidationData memory a, uint256 uintb)
        internal
        pure
        returns (ValidationData memory validationData)
    {
        ValidationData memory b = _unpackValidationData(uintb);
        if (a.validAfter > a.validUntil) {
            revert WrongTimeBounds();
        }
        if (b.validAfter > b.validUntil) {
            revert WrongTimeBounds();
        }
        // 0 is successful validation
        if (a.authorizer == address(0)) {
            validationData.authorizer = b.authorizer;
        } else {
            validationData.authorizer = a.authorizer;
        }
        if (a.validAfter > b.validAfter) {
            validationData.validAfter = a.validAfter;
        } else {
            validationData.validAfter = b.validAfter;
        }
        if (a.validUntil < b.validUntil) {
            validationData.validUntil = a.validUntil;
        } else {
            validationData.validUntil = b.validUntil;
        }
        // make sure the caller (e.g. entryPoint) reverts
        if (validationData.validAfter >= validationData.validUntil) {
            validationData.authorizer = address(1);
        }
        return validationData;
    }

    /**
     * @dev Unpack into the deserialized packed format from validAfter | validUntil | authorizer.
     */
    function _unpackValidationData(uint256 validationDataInt)
        internal
        pure
        returns (ValidationData memory validationData)
    {
        address authorizer = address(uint160(validationDataInt));
        uint48 validUntil = uint48(validationDataInt >> 160);
        if (validUntil == 0) {
            validUntil = type(uint48).max;
        }
        uint48 validAfter = uint48(validationDataInt >> (48 + 160));
        return ValidationData(validAfter, validUntil, authorizer);
    }

    function _packValidationData(ValidationData memory data) internal pure returns (uint256) {
        return uint160(data.authorizer) | (uint256(data.validUntil) << 160) | (uint256(data.validAfter) << (160 + 48));
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

// magic value for runtime validation functions that always allow access
bytes21 constant RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE = bytes21(uint168(1));

// magic value for hooks that should always revert
bytes21 constant PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE = bytes21(uint168(2));

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

// Standard executor
struct Call {
    // The target address for the account to call.
    address target;
    // The value to send with the call.
    uint256 value;
    // The calldata for the call.
    bytes data;
}

struct FunctionReference {
    address plugin;
    uint8 functionId;
}

// Account loupe
// @notice Config for an execution function, given a selector
struct ExecutionFunctionConfig {
    address plugin;
    FunctionReference userOpValidationFunction;
    FunctionReference runtimeValidationFunction;
}

/// @notice Pre and post hooks for a given selector
/// @dev It's possible for one of either `preExecHook` or `postExecHook` to be empty
struct ExecutionHooks {
    FunctionReference preExecHook;
    FunctionReference postExecHook;
}

// internal data structure
struct Bytes21DLL {
    mapping(bytes21 => bytes21) next;
    mapping(bytes21 => bytes21) prev;
    uint256 count;
}

struct RepeatableBytes21DLL {
    mapping(bytes21 => bytes21) next;
    mapping(bytes21 => bytes21) prev;
    mapping(bytes21 => uint256) counter;
    // unique items
    uint256 uniqueItems;
    // total items with repeatable ones
    uint256 totalItems;
}

// Represents a set of pre and post hooks. Used to store execution hooks.
struct HookGroup {
    RepeatableBytes21DLL preHooks;
    // key = preExecHook.pack()
    mapping(bytes21 => RepeatableBytes21DLL) preToPostHooks;
    RepeatableBytes21DLL postOnlyHooks;
}

// plugin's permission to call external (to the account and its plugins) contracts and addresses
// through `executeFromPluginExternal`
struct PermittedExternalCall {
    bool addressPermitted;
    // either anySelector or selectors permitted
    bool anySelector;
    mapping(bytes4 => bool) selectors;
}

struct PostExecHookToRun {
    bytes preExecHookReturnData;
    FunctionReference postExecHook;
}

// plugin detail stored in wallet storage
struct PluginDetail {
    // permitted to call any external contracts and selectors
    bool anyExternalAddressPermitted;
    // boolean to indicate if the plugin can spend native tokens, if any of the execution function can spend
    // native tokens, a plugin is considered to be able to spend native tokens of the accounts
    bool canSpendNativeToken;
    // tracks the count this plugin has been used as a dependency function
    uint256 dependentCounter;
    bytes32 manifestHash;
    Bytes21DLL dependencies;
}

// execution detail associated with selector
struct ExecutionDetail {
    address plugin; // plugin address that implements the execution function, for native functions, the value should be
        // address(0)
    FunctionReference userOpValidationFunction;
    RepeatableBytes21DLL preUserOpValidationHooks;
    FunctionReference runtimeValidationFunction;
    RepeatableBytes21DLL preRuntimeValidationHooks;
    HookGroup executionHooks;
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import "../common/PluginManifest.sol";
import "../common/Structs.sol";
import {UserOperation} from "@account-abstraction/contracts/interfaces/UserOperation.sol";

/**
 * @dev Implements https://eips.ethereum.org/EIPS/eip-6900. Plugins must implement this interface to support plugin
 * management and interactions with MSCAs.
 */
interface IPlugin {
    /// @notice Initialize plugin data for the modular account.
    /// @dev Called by the modular account during `installPlugin`.
    /// @param data Optional bytes array to be decoded and used by the plugin to setup initial plugin data for the
    /// modular account.
    function onInstall(bytes calldata data) external;

    /// @notice Clear plugin data for the modular account.
    /// @dev Called by the modular account during `uninstallPlugin`.
    /// @param data Optional bytes array to be decoded and used by the plugin to clear plugin data for the modular
    /// account.
    function onUninstall(bytes calldata data) external;

    /// @notice Run the pre user operation validation hook specified by the `functionId`.
    /// @dev Pre user operation validation hooks MUST NOT return an authorizer value other than 0 or 1.
    /// @param functionId An identifier that routes the call to different internal implementations, should there be more
    /// than one.
    /// @param userOp The user operation.
    /// @param userOpHash The user operation hash.
    /// @return Packed validation data for validAfter (6 bytes), validUntil (6 bytes), and authorizer (20 bytes).
    function preUserOpValidationHook(uint8 functionId, UserOperation calldata userOp, bytes32 userOpHash)
        external
        returns (uint256);

    /// @notice Run the user operation validationFunction specified by the `functionId`.
    /// @param functionId An identifier that routes the call to different internal implementations, should there be
    /// more than one.
    /// @param userOp The user operation.
    /// @param userOpHash The user operation hash.
    /// @return Packed validation data for validAfter (6 bytes), validUntil (6 bytes), and authorizer (20 bytes).
    function userOpValidationFunction(uint8 functionId, UserOperation calldata userOp, bytes32 userOpHash)
        external
        returns (uint256);

    /// @notice Run the pre runtime validation hook specified by the `functionId`.
    /// @dev To indicate the entire call should revert, the function MUST revert.
    /// @param functionId An identifier that routes the call to different internal implementations, should there be more
    /// than one.
    /// @param sender The caller address.
    /// @param value The call value.
    /// @param data The calldata sent.
    function preRuntimeValidationHook(uint8 functionId, address sender, uint256 value, bytes calldata data) external;

    /// @notice Run the runtime validationFunction specified by the `functionId`.
    /// @dev To indicate the entire call should revert, the function MUST revert.
    /// @param functionId An identifier that routes the call to different internal implementations, should there be
    /// more than one.
    /// @param sender The caller address.
    /// @param value The call value.
    /// @param data The calldata sent.
    function runtimeValidationFunction(uint8 functionId, address sender, uint256 value, bytes calldata data) external;

    /// @notice Run the pre execution hook specified by the `functionId`.
    /// @dev To indicate the entire call should revert, the function MUST revert.
    /// @param functionId An identifier that routes the call to different internal implementations, should there be more
    /// than one.
    /// @param sender The caller address.
    /// @param value The call value.
    /// @param data The calldata sent.
    /// @return context Context to pass to a post execution hook, if present. An empty bytes array MAY be returned.
    function preExecutionHook(uint8 functionId, address sender, uint256 value, bytes calldata data)
        external
        returns (bytes memory context);

    /// @notice Run the post execution hook specified by the `functionId`.
    /// @dev To indicate the entire call should revert, the function MUST revert.
    /// @param functionId An identifier that routes the call to different internal implementations, should there be more
    /// than one.
    /// @param preExecHookData The context returned by its associated pre execution hook.
    function postExecutionHook(uint8 functionId, bytes calldata preExecHookData) external;

    /// @notice Describe the contents and intended configuration of the plugin.
    /// @dev This manifest MUST stay constant over time.
    /// @return A manifest describing the contents and intended configuration of the plugin.
    function pluginManifest() external pure returns (PluginManifest memory);

    /// @notice Describe the metadata of the plugin.
    /// @dev This metadata MUST stay constant over time.
    /// @return A metadata struct describing the plugin.
    function pluginMetadata() external pure returns (PluginMetadata memory);
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import "../common/Structs.sol";

library FunctionReferenceLib {
    function unpack(bytes21 frBytes) internal pure returns (FunctionReference memory) {
        return FunctionReference(address(bytes20(frBytes)), uint8(bytes1(frBytes << 160)));
    }

    function pack(FunctionReference memory functionReference) internal pure returns (bytes21) {
        return (bytes21(bytes20(functionReference.plugin)) | bytes21(uint168(functionReference.functionId)));
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {EMPTY_FUNCTION_REFERENCE, SENTINEL_BYTES21} from "../../../../common/Constants.sol";
import {InvalidFunctionReference, InvalidLimit, ItemDoesNotExist} from "../../shared/common/Errors.sol";
import "../common/Structs.sol";
import {FunctionReferenceLib} from "./FunctionReferenceLib.sol";

/**
 * @dev Enumerable & ordered doubly linked list built using RepeatableBytes21DLL.
 *      Item is expected to be have a counter that tracks repeated number.
 */
library RepeatableFunctionReferenceDLLLib {
    using FunctionReferenceLib for FunctionReference;
    using FunctionReferenceLib for bytes21;

    modifier validFunctionReference(FunctionReference memory fr) {
        if (fr.pack() <= SENTINEL_BYTES21) {
            revert InvalidFunctionReference();
        }
        _;
    }

    /**
     * @dev Check the counter of an item. O(1).
     * @return the counter
     */
    function getRepeatedCount(RepeatableBytes21DLL storage dll, FunctionReference memory fr)
        internal
        view
        returns (uint256)
    {
        bytes21 item = fr.pack();
        if (item == SENTINEL_BYTES21) {
            return 1;
        }
        return dll.counter[item];
    }

    /**
     * @dev Get the total items of dll. O(1).
     */
    function getTotalItems(RepeatableBytes21DLL storage dll) internal view returns (uint256) {
        return dll.totalItems;
    }

    /**
     * @dev Get the unique items of dll. O(1).
     */
    function getUniqueItems(RepeatableBytes21DLL storage dll) internal view returns (uint256) {
        return dll.uniqueItems;
    }

    /**
     * @dev Add an new item. O(1).
     */
    function append(RepeatableBytes21DLL storage dll, FunctionReference memory fr)
        internal
        validFunctionReference(fr)
        returns (uint256)
    {
        bytes21 item = fr.pack();
        uint256 currentCount = getRepeatedCount(dll, fr);
        if (currentCount == 0) {
            bytes21 prev = getTailWithoutUnpack(dll);
            bytes21 next = SENTINEL_BYTES21;
            // prev.next = item
            dll.next[prev] = item;
            // item.next = next
            dll.next[item] = next;
            // next.prev = item
            dll.prev[next] = item;
            // item.prev = prev
            dll.prev[item] = prev;
            dll.uniqueItems++;
        }
        dll.counter[item]++;
        dll.totalItems++;
        return dll.counter[item];
    }

    /**
     * @dev Remove or decrease the counter of already existing item. Otherwise the function reverts. O(1).
     */
    function remove(RepeatableBytes21DLL storage dll, FunctionReference memory fr)
        internal
        validFunctionReference(fr)
        returns (uint256)
    {
        uint256 currentCount = getRepeatedCount(dll, fr);
        if (currentCount == 0) {
            revert ItemDoesNotExist();
        }
        bytes21 item = fr.pack();
        if (currentCount == 1) {
            // delete the item
            // item.prev.next = item.next
            dll.next[dll.prev[item]] = dll.next[item];
            // item.next.prev = item.prev
            dll.prev[dll.next[item]] = dll.prev[item];
            delete dll.next[item];
            delete dll.prev[item];
            delete dll.counter[item];
            dll.uniqueItems--;
        } else {
            dll.counter[item]--;
        }
        dll.totalItems--;
        return dll.counter[item];
    }

    /**
     * @dev Remove all copies of already existing items. O(1).
     */
    function removeAllRepeated(RepeatableBytes21DLL storage dll, FunctionReference memory fr)
        internal
        validFunctionReference(fr)
        returns (bool)
    {
        uint256 currentCount = getRepeatedCount(dll, fr);
        if (currentCount == 0) {
            revert ItemDoesNotExist();
        }
        bytes21 item = fr.pack();
        // item.prev.next = item.next
        dll.next[dll.prev[item]] = dll.next[item];
        // item.next.prev = item.prev
        dll.prev[dll.next[item]] = dll.prev[item];
        delete dll.next[item];
        delete dll.prev[item];
        delete dll.counter[item];
        dll.uniqueItems--;
        dll.totalItems -= currentCount;
        return true;
    }

    /**
     * @dev Return paginated results and next pointer without counter information. O(n).
     *      In order to get counter information (which our current use case does not need), please call
     * getRepeatedCount.
     * @param startFR Starting item, inclusive, if start == bytes21(0), this method searches from the head.
     */
    function getPaginated(RepeatableBytes21DLL storage dll, FunctionReference memory startFR, uint256 limit)
        internal
        view
        returns (FunctionReference[] memory, FunctionReference memory)
    {
        if (limit == 0) {
            revert InvalidLimit();
        }
        bytes21 start = startFR.pack();
        FunctionReference[] memory results = new FunctionReference[](limit);
        bytes21 current = start;
        if (start == SENTINEL_BYTES21) {
            current = getHeadWithoutUnpack(dll);
        }
        uint256 count = 0;
        for (; count < limit && current > SENTINEL_BYTES21; ++count) {
            results[count] = current.unpack();
            current = dll.next[current];
        }
        assembly ("memory-safe") {
            mstore(results, count)
        }
        return (results, current.unpack());
    }

    /**
     * @dev Return all the unique items without counter information. O(n).
     *      In order to get counter information (which our current use case does not need), please call
     * getRepeatedCount.
     */
    function getAll(RepeatableBytes21DLL storage dll) internal view returns (FunctionReference[] memory results) {
        uint256 totalUniqueCount = getUniqueItems(dll);
        results = new FunctionReference[](totalUniqueCount);
        uint256 accumulatedCount = 0;
        FunctionReference memory startFR = EMPTY_FUNCTION_REFERENCE.unpack();
        for (uint256 i = 0; i < totalUniqueCount; ++i) {
            (FunctionReference[] memory currentResults, FunctionReference memory nextFR) =
                getPaginated(dll, startFR, 10);
            for (uint256 j = 0; j < currentResults.length; ++j) {
                results[accumulatedCount++] = currentResults[j];
            }
            if (nextFR.pack() == SENTINEL_BYTES21) {
                break;
            }
            startFR = nextFR;
        }
        return results;
    }

    function getHead(RepeatableBytes21DLL storage dll) internal view returns (FunctionReference memory) {
        return dll.next[SENTINEL_BYTES21].unpack();
    }

    function getTail(RepeatableBytes21DLL storage dll) internal view returns (FunctionReference memory) {
        return dll.prev[SENTINEL_BYTES21].unpack();
    }

    function getHeadWithoutUnpack(RepeatableBytes21DLL storage dll) private view returns (bytes21) {
        return dll.next[SENTINEL_BYTES21];
    }

    function getTailWithoutUnpack(RepeatableBytes21DLL storage dll) private view returns (bytes21) {
        return dll.prev[SENTINEL_BYTES21];
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {AddressDLL} from "../../shared/common/Structs.sol";
import "../common/Structs.sol";

/// @dev The same storage will be used for v1.x.y of MSCAs.
library WalletStorageV1Lib {
    // keccak256 hash of "circle.msca.v1.storage" subtracted by 1
    bytes32 internal constant WALLET_STORAGE_SLOT = 0xc6a0cc20c824c4eecc4b0fbb7fb297d07492a7bd12c83d4fa4d27b4249f9bfc8;

    struct Layout {
        // installed plugin addresses for quick query
        AddressDLL installedPlugins;
        // installed plugin details such as manifest, dependencies
        mapping(address => PluginDetail) pluginDetails;
        // permissions for executeFromPlugin into another plugin
        // callingPluginAddress => callingExecutionSelector => permittedOrNot
        mapping(address => mapping(bytes4 => bool)) permittedPluginCalls;
        // permissions for executeFromPluginExternal into external contract
        // callingPluginAddress => targetContractAddress => permission
        mapping(address => mapping(address => PermittedExternalCall)) permittedExternalCalls;
        // list of ERC-165 interfaceIds to add to account to support introspection checks
        // interfaceId => counter
        mapping(bytes4 => uint256) supportedInterfaces;
        // find plugin or native function execution detail by selector
        mapping(bytes4 => ExecutionDetail) executionDetails;
        /// indicates that the contract has been initialized
        uint8 initialized;
        /// indicates that the contract is in the process of being initialized
        bool initializing;
        // optional fields
        address owner;
    }

    /**
     * @dev Function to read structured wallet storage.
     */
    function getLayout() internal pure returns (Layout storage walletStorage) {
        assembly ("memory-safe") {
            walletStorage.slot := WALLET_STORAGE_SLOT
        }
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {
    EMPTY_FUNCTION_REFERENCE,
    SENTINEL_BYTES21,
    WALLET_AUTHOR,
    WALLET_VERSION_1
} from "../../../../common/Constants.sol";
import {ExecutionUtils} from "../../../../utils/ExecutionUtils.sol";
import {
    InvalidAuthorizer,
    InvalidExecutionFunction,
    InvalidValidationFunctionId,
    NotFoundSelector,
    UnauthorizedCaller
} from "../../shared/common/Errors.sol";
import {AddressDLL, ValidationData} from "../../shared/common/Structs.sol";
import {AddressDLLLib} from "../../shared/libs/AddressDLLLib.sol";
import {ValidationDataLib} from "../../shared/libs/ValidationDataLib.sol";
import {
    PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE,
    RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
} from "../common/Constants.sol";
import "../common/Structs.sol";
import {IAccountLoupe} from "../interfaces/IAccountLoupe.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {IPluginExecutor} from "../interfaces/IPluginExecutor.sol";
import {IPluginManager} from "../interfaces/IPluginManager.sol";
import {IStandardExecutor} from "../interfaces/IStandardExecutor.sol";
import {ExecutionHookLib} from "../libs/ExecutionHookLib.sol";
import {FunctionReferenceLib} from "../libs/FunctionReferenceLib.sol";
import {RepeatableFunctionReferenceDLLLib} from "../libs/RepeatableFunctionReferenceDLLLib.sol";

import {SelectorRegistryLib} from "../libs/SelectorRegistryLib.sol";
import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";
import {PluginExecutor} from "../managers/PluginExecutor.sol";
import {PluginManager} from "../managers/PluginManager.sol";
import {StandardExecutor} from "../managers/StandardExecutor.sol";

import {WalletStorageInitializable} from "./WalletStorageInitializable.sol";
import {IEntryPoint} from "@account-abstraction/contracts/interfaces/IEntryPoint.sol";
import {UserOperation} from "@account-abstraction/contracts/interfaces/UserOperation.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";

/**
 * @dev Base MSCA implementation with **authentication**.
 * This contract provides the basic logic for implementing the MSCA interfaces;
 * specific account implementation should inherit this contract.
 */
abstract contract BaseMSCA is
    WalletStorageInitializable,
    IPluginManager,
    IAccountLoupe,
    IStandardExecutor,
    IPluginExecutor,
    IERC165
{
    using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
    using FunctionReferenceLib for bytes21;
    using FunctionReferenceLib for FunctionReference;
    using ExecutionHookLib for HookGroup;
    using ExecutionHookLib for PostExecHookToRun[];
    using ExecutionUtils for address;
    using PluginExecutor for bytes;
    using StandardExecutor for address;
    using StandardExecutor for Call[];
    using AddressDLLLib for AddressDLL;
    using ValidationDataLib for ValidationData;
    using SelectorRegistryLib for bytes4;

    string public constant author = WALLET_AUTHOR;
    string public constant version = WALLET_VERSION_1;
    // 4337 related immutable storage
    IEntryPoint public immutable entryPoint;
    PluginManager public immutable pluginManager;

    error NotNativeFunctionSelector(bytes4 selector);
    error InvalidHookFunctionId(uint8 functionId);
    error PreRuntimeValidationHookFailed(address plugin, uint8 functionId, bytes revertReason);
    error RuntimeValidationFailed(address plugin, uint8 functionId, bytes revertReason);

    /**
     * @dev Wraps execution of a native function (as opposed to a function added by plugins) with runtime validations
     * (not from EP)
     *      and hooks. Used by execute, executeBatch, installPlugin, uninstallPlugin, upgradeTo and upgradeToAndCall.
     *      If the call is from entry point, then validateUserOp will run.
     *      https://eips.ethereum.org/assets/eip-6900/Modular_Account_Call_Flow.svg
     */
    modifier validateNativeFunction() {
        PostExecHookToRun[] memory postExecHooks = _processPreExecHooks();
        _;
        postExecHooks._processPostExecHooks();
    }

    /**
     * @dev This function allows entry point or SA itself to execute certain actions.
     * If the caller is not authorized, the function will revert with an error message.
     */
    modifier onlyFromEntryPointOrSelf() {
        _checkAccessRuleFromEPOrAcctItself();
        _;
    }

    constructor(IEntryPoint _newEntryPoint, PluginManager _newPluginManager) {
        entryPoint = _newEntryPoint;
        pluginManager = _newPluginManager;
        // lock the implementation contract so it can only be called from proxies
        _disableWalletStorageInitializers();
    }

    receive() external payable {}

    /// @notice Manage fallback calls made to the plugins.
    /// @dev Route calls to execution functions based on incoming msg.sig
    ///      If there's no plugin associated with this function selector, revert
    fallback(bytes calldata) external payable returns (bytes memory result) {
        // run runtime validation before we load the executionDetail because validation may update account state
        if (msg.sender != address(entryPoint)) {
            // entryPoint should go through validateUserOp flow which calls userOpValidationFunction
            _processPreRuntimeHooksAndValidation(msg.sig);
        }
        // load the executionDetail before we run the preExecHooks because they may modify the plugins
        ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[msg.sig];
        address executionFunctionPlugin = executionDetail.plugin;
        // valid plugin address should not be 0
        if (executionFunctionPlugin == address(0)) {
            revert InvalidExecutionFunction(msg.sig);
        }
        PostExecHookToRun[] memory postExecHooks = executionDetail.executionHooks._processPreExecHooks(msg.data);
        result = ExecutionUtils.callWithReturnDataOrRevert(executionFunctionPlugin, msg.value, msg.data);
        postExecHooks._processPostExecHooks();
        return result;
    }

    /**
     * @dev Return the entryPoint used by this account.
     * subclass should return the current entryPoint used by this account.
     */
    function getEntryPoint() external view returns (IEntryPoint) {
        return entryPoint;
    }

    /**
     * @dev 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
        returns (uint256 validationData)
    {
        if (msg.sender != address(entryPoint)) {
            revert UnauthorizedCaller();
        }
        validationData = _authenticateAndAuthorizeUserOp(userOp, userOpHash);
        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.)
        }
    }

    /// @notice ERC165 introspection https://eips.ethereum.org/EIPS/eip-165
    /// @dev returns true for `IERC165.interfaceId` and false for `0xFFFFFFFF`
    /// @param interfaceId interface id to check against
    /// @return bool support for specific interface
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        if (interfaceId == 0xffffffff) {
            return false;
        }
        if (interfaceId == type(IERC165).interfaceId) {
            return true;
        }
        return WalletStorageV1Lib.getLayout().supportedInterfaces[interfaceId] > 0;
    }

    /**
     * @dev Return the account nonce.
     * This method returns the next sequential nonce.
     * For a nonce of a specific key, use `entrypoint.getNonce(account, key)`
     */
    function getNonce() public view virtual returns (uint256) {
        return entryPoint.getNonce(address(this), 0);
    }

    function installPlugin(
        address plugin,
        bytes32 manifestHash,
        bytes memory pluginInstallData,
        FunctionReference[] memory dependencies
    ) external override validateNativeFunction {
        bytes memory data = abi.encodeCall(
            PluginManager.install, (plugin, manifestHash, pluginInstallData, dependencies, address(this))
        );
        address(pluginManager).delegateCall(data);
        emit PluginInstalled(plugin, manifestHash, dependencies);
    }

    function uninstallPlugin(address plugin, bytes memory config, bytes memory pluginUninstallData)
        external
        override
        validateNativeFunction
    {
        bytes memory data = abi.encodeCall(PluginManager.uninstall, (plugin, config, pluginUninstallData));
        address(pluginManager).delegateCall(data);
        emit PluginUninstalled(plugin, true);
    }

    function execute(address target, uint256 value, bytes calldata data)
        external
        payable
        override
        validateNativeFunction
        returns (bytes memory returnData)
    {
        return target.execute(value, data);
    }

    function executeBatch(Call[] calldata calls)
        external
        payable
        override
        validateNativeFunction
        returns (bytes[] memory returnData)
    {
        return calls.executeBatch();
    }

    function executeFromPlugin(bytes calldata data) external payable override returns (bytes memory) {
        return data.executeFromPlugin();
    }

    function executeFromPluginExternal(address target, uint256 value, bytes calldata data)
        external
        payable
        override
        returns (bytes memory)
    {
        return data.executeFromPluginToExternal(target, value);
    }

    /// @notice Gets the validation functions and plugin address for a selector
    /// @dev If the selector is a native function, the plugin address will be the address of the account
    /// @param selector The selector to get the configuration for
    /// @return executionFunctionConfig The configuration for this selector
    function getExecutionFunctionConfig(bytes4 selector)
        external
        view
        returns (ExecutionFunctionConfig memory executionFunctionConfig)
    {
        WalletStorageV1Lib.Layout storage walletStorage = WalletStorageV1Lib.getLayout();
        if (selector._isNativeFunctionSelector()) {
            executionFunctionConfig.plugin = address(this);
        } else {
            executionFunctionConfig.plugin = walletStorage.executionDetails[selector].plugin;
        }
        executionFunctionConfig.userOpValidationFunction =
            walletStorage.executionDetails[selector].userOpValidationFunction;
        executionFunctionConfig.runtimeValidationFunction =
            walletStorage.executionDetails[selector].runtimeValidationFunction;
        return executionFunctionConfig;
    }

    /// @notice Gets the pre and post execution hooks for a selector
    /// @param selector The selector to get the hooks for
    /// @return executionHooks The pre and post execution hooks for this selector
    function getExecutionHooks(bytes4 selector) external view returns (ExecutionHooks[] memory executionHooks) {
        return WalletStorageV1Lib.getLayout().executionDetails[selector].executionHooks._getExecutionHooks();
    }

    /// @notice Gets the pre user op and runtime validation hooks associated with a selector
    /// @param selector The selector to get the hooks for
    /// @return preUserOpValidationHooks The pre user op validation hooks for this selector
    /// @return preRuntimeValidationHooks The pre runtime validation hooks for this selector
    function getPreValidationHooks(bytes4 selector)
        external
        view
        returns (
            FunctionReference[] memory preUserOpValidationHooks,
            FunctionReference[] memory preRuntimeValidationHooks
        )
    {
        preUserOpValidationHooks =
            WalletStorageV1Lib.getLayout().executionDetails[selector].preUserOpValidationHooks.getAll();
        preRuntimeValidationHooks =
            WalletStorageV1Lib.getLayout().executionDetails[selector].preRuntimeValidationHooks.getAll();
        return (preUserOpValidationHooks, preRuntimeValidationHooks);
    }

    /// @notice Gets an array of all installed plugins
    /// @return pluginAddresses The addresses of all installed plugins
    function getInstalledPlugins() external view returns (address[] memory pluginAddresses) {
        return WalletStorageV1Lib.getLayout().installedPlugins.getAll();
    }

    /**
     * Check current account deposit in the entryPoint.
     */
    function getDeposit() public view returns (uint256) {
        return entryPoint.balanceOf(address(this));
    }

    /**
     * Deposit more funds for this account in the entryPoint.
     */
    function addDeposit() public payable {
        entryPoint.depositTo{value: msg.value}(address(this));
    }

    /**
     * Withdraw value from the account's deposit.
     * @param withdrawAddress target to send to
     * @param amount to withdraw
     */
    function withdrawDepositTo(address payable withdrawAddress, uint256 amount) public onlyFromEntryPointOrSelf {
        entryPoint.withdrawTo(withdrawAddress, amount);
    }

    /**
     * @dev Authenticate and authorize this userOp. OnlyFromEntryPoint is applied in the caller.
     * @param userOp validate the userOp.signature field
     * @param userOpHash convenient field: the hash of the request, to check the signature against
     *          (also hashes the entrypoint and chain id)
     * @return validationData signature and time-range of this operation
     *      <20-byte> sigAuthorizer - 0 for valid signature, 1 to mark signature failure,
     *         otherwise, an address of an "authorizer" contract.
     *      <6-byte> validUntil - last timestamp this operation is valid. 0 for "indefinite"
     *      <6-byte> validAfter - first timestamp this operation is valid
     *      If the account doesn't use time-range, it is enough to return SIG_VALIDATION_FAILED value (1) for signature
     * failure.
     *      Note that the validation code cannot use block.timestamp (or block.number) directly due to the storage rule.
     */
    function _authenticateAndAuthorizeUserOp(UserOperation calldata userOp, bytes32 userOpHash)
        internal
        virtual
        returns (uint256 validationData)
    {
        // onlyFromEntryPoint is applied in the caller
        // if there is no function defined for the selector, or if userOp.callData.length < 4, then execution MUST
        // revert
        if (userOp.callData.length < 4) {
            revert NotFoundSelector();
        }
        bytes4 selector = bytes4(userOp.callData[0:4]);
        if (selector == bytes4(0)) {
            revert NotFoundSelector();
        }
        ExecutionDetail storage executionDetail = WalletStorageV1Lib.getLayout().executionDetails[selector];
        FunctionReference memory validationFunction = executionDetail.userOpValidationFunction;
        bytes21 packedValidationFunction = validationFunction.pack();
        if (
            packedValidationFunction == EMPTY_FUNCTION_REFERENCE
                || packedValidationFunction == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
                || packedValidationFunction == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
        ) {
            revert InvalidValidationFunctionId(validationFunction.functionId);
        }
        // pre hook
        ValidationData memory unpackedValidationData =
            _processPreUserOpValidationHooks(executionDetail, userOp, userOpHash);
        IPlugin userOpValidatorPlugin = IPlugin(validationFunction.plugin);
        // execute the validation function with the user operation and its hash as parameters using the call opcode
        uint256 currentValidationData = userOpValidatorPlugin.userOpValidationFunction(
            executionDetail.userOpValidationFunction.functionId, userOp, userOpHash
        );
        // intercept with validation function call
        unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
        if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1)) {
            // only revert on unexpected values
            revert InvalidAuthorizer();
        }
        validationData = unpackedValidationData._packValidationData();
    }

    /**
     * @dev Default validation logic is from installed plugins. However, you can override this validation logic in MSCA
     *      implementations. For instance, semi MSCA such as single owner semi MSCA may want to honor the validation
     *      from native owner.
     */
    function _processPreRuntimeHooksAndValidation(bytes4 selector) internal virtual {
        FunctionReference memory validationFunction =
            WalletStorageV1Lib.getLayout().executionDetails[selector].runtimeValidationFunction;
        bytes21 packedValidationFunction = validationFunction.pack();
        if (
            packedValidationFunction == EMPTY_FUNCTION_REFERENCE
                || packedValidationFunction == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
        ) {
            revert InvalidValidationFunctionId(validationFunction.functionId);
        }
        RepeatableBytes21DLL storage preRuntimeValidationHooksDLL =
            WalletStorageV1Lib.getLayout().executionDetails[selector].preRuntimeValidationHooks;
        uint256 totalUniqueHookCount = preRuntimeValidationHooksDLL.getUniqueItems();
        FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        FunctionReference[] memory preRuntimeValidationHooks;
        FunctionReference memory nextHook;
        for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
            (preRuntimeValidationHooks, nextHook) = preRuntimeValidationHooksDLL.getPaginated(startHook, 10);
            for (uint256 j = 0; j < preRuntimeValidationHooks.length; ++j) {
                // revert on EMPTY_FUNCTION_REFERENCE, RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE,
                // PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
                // if any revert, the outer call MUST revert
                bytes21 packedPreRuntimeValidationHook = preRuntimeValidationHooks[j].pack();
                if (
                    packedPreRuntimeValidationHook == EMPTY_FUNCTION_REFERENCE
                        || packedPreRuntimeValidationHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
                        || packedPreRuntimeValidationHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
                ) {
                    revert InvalidValidationFunctionId(preRuntimeValidationHooks[j].functionId);
                }
                IPlugin preRuntimeValidationHookPlugin = IPlugin(preRuntimeValidationHooks[j].plugin);
                try preRuntimeValidationHookPlugin.preRuntimeValidationHook(
                    preRuntimeValidationHooks[j].functionId, msg.sender, msg.value, msg.data
                ) {} catch (bytes memory revertReason) {
                    revert PreRuntimeValidationHookFailed(
                        preRuntimeValidationHooks[j].plugin, preRuntimeValidationHooks[j].functionId, revertReason
                    );
                }
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        // call runtimeValidationFunction if it's not always allowed
        if (packedValidationFunction != RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE) {
            try IPlugin(validationFunction.plugin).runtimeValidationFunction(
                validationFunction.functionId, msg.sender, msg.value, msg.data
            ) {} catch (bytes memory revertReason) {
                revert RuntimeValidationFailed(validationFunction.plugin, validationFunction.functionId, revertReason);
            }
        }
    }

    /// @dev Also runs runtime hooks and validation if msg.sender is not from entry point.
    function _processPreExecHooks() internal returns (PostExecHookToRun[] memory) {
        if (!msg.sig._isNativeFunctionSelector()) {
            revert NotNativeFunctionSelector(msg.sig);
        }
        if (msg.sender != address(entryPoint)) {
            // entryPoint should go through validateUserOp flow which calls userOpValidationFunction
            _processPreRuntimeHooksAndValidation(msg.sig);
        }
        return WalletStorageV1Lib.getLayout().executionDetails[msg.sig].executionHooks._processPreExecHooks(msg.data);
    }

    function _processPreUserOpValidationHooks(
        ExecutionDetail storage executionDetail,
        UserOperation calldata userOp,
        bytes32 userOpHash
    ) internal virtual returns (ValidationData memory unpackedValidationData) {
        unpackedValidationData = ValidationData(0, 0xFFFFFFFFFFFF, address(0));
        // if the function selector has associated pre user operation validation hooks, then those hooks MUST be run
        // sequentially
        uint256 totalUniqueHookCount = executionDetail.preUserOpValidationHooks.getUniqueItems();
        FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        FunctionReference[] memory preUserOpValidatorHooks;
        FunctionReference memory nextHook;
        uint256 currentValidationData;
        for (uint256 i = 0; i < totalUniqueHookCount; ++i) {
            (preUserOpValidatorHooks, nextHook) = executionDetail.preUserOpValidationHooks.getPaginated(startHook, 10);
            for (uint256 j = 0; j < preUserOpValidatorHooks.length; ++j) {
                bytes21 packedUserOpValidatorHook = preUserOpValidatorHooks[j].pack();
                // if any revert, the outer call MUST revert
                if (
                    packedUserOpValidatorHook == EMPTY_FUNCTION_REFERENCE
                        || packedUserOpValidatorHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
                        || packedUserOpValidatorHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
                ) {
                    revert InvalidHookFunctionId(preUserOpValidatorHooks[j].functionId);
                }
                IPlugin preUserOpValidationHookPlugin = IPlugin(preUserOpValidatorHooks[j].plugin);
                currentValidationData = preUserOpValidationHookPlugin.preUserOpValidationHook(
                    preUserOpValidatorHooks[j].functionId, userOp, userOpHash
                );
                unpackedValidationData = unpackedValidationData._intersectValidationData(currentValidationData);
                // if any return an authorizer value other than 0 or 1, execution MUST revert
                if (unpackedValidationData.authorizer != address(0) && unpackedValidationData.authorizer != address(1))
                {
                    revert InvalidAuthorizer();
                }
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        return unpackedValidationData;
    }

    function _checkAccessRuleFromEPOrAcctItself() internal view {
        if (msg.sender != address(entryPoint) && msg.sender != address(this)) {
            revert UnauthorizedCaller();
        }
    }
}

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

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

import {calldataKeccak} from "../core/Helpers.sol";

/**
 * 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 callGasLimit the gas limit passed to the callData method call.
     * @param verificationGasLimit gas used for validateUserOp and validatePaymasterUserOp.
     * @param preVerificationGas gas not calculated by the handleOps method, but added to the gas paid. Covers batch overhead.
     * @param maxFeePerGas same as EIP-1559 gas parameter.
     * @param maxPriorityFeePerGas same as EIP-1559 gas parameter.
     * @param paymasterAndData if set, this field holds the paymaster address and paymaster-specific 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 UserOperation {

        address sender;
        uint256 nonce;
        bytes initCode;
        bytes callData;
        uint256 callGasLimit;
        uint256 verificationGasLimit;
        uint256 preVerificationGas;
        uint256 maxFeePerGas;
        uint256 maxPriorityFeePerGas;
        bytes paymasterAndData;
        bytes signature;
    }

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

    function getSender(UserOperation 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.
    function gasPrice(UserOperation calldata userOp) internal view returns (uint256) {
    unchecked {
        uint256 maxFeePerGas = userOp.maxFeePerGas;
        uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
        if (maxFeePerGas == maxPriorityFeePerGas) {
            //legacy mode (for networks that don't support basefee opcode)
            return maxFeePerGas;
        }
        return min(maxFeePerGas, maxPriorityFeePerGas + block.basefee);
    }
    }

    function pack(UserOperation 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);
        uint256 callGasLimit = userOp.callGasLimit;
        uint256 verificationGasLimit = userOp.verificationGasLimit;
        uint256 preVerificationGas = userOp.preVerificationGas;
        uint256 maxFeePerGas = userOp.maxFeePerGas;
        uint256 maxPriorityFeePerGas = userOp.maxPriorityFeePerGas;
        bytes32 hashPaymasterAndData = calldataKeccak(userOp.paymasterAndData);

        return abi.encode(
            sender, nonce,
            hashInitCode, hashCallData,
            callGasLimit, verificationGasLimit, preVerificationGas,
            maxFeePerGas, maxPriorityFeePerGas,
            hashPaymasterAndData
        );
    }

    function hash(UserOperation calldata userOp) internal pure returns (bytes32) {
        return keccak256(pack(userOp));
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.0;

import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
import {Initializable} from "./Initializable.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 *
 * _Available since v4.1._
 */
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
    address private immutable __self = address(this);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        require(address(this) != __self, "Function must be called through delegatecall");
        require(_getImplementation() == __self, "Function must be called through active proxy");
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
        _;
    }

    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
        return _IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeTo(address newImplementation) public virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data, true);
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeTo} and {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal override onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {MessageHashUtils} from "../libs/MessageHashUtils.sol";

abstract contract BaseERC712CompliantAccount {
    // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
    bytes32 private constant _DOMAIN_SEPARATOR_TYPEHASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /// @notice Wraps a replay safe hash in an EIP-712 envelope to prevent cross-account replay attacks.
    /// domainSeparator = hashStruct(eip712Domain).
    /// eip712Domain = (string name,string version,uint256 chainId,address verifyingContract)
    /// hashStruct(s) = keccak256(typeHash ‖ encodeData(s)) where typeHash = keccak256(encodeType(typeOf(s)))
    /// @param hash Message that should be hashed.
    /// @return Replay safe message hash.
    function getReplaySafeMessageHash(bytes32 hash) public view returns (bytes32) {
        return MessageHashUtils.toTypedDataHash({
            domainSeparator: keccak256(
                abi.encode(
                    _DOMAIN_SEPARATOR_TYPEHASH, _getAccountName(), _getAccountVersion(), block.chainid, address(this)
                )
            ),
            structHash: keccak256(abi.encode(_getAccountTypeHash(), hash))
        });
    }

    /// @dev Returns the account message typehash.
    function _getAccountTypeHash() internal pure virtual returns (bytes32);

    /// @dev Returns the account name.
    function _getAccountName() internal pure virtual returns (bytes32);

    /// @dev Returns the account version.
    function _getAccountVersion() internal pure virtual returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";
import "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Gnosis Safe.
 *
 * _Available since v4.1._
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
        return
            (error == ECDSA.RecoverError.NoError && recovered == signer) ||
            isValidERC1271SignatureNow(signer, hash, signature);
    }

    /**
     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
     * against the signer smart contract using ERC1271.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidERC1271SignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
        );
        return (success &&
            result.length >= 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {InvalidLimit, ItemAlreadyExists, ItemDoesNotExist} from "../common/Errors.sol";
import {AddressDLL} from "../common/Structs.sol";

/**
 * @dev Enumerable & ordered doubly linked list built using mapping(address => address).
 *      Item is expected to be unique.
 */
library AddressDLLLib {
    address internal constant SENTINEL_ADDRESS = address(0x0);
    uint160 internal constant SENTINEL_ADDRESS_UINT = 0;

    event AddressAdded(address indexed addr);
    event AddressRemoved(address indexed addr);

    error InvalidAddress();

    modifier validAddress(address addr) {
        if (uint160(addr) <= SENTINEL_ADDRESS_UINT) {
            revert InvalidAddress();
        }
        _;
    }

    /**
     * @dev Check if an item exists or not. O(1).
     */
    function contains(AddressDLL storage dll, address item) internal view returns (bool) {
        return getHead(dll) == item || dll.next[item] != address(0) || dll.prev[item] != address(0);
    }

    /**
     * @dev Get the count of dll. O(1).
     */
    function size(AddressDLL storage dll) internal view returns (uint256) {
        return dll.count;
    }

    /**
     * @dev Add an new item which did not exist before. Otherwise the function reverts. O(1).
     */
    function append(AddressDLL storage dll, address item) internal validAddress(item) returns (bool) {
        if (contains(dll, item)) {
            revert ItemAlreadyExists();
        }
        address prev = getTail(dll);
        address next = SENTINEL_ADDRESS;
        // prev.next = item
        dll.next[prev] = item;
        // item.next = next
        dll.next[item] = next;
        // next.prev = item
        dll.prev[next] = item;
        // item.prev = prev
        dll.prev[item] = prev;
        dll.count++;
        emit AddressAdded(item);
        return true;
    }

    /**
     * @dev Remove an already existing item. Otherwise the function reverts. O(1).
     */
    function remove(AddressDLL storage dll, address item) internal validAddress(item) returns (bool) {
        if (!contains(dll, item)) {
            revert ItemDoesNotExist();
        }
        // item.prev.next = item.next
        dll.next[dll.prev[item]] = dll.next[item];
        // item.next.prev = item.prev
        dll.prev[dll.next[item]] = dll.prev[item];
        delete dll.next[item];
        delete dll.prev[item];
        dll.count--;
        emit AddressRemoved(item);
        return true;
    }

    /**
     * @dev Return paginated addresses and next pointer address. O(n).
     * @param start Starting address, inclusive, if start == address(0x0), this method searches from the head.
     */
    function getPaginated(AddressDLL storage dll, address start, uint256 limit)
        internal
        view
        returns (address[] memory, address)
    {
        if (limit == 0) {
            revert InvalidLimit();
        }
        address[] memory results = new address[](limit);
        address current = start;
        if (start == address(0)) {
            current = getHead(dll);
        }
        uint256 count = 0;
        for (; count < limit && uint160(current) > SENTINEL_ADDRESS_UINT; ++count) {
            results[count] = current;
            current = dll.next[current];
        }
        assembly ("memory-safe") {
            mstore(results, count)
        }
        return (results, current);
    }

    /**
     * @dev Return all the data. O(n).
     */
    function getAll(AddressDLL storage dll) internal view returns (address[] memory results) {
        uint256 totalCount = size(dll);
        results = new address[](totalCount);
        uint256 accumulatedCount = 0;
        address startAddr = address(0x0);
        for (uint256 i = 0; i < totalCount; ++i) {
            (address[] memory currentResults, address nextAddr) = getPaginated(dll, startAddr, 10);
            for (uint256 j = 0; j < currentResults.length; ++j) {
                results[accumulatedCount++] = currentResults[j];
            }
            if (nextAddr == SENTINEL_ADDRESS) {
                break;
            }
            startAddr = nextAddr;
        }
        return results;
    }

    function getHead(AddressDLL storage dll) internal view returns (address) {
        return dll.next[SENTINEL_ADDRESS];
    }

    function getTail(AddressDLL storage dll) internal view returns (address) {
        return dll.prev[SENTINEL_ADDRESS];
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

// Plugin Manifest
enum ManifestAssociatedFunctionType {
    // Function is not defined.
    NONE,
    // Function belongs to this plugin.
    SELF,
    // Function belongs to an external plugin provided as a dependency during plugin installation.
    DEPENDENCY,
    // Resolves to a magic value to always bypass runtime validation for a given function.
    // This is only assignable on runtime validation functions. If it were to be used on a user op validation function,
    // it would risk burning gas from the account. When used as a hook in any hook location, it is equivalent to not
    // setting a hook and is therefore disallowed.
    RUNTIME_VALIDATION_ALWAYS_ALLOW,
    // Resolves to a magic value to always fail in a hook for a given function.
    // This is only assignable to pre hooks (pre validation and pre execution). It should not be used on
    // validation functions themselves, because this is equivalent to leaving the validation functions unset.
    // It should not be used in post-exec hooks, because if it is known to always revert, that should happen
    // as early as possible to save gas.
    PRE_HOOK_ALWAYS_DENY
}

/// @dev For functions of type `ManifestAssociatedFunctionType.DEPENDENCY`, the MSCA MUST find the plugin address
/// of the function at `dependencies[dependencyIndex]` during the call to `installPlugin(config)`.
struct ManifestFunction {
    ManifestAssociatedFunctionType functionType;
    uint8 functionId;
    uint256 dependencyIndex;
}

struct ManifestAssociatedFunction {
    bytes4 executionSelector;
    ManifestFunction associatedFunction;
}

struct ManifestExecutionHook {
    bytes4 selector;
    ManifestFunction preExecHook;
    ManifestFunction postExecHook;
}

struct ManifestExternalCallPermission {
    address externalAddress;
    bool permitAnySelector;
    bytes4[] selectors;
}

struct SelectorPermission {
    bytes4 functionSelector;
    string permissionDescription;
}

/// @dev A struct holding fields to describe the plugin in a purely view context. Intended for front end clients.
struct PluginMetadata {
    // A human-readable name of the plugin.
    string name;
    // The version of the plugin, following the semantic versioning scheme.
    string version;
    // The author field SHOULD be a username representing the identity of the user or organization
    // that created this plugin.
    string author;
    // String descriptions of the relative sensitivity of specific functions. The selectors MUST be selectors for
    // functions implemented by this plugin.
    SelectorPermission[] permissionDescriptors;
}

/// @dev A struct describing how the plugin should be installed on a modular account.
struct PluginManifest {
    // List of ERC-165 interface IDs to add to account to support introspection checks. This MUST NOT include
    // IPlugin's interface ID.
    bytes4[] interfaceIds;
    // If this plugin depends on other plugins' validation functions, the interface IDs of those plugins MUST be
    // provided here, with its position in the array matching the `dependencyIndex` members of `ManifestFunction`
    bytes4[] dependencyInterfaceIds;
    // Execution functions defined in this plugin to be installed on the MSCA.
    bytes4[] executionFunctions;
    // Plugin execution functions already installed on the MSCA that this plugin will be able to call.
    bytes4[] permittedExecutionSelectors;
    // Boolean to indicate whether the plugin can call any external address.
    bool permitAnyExternalAddress;
    // Boolean to indicate whether the plugin needs access to spend native tokens of the account. If false, the
    // plugin MUST still be able to spend up to the balance that it sends to the account in the same call.
    bool canSpendNativeToken;
    // More granular control
    ManifestExternalCallPermission[] permittedExternalCalls;
    ManifestAssociatedFunction[] userOpValidationFunctions;
    ManifestAssociatedFunction[] runtimeValidationFunctions;
    ManifestAssociatedFunction[] preUserOpValidationHooks;
    ManifestAssociatedFunction[] preRuntimeValidationHooks;
    // for executionFunctions
    ManifestExecutionHook[] executionHooks;
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {EMPTY_FUNCTION_REFERENCE, SENTINEL_BYTES21} from "../../../../common/Constants.sol";
import {
    InvalidFunctionReference, InvalidLimit, ItemAlreadyExists, ItemDoesNotExist
} from "../../shared/common/Errors.sol";
import "../common/Structs.sol";
import {FunctionReferenceLib} from "./FunctionReferenceLib.sol";

/**
 * @dev Enumerable & ordered doubly linked list built using mapping(bytes21 => bytes21) for function reference.
 *      Item is expected to be unique.
 */
library FunctionReferenceDLLLib {
    using FunctionReferenceLib for FunctionReference;
    using FunctionReferenceLib for bytes21;

    modifier validFunctionReference(FunctionReference memory fr) {
        if (fr.pack() <= SENTINEL_BYTES21) {
            revert InvalidFunctionReference();
        }
        _;
    }

    /**
     * @dev Check if an item exists or not. O(1).
     */
    function contains(Bytes21DLL storage dll, FunctionReference memory fr) internal view returns (bool) {
        return contains(dll, fr.pack());
    }

    function contains(Bytes21DLL storage dll, bytes21 item) internal view returns (bool) {
        return getHeadWithoutUnpack(dll) == item || dll.next[item] != SENTINEL_BYTES21
            || dll.prev[item] != SENTINEL_BYTES21;
    }

    /**
     * @dev Get the count of dll. O(1).
     */
    function size(Bytes21DLL storage dll) internal view returns (uint256) {
        return dll.count;
    }

    /**
     * @dev Add an new item which did not exist before. Otherwise the function reverts. O(1).
     */
    function append(Bytes21DLL storage dll, FunctionReference memory fr)
        internal
        validFunctionReference(fr)
        returns (bool)
    {
        bytes21 item = fr.pack();
        if (contains(dll, item)) {
            revert ItemAlreadyExists();
        }
        bytes21 prev = getTailWithoutUnpack(dll);
        bytes21 next = SENTINEL_BYTES21;
        // prev.next = item
        dll.next[prev] = item;
        // item.next = next
        dll.next[item] = next;
        // next.prev = item
        dll.prev[next] = item;
        // item.prev = prev
        dll.prev[item] = prev;
        dll.count++;
        return true;
    }

    /**
     * @dev Remove an already existing item. Otherwise the function reverts. O(1).
     */
    function remove(Bytes21DLL storage dll, FunctionReference memory fr)
        internal
        validFunctionReference(fr)
        returns (bool)
    {
        bytes21 item = fr.pack();
        if (!contains(dll, item)) {
            revert ItemDoesNotExist();
        }
        // item.prev.next = item.next
        dll.next[dll.prev[item]] = dll.next[item];
        // item.next.prev = item.prev
        dll.prev[dll.next[item]] = dll.prev[item];
        delete dll.next[item];
        delete dll.prev[item];
        dll.count--;
        return true;
    }

    /**
     * @dev Return paginated bytes21s and next pointer bytes21. O(n).
     * @param startFR Starting bytes21, inclusive, if start == bytes21(0), this method searches from the head.
     */
    function getPaginated(Bytes21DLL storage dll, FunctionReference memory startFR, uint256 limit)
        internal
        view
        returns (FunctionReference[] memory, FunctionReference memory)
    {
        if (limit == 0) {
            revert InvalidLimit();
        }
        bytes21 start = startFR.pack();
        FunctionReference[] memory results = new FunctionReference[](limit);
        bytes21 current = start;
        if (start == SENTINEL_BYTES21) {
            current = getHeadWithoutUnpack(dll);
        }
        uint256 count = 0;
        for (; count < limit && current > SENTINEL_BYTES21; ++count) {
            results[count] = current.unpack();
            current = dll.next[current];
        }
        assembly ("memory-safe") {
            mstore(results, count)
        }
        return (results, current.unpack());
    }

    /**
     * @dev Return all the data. O(n).
     */
    function getAll(Bytes21DLL storage dll) internal view returns (FunctionReference[] memory results) {
        uint256 totalCount = size(dll);
        results = new FunctionReference[](totalCount);
        uint256 accumulatedCount = 0;
        FunctionReference memory startFR = EMPTY_FUNCTION_REFERENCE.unpack();
        for (uint256 i = 0; i < totalCount; ++i) {
            (FunctionReference[] memory currentResults, FunctionReference memory nextFR) =
                getPaginated(dll, startFR, 10);
            for (uint256 j = 0; j < currentResults.length; ++j) {
                results[accumulatedCount++] = currentResults[j];
            }
            if (nextFR.pack() == SENTINEL_BYTES21) {
                break;
            }
            startFR = nextFR;
        }
        return results;
    }

    function getHead(Bytes21DLL storage dll) internal view returns (FunctionReference memory) {
        return dll.next[SENTINEL_BYTES21].unpack();
    }

    function getTail(Bytes21DLL storage dll) internal view returns (FunctionReference memory) {
        return dll.prev[SENTINEL_BYTES21].unpack();
    }

    function getHeadWithoutUnpack(Bytes21DLL storage dll) private view returns (bytes21) {
        return dll.next[SENTINEL_BYTES21];
    }

    function getTailWithoutUnpack(Bytes21DLL storage dll) private view returns (bytes21) {
        return dll.prev[SENTINEL_BYTES21];
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {IAccountLoupe} from "../interfaces/IAccountLoupe.sol";

import {IPlugin} from "../interfaces/IPlugin.sol";
import {IPluginExecutor} from "../interfaces/IPluginExecutor.sol";
import {IPluginManager} from "../interfaces/IPluginManager.sol";
import {IStandardExecutor} from "../interfaces/IStandardExecutor.sol";
import {IAggregator} from "@account-abstraction/contracts/interfaces/IAggregator.sol";
import {IPaymaster} from "@account-abstraction/contracts/interfaces/IPaymaster.sol";
import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";

library SelectorRegistryLib {
    bytes4 internal constant INITIALIZE_UPGRADABLE_MSCA =
        bytes4(keccak256("initializeUpgradableMSCA(address[],bytes32[],bytes[])"));
    bytes4 internal constant INITIALIZE_SINGLE_OWNER_MSCA = bytes4(keccak256("initializeSingleOwnerMSCA(address)"));
    bytes4 internal constant TRANSFER_NATIVE_OWNERSHIP = bytes4(keccak256("transferNativeOwnership(address)"));
    bytes4 internal constant RENOUNCE_NATIVE_OWNERSHIP = bytes4(keccak256("renounceNativeOwnership()"));
    bytes4 internal constant GET_NATIVE_OWNER = bytes4(keccak256("getNativeOwner()"));
    bytes4 internal constant VALIDATE_USER_OP = bytes4(keccak256("validateUserOp(UserOperation,bytes32,uint256)"));
    bytes4 internal constant GET_ENTRYPOINT = bytes4(keccak256("getEntryPoint()"));
    bytes4 internal constant GET_NONCE = bytes4(keccak256("getNonce()"));

    /**
     * @dev Check if the selector is for native function.
     * @param selector the function selector.
     */
    function _isNativeFunctionSelector(bytes4 selector) internal pure returns (bool) {
        return selector == IStandardExecutor.execute.selector || selector == IStandardExecutor.executeBatch.selector
            || selector == IPluginManager.installPlugin.selector || selector == IPluginManager.uninstallPlugin.selector
            || selector == UUPSUpgradeable.upgradeTo.selector || selector == UUPSUpgradeable.upgradeToAndCall.selector
            || selector == UUPSUpgradeable.proxiableUUID.selector
        // check against IERC165 methods
        || selector == IERC165.supportsInterface.selector
        // check against IPluginExecutor methods
        || selector == IPluginExecutor.executeFromPlugin.selector
            || selector == IPluginExecutor.executeFromPluginExternal.selector
        // check against IAccountLoupe methods
        || selector == IAccountLoupe.getExecutionFunctionConfig.selector
            || selector == IAccountLoupe.getExecutionHooks.selector
            || selector == IAccountLoupe.getPreValidationHooks.selector
            || selector == IAccountLoupe.getInstalledPlugins.selector || selector == VALIDATE_USER_OP
            || selector == GET_ENTRYPOINT || selector == GET_NONCE || selector == INITIALIZE_UPGRADABLE_MSCA
            || selector == INITIALIZE_SINGLE_OWNER_MSCA || selector == TRANSFER_NATIVE_OWNERSHIP
            || selector == RENOUNCE_NATIVE_OWNERSHIP || selector == GET_NATIVE_OWNER;
    }

    function _isErc4337FunctionSelector(bytes4 selector) internal pure returns (bool) {
        return selector == IAggregator.validateSignatures.selector
            || selector == IAggregator.validateUserOpSignature.selector
            || selector == IAggregator.aggregateSignatures.selector
            || selector == IPaymaster.validatePaymasterUserOp.selector || selector == IPaymaster.postOp.selector;
    }

    function _isIPluginFunctionSelector(bytes4 selector) internal pure returns (bool) {
        return selector == IPlugin.onInstall.selector || selector == IPlugin.onUninstall.selector
            || selector == IPlugin.preUserOpValidationHook.selector || selector == IPlugin.userOpValidationFunction.selector
            || selector == IPlugin.preRuntimeValidationHook.selector
            || selector == IPlugin.runtimeValidationFunction.selector || selector == IPlugin.preExecutionHook.selector
            || selector == IPlugin.postExecutionHook.selector || selector == IPlugin.pluginManifest.selector
            || selector == IPlugin.pluginMetadata.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/introspection/ERC165Checker.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Library used to query support of an interface declared via {IERC165}.
 *
 * Note that these functions return the actual result of the query: they do not
 * `revert` if an interface is not supported. It is up to the caller to decide
 * what to do in these cases.
 */
library ERC165Checker {
    // As per the EIP-165 spec, no interface should ever match 0xffffffff
    bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;

    /**
     * @dev Returns true if `account` supports the {IERC165} interface.
     */
    function supportsERC165(address account) internal view returns (bool) {
        // Any contract that implements ERC165 must explicitly indicate support of
        // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
        return
            supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
            !supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
    }

    /**
     * @dev Returns true if `account` supports the interface defined by
     * `interfaceId`. Support for {IERC165} itself is queried automatically.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
        // query support of both ERC165 as per the spec and support of _interfaceId
        return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
    }

    /**
     * @dev Returns a boolean array where each value corresponds to the
     * interfaces passed in and whether they're supported or not. This allows
     * you to batch check interfaces for a contract where your expectation
     * is that some interfaces may not be supported.
     *
     * See {IERC165-supportsInterface}.
     *
     * _Available since v3.4._
     */
    function getSupportedInterfaces(
        address account,
        bytes4[] memory interfaceIds
    ) internal view returns (bool[] memory) {
        // an array of booleans corresponding to interfaceIds and whether they're supported or not
        bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);

        // query support of ERC165 itself
        if (supportsERC165(account)) {
            // query support of each interface in interfaceIds
            for (uint256 i = 0; i < interfaceIds.length; i++) {
                interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
            }
        }

        return interfaceIdsSupported;
    }

    /**
     * @dev Returns true if `account` supports all the interfaces defined in
     * `interfaceIds`. Support for {IERC165} itself is queried automatically.
     *
     * Batch-querying can lead to gas savings by skipping repeated checks for
     * {IERC165} support.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
        // query support of ERC165 itself
        if (!supportsERC165(account)) {
            return false;
        }

        // query support of each interface in interfaceIds
        for (uint256 i = 0; i < interfaceIds.length; i++) {
            if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
                return false;
            }
        }

        // all interfaces supported
        return true;
    }

    /**
     * @notice Query if a contract implements an interface, does not check ERC165 support
     * @param account The address of the contract to query for support of an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @return true if the contract at account indicates support of the interface with
     * identifier interfaceId, false otherwise
     * @dev Assumes that account contains a contract that supports ERC165, otherwise
     * the behavior of this method is undefined. This precondition can be checked
     * with {supportsERC165}.
     *
     * Some precompiled contracts will falsely indicate support for a given interface, so caution
     * should be exercised when using this function.
     *
     * Interface identification is specified in ERC-165.
     */
    function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
        // prepare call
        bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);

        // perform static call
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly {
            success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0x00)
        }

        return success && returnSize >= 0x20 && returnValue > 0;
    }
}

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

/**
 * 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,staked, stake) fit into one cell (used during handleOps)
     *    and the rest fit into a 2nd cell.
     *    112 bit allows for 10^15 eth
     *    48 bit for full timestamp
     *    32 bit allows 150 years for unstake delay
     */
    struct DepositInfo {
        uint112 deposit;
        bool staked;
        uint112 stake;
        uint32 unstakeDelaySec;
        uint48 withdrawTime;
    }

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

    /// @return info - full deposit information of given account
    function getDepositInfo(address account) external view returns (DepositInfo memory info);

    /// @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
     */
    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.8.12;

import "./UserOperation.sol";

/**
 * Aggregated Signatures validator.
 */
interface IAggregator {

    /**
     * validate aggregated signature.
     * revert if the aggregated signature does not match the given list of operations.
     */
    function validateSignatures(UserOperation[] calldata userOps, bytes calldata signature) external view;

    /**
     * validate signature of a single userOp
     * This method is should be called by bundler after EntryPoint.simulateValidation() returns (reverts) with ValidationResultWithAggregation
     * 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(UserOperation 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(UserOperation[] calldata userOps) external view returns (bytes memory aggregatedSignature);
}

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

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 v4.6.0) (proxy/Proxy.sol)

pragma solidity ^0.8.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }

    /**
     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
     * and {_fallback} should delegate.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates the current call to the address returned by `_implementation()`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback() external payable virtual {
        _fallback();
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
     * is empty.
     */
    receive() external payable virtual {
        _fallback();
    }

    /**
     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
     * call, or as part of the Solidity `fallback` or `receive` functions.
     *
     * If overridden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeacon.sol";
import "../../interfaces/IERC1967.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 */
abstract contract ERC1967Upgrade is IERC1967 {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC777Recipient.sol)

pragma solidity ^0.8.0;

import "../token/ERC777/IERC777Recipient.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @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);
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import "../common/Structs.sol";

/**
 * @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs may implement this interface to support visibility in
 * plugin configurations on-chain.
 */
interface IAccountLoupe {
    /// @notice Get the validation functions and plugin address for a selector.
    /// @dev If the selector is a native function, the plugin address will be the address of the account.
    /// @param selector The selector to get the configuration for.
    /// @return The configuration for this selector.
    function getExecutionFunctionConfig(bytes4 selector) external view returns (ExecutionFunctionConfig memory);

    /// @notice Get the pre and post execution hooks for a selector.
    /// @param selector The selector to get the hooks for.
    /// @return The pre and post execution hooks for this selector.
    function getExecutionHooks(bytes4 selector) external view returns (ExecutionHooks[] memory);

    /// @notice Get the pre user op and runtime validation hooks associated with a selector.
    /// @param selector The selector to get the hooks for.
    /// @return preUserOpValidationHooks The pre user op validation hooks for this selector.
    /// @return preRuntimeValidationHooks The pre runtime validation hooks for this selector.
    function getPreValidationHooks(bytes4 selector)
        external
        view
        returns (FunctionReference[] memory, FunctionReference[] memory);

    /// @notice Get an array of all installed plugins.
    /// @return pluginAddresses The addresses of all installed plugins.
    function getInstalledPlugins() external view returns (address[] memory);
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

/**
 * @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support execution
 * from plugins.
 */
interface IPluginExecutor {
    /// @notice Execute a call from a plugin through the account.
    /// @dev Permissions must be granted to the calling plugin for the call to go through.
    /// @param data The calldata to send to the account.
    function executeFromPlugin(bytes calldata data) external payable returns (bytes memory);

    /// @notice Execute a call from a plugin to a non-plugin address.
    /// @dev If the target is a plugin, the call SHOULD revert. Permissions must be granted to the calling plugin
    /// for the call to go through.
    /// @param target The address to be called.
    /// @param value The value to send with the call.
    /// @param data The calldata to send to the target.
    /// @return The return data from the call.
    function executeFromPluginExternal(address target, uint256 value, bytes calldata data)
        external
        payable
        returns (bytes memory);
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import "../common/Structs.sol";

/**
 * @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support installing
 * and uninstalling plugins.
 */
interface IPluginManager {
    event PluginInstalled(address indexed plugin, bytes32 manifestHash, FunctionReference[] dependencies);
    event PluginUninstalled(address indexed plugin, bool indexed onUninstallSucceeded);

    /// @notice Install a plugin to the modular account.
    /// @param plugin The plugin to install.
    /// @param manifestHash The hash of the plugin manifest.
    /// @param pluginInstallData Optional data to be decoded and used by the plugin to setup initial plugin data
    /// for the modular account.
    /// @param dependencies The dependencies of the plugin, as described in the manifest. Each FunctionReference
    /// MUST be composed of an installed plugin's address and a function ID of its validation function.
    function installPlugin(
        address plugin,
        bytes32 manifestHash,
        bytes calldata pluginInstallData,
        FunctionReference[] calldata dependencies
    ) external;

    /// @notice Uninstall a plugin from the modular account.
    /// @param plugin The plugin to uninstall.
    /// @param config An optional, implementation-specific field that accounts may use to ensure consistency
    /// guarantees.
    /// @param pluginUninstallData Optional data to be decoded and used by the plugin to clear plugin data for the
    /// modular account.
    function uninstallPlugin(address plugin, bytes calldata config, bytes calldata pluginUninstallData) external;
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import "../common/Structs.sol";

/**
 * @dev Implements https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to support open-ended
 * execution.
 */
interface IStandardExecutor {
    /// @notice Standard execute method.
    /// @dev If the target is a plugin, the call SHOULD revert.
    /// @param target The target address for the account to call.
    /// @param value The value to send with the call.
    /// @param data The calldata for the call.
    /// @return The return data from the call.
    function execute(address target, uint256 value, bytes calldata data) external payable returns (bytes memory);

    /// @notice Standard executeBatch method.
    /// @dev If the target is a plugin, the call SHOULD revert. If any of the calls revert, the entire batch MUST
    /// revert.
    /// @param calls The array of calls.
    /// @return An array containing the return data from the calls.
    function executeBatch(Call[] calldata calls) external payable returns (bytes[] memory);
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {EMPTY_FUNCTION_REFERENCE, SENTINEL_BYTES21} from "../../../../common/Constants.sol";
import {InvalidValidationFunctionId} from "../../shared/common/Errors.sol";
import {
    PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE,
    RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
} from "../common/Constants.sol";
import "../common/Structs.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {FunctionReferenceLib} from "./FunctionReferenceLib.sol";
import {RepeatableFunctionReferenceDLLLib} from "./RepeatableFunctionReferenceDLLLib.sol";

/**
 * @dev Process pre or post execution hooks.
 */
library ExecutionHookLib {
    using RepeatableFunctionReferenceDLLLib for RepeatableBytes21DLL;
    using FunctionReferenceLib for FunctionReference;
    using FunctionReferenceLib for bytes21;

    error PreExecHookFailed(address plugin, uint8 functionId, bytes revertReason);
    error PostExecHookFailed(address plugin, uint8 functionId, bytes revertReason);

    // avoid stack too deep
    struct SetPostExecHooksFromPreHooksParam {
        uint256 totalPostExecHooksToRunCount;
        PostExecHookToRun[] postExecHooksToRun;
    }

    function _processPreExecHooks(HookGroup storage hookGroup, bytes calldata data)
        internal
        returns (PostExecHookToRun[] memory postExecHooksToRun)
    {
        uint256 postOnlyHooksCount = hookGroup.postOnlyHooks.getUniqueItems();
        // hooks have three categories a. preOnlyHook b. preToPostHook c. postOnlyHook
        // 1. add repeated preHook into postHook 2. add postOnlyHooks
        uint256 maxPostHooksCount = postOnlyHooksCount + hookGroup.preHooks.getTotalItems();
        uint256 totalPostExecHooksToRunCount = 0;
        postExecHooksToRun = new PostExecHookToRun[](maxPostHooksCount);
        // copy postOnlyHooks into result first
        FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        for (uint256 i = 0; i < postOnlyHooksCount; ++i) {
            (FunctionReference[] memory resultPostOnlyHooks, FunctionReference memory nextHook) =
                hookGroup.postOnlyHooks.getPaginated(startHook, 10);
            for (uint256 j = 0; j < resultPostOnlyHooks.length; ++j) {
                postExecHooksToRun[totalPostExecHooksToRunCount++].postExecHook = resultPostOnlyHooks[j];
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        // then run the preHooks and copy associated postHooks
        SetPostExecHooksFromPreHooksParam memory input;
        input.totalPostExecHooksToRunCount = totalPostExecHooksToRunCount;
        input.postExecHooksToRun = postExecHooksToRun;
        (totalPostExecHooksToRunCount, postExecHooksToRun) = _setPostExecHooksFromPreHooks(hookGroup, data, input);
        assembly ("memory-safe") {
            mstore(postExecHooksToRun, totalPostExecHooksToRunCount)
        }
    }

    function _processPreExecHook(FunctionReference memory preExecHook, bytes calldata data)
        internal
        returns (bytes memory preExecHookReturnData)
    {
        try IPlugin(preExecHook.plugin).preExecutionHook(preExecHook.functionId, msg.sender, msg.value, data) returns (
            bytes memory returnData
        ) {
            preExecHookReturnData = returnData;
        } catch (bytes memory revertReason) {
            revert PreExecHookFailed(preExecHook.plugin, preExecHook.functionId, revertReason);
        }
        return preExecHookReturnData;
    }

    function _processPostExecHooks(PostExecHookToRun[] memory postExecHooksToRun) internal {
        uint256 length = postExecHooksToRun.length;
        for (uint256 i = 0; i < length; ++i) {
            FunctionReference memory postExecHook = postExecHooksToRun[i].postExecHook;
            try IPlugin(postExecHook.plugin).postExecutionHook(
                postExecHook.functionId, postExecHooksToRun[i].preExecHookReturnData
            ) {} catch (bytes memory revertReason) {
                revert PostExecHookFailed(postExecHook.plugin, postExecHook.functionId, revertReason);
            }
        }
    }

    function _getExecutionHooks(HookGroup storage hookGroup) internal view returns (ExecutionHooks[] memory hooks) {
        uint256 preHooksCount = hookGroup.preHooks.getUniqueItems();
        uint256 postOnlyHooksCount = hookGroup.postOnlyHooks.getUniqueItems();
        // hooks have three categories a. preOnlyHook b. preToPostHook c. postOnlyHook
        // 1. add repeated preHook into postHook 2. add postOnlyHooks
        uint256 maxExecHooksCount = postOnlyHooksCount + hookGroup.preHooks.getTotalItems();
        uint256 totalExecHooksCount = 0;
        hooks = new ExecutionHooks[](maxExecHooksCount);
        // copy postOnlyHooks into result first
        FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        for (uint256 i = 0; i < postOnlyHooksCount; ++i) {
            (FunctionReference[] memory resultPostOnlyHooks, FunctionReference memory nextHook) =
                hookGroup.postOnlyHooks.getPaginated(startHook, 10);
            for (uint256 j = 0; j < resultPostOnlyHooks.length; ++j) {
                hooks[totalExecHooksCount++].postExecHook = resultPostOnlyHooks[j];
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        // then copy preOnlyHooks or preToPostHooks
        startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        for (uint256 i = 0; i < preHooksCount; ++i) {
            (FunctionReference[] memory resultPreExecHooks, FunctionReference memory nextHook) =
                hookGroup.preHooks.getPaginated(startHook, 10);
            for (uint256 j = 0; j < resultPreExecHooks.length; ++j) {
                // if any revert, the outer call MUST revert
                bytes21 packedPreExecHook = resultPreExecHooks[j].pack();
                // getAll can handle 1000+ hooks
                FunctionReference[] memory preToPostHooks = hookGroup.preToPostHooks[packedPreExecHook].getAll();
                if (preToPostHooks.length > 0) {
                    for (uint256 k = 0; k < preToPostHooks.length; ++k) {
                        hooks[totalExecHooksCount].preExecHook = resultPreExecHooks[j];
                        hooks[totalExecHooksCount].postExecHook = preToPostHooks[k];
                        totalExecHooksCount++;
                    }
                } else {
                    // no associated postHook
                    hooks[totalExecHooksCount++].preExecHook = resultPreExecHooks[j];
                }
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        assembly ("memory-safe") {
            mstore(hooks, totalExecHooksCount)
        }
        return hooks;
    }

    /// @dev The caller would expect both input.totalPostExecHooksToRunCount and input.postExecHooksToRun to be assigned
    /// back to original values.
    function _setPostExecHooksFromPreHooks(
        HookGroup storage hookGroup,
        bytes calldata data,
        SetPostExecHooksFromPreHooksParam memory input
    ) internal returns (uint256, PostExecHookToRun[] memory) {
        FunctionReference memory startHook = EMPTY_FUNCTION_REFERENCE.unpack();
        uint256 preHooksCount = hookGroup.preHooks.getUniqueItems();
        for (uint256 i = 0; i < preHooksCount; ++i) {
            (FunctionReference[] memory resultPreExecHooks, FunctionReference memory nextHook) =
                hookGroup.preHooks.getPaginated(startHook, 10);
            for (uint256 j = 0; j < resultPreExecHooks.length; ++j) {
                // if any revert, the outer call MUST revert
                bytes21 packedPreExecHook = resultPreExecHooks[j].pack();
                if (
                    packedPreExecHook == EMPTY_FUNCTION_REFERENCE
                        || packedPreExecHook == RUNTIME_VALIDATION_ALWAYS_ALLOW_FUNCTION_REFERENCE
                        || packedPreExecHook == PRE_HOOK_ALWAYS_DENY_FUNCTION_REFERENCE
                ) {
                    revert InvalidValidationFunctionId(resultPreExecHooks[j].functionId);
                }
                // getAll can handle 1000+ hooks
                // run duplicated (if any) preHooks only once
                bytes memory preExecHookReturnData = _processPreExecHook(resultPreExecHooks[j], data);
                FunctionReference[] memory preToPostHooks = hookGroup.preToPostHooks[packedPreExecHook].getAll();
                if (preToPostHooks.length > 0) {
                    for (uint256 k = 0; k < preToPostHooks.length; ++k) {
                        input.postExecHooksToRun[input.totalPostExecHooksToRunCount].postExecHook = preToPostHooks[k];
                        input.postExecHooksToRun[input.totalPostExecHooksToRunCount].preExecHookReturnData =
                            preExecHookReturnData;
                        input.totalPostExecHooksToRunCount++;
                    }
                }
            }
            if (nextHook.pack() == SENTINEL_BYTES21) {
                break;
            }
            startHook = nextHook;
        }
        return (input.totalPostExecHooksToRunCount, input.postExecHooksToRun);
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {ExecutionUtils} from "../../../../utils/ExecutionUtils.sol";
import {InvalidExecutionFunction, NotFoundSelector} from "../../shared/common/Errors.sol";
import "../common/Structs.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {IPluginExecutor} from "../interfaces/IPluginExecutor.sol";
import {ExecutionHookLib} from "../libs/ExecutionHookLib.sol";
import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";

/**
 * @dev Default implementation of https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to
 * support execution from plugins.
 *      https://eips.ethereum.org/assets/eip-6900/Plugin_Execution_Flow.svg
 */
library PluginExecutor {
    using ExecutionHookLib for HookGroup;
    using ExecutionHookLib for PostExecHookToRun[];
    using ExecutionUtils for address;

    error ExecuteFromPluginToExternalNotPermitted();
    error ExecFromPluginToSelectorNotPermitted(address plugin, bytes4 selector);
    error NativeTokenSpendingNotPermitted(address plugin);

    /// @dev Refer to IPluginExecutor
    function executeFromPlugin(bytes calldata data) internal returns (bytes memory) {
        if (data.length < 4) {
            revert NotFoundSelector();
        }
        bytes4 selector = bytes4(data[0:4]);
        if (selector == bytes4(0)) {
            revert NotFoundSelector();
        }
        address callingPlugin = msg.sender;
        WalletStorageV1Lib.Layout storage walletStorage = WalletStorageV1Lib.getLayout();
        // permission check
        if (!walletStorage.permittedPluginCalls[callingPlugin][selector]) {
            revert ExecFromPluginToSelectorNotPermitted(callingPlugin, selector);
        }
        // this function call emulates a call to the fallback that routes calls into another plugin;
        // we use inner data here instead of the entire msg.data that includes the complete calldata of
        // executeFromPlugin
        ExecutionDetail storage executionDetail = walletStorage.executionDetails[selector];
        if (executionDetail.plugin == address(0)) {
            revert InvalidExecutionFunction(selector);
        }
        // pre execution hooks
        PostExecHookToRun[] memory postExecHooks = executionDetail.executionHooks._processPreExecHooks(data);
        // permitted to call the other plugin
        bytes memory returnData = executionDetail.plugin.callWithReturnDataOrRevert(0, data);
        // post execution hooks
        postExecHooks._processPostExecHooks();
        return returnData;
    }

    /// @dev Refer to IPluginExecutor
    function executeFromPluginToExternal(bytes calldata data, address target, uint256 value)
        internal
        returns (bytes memory)
    {
        if (target == address(this) || ERC165Checker.supportsInterface(target, type(IPlugin).interfaceId)) {
            revert ExecuteFromPluginToExternalNotPermitted();
        }
        WalletStorageV1Lib.Layout storage walletStorage = WalletStorageV1Lib.getLayout();
        address callingPlugin = msg.sender;
        // revert if the plugin can't cover the value and is not permitted to spend MSCA's native token
        if (value > 0 && value > msg.value && !walletStorage.pluginDetails[callingPlugin].canSpendNativeToken) {
            revert NativeTokenSpendingNotPermitted(callingPlugin);
        }
        PermittedExternalCall storage permittedExternalCall =
            walletStorage.permittedExternalCalls[callingPlugin][target];
        // permission check
        // addressPermitted can only be true if anyExternalAddressPermitted is false
        bool targetContractCallPermitted;
        // external call might not have function selector
        bytes4 selector = bytes4(data);
        if (permittedExternalCall.addressPermitted) {
            targetContractCallPermitted =
                permittedExternalCall.anySelector || permittedExternalCall.selectors[selector] || data.length == 0;
        } else {
            // also need to check the default permission in plugin detail
            targetContractCallPermitted = walletStorage.pluginDetails[callingPlugin].anyExternalAddressPermitted;
        }
        if (!targetContractCallPermitted) {
            revert ExecFromPluginToSelectorNotPermitted(callingPlugin, selector);
        }
        // we use msg.data here so the complete calldata of current function call executeFromPluginToExternalContract
        // can be passed
        // pre executeFromPluginToExternalContract hooks
        // process any pre exec hooks for IPluginExecutor.executeFromPluginExternal.selector during runtime
        PostExecHookToRun[] memory postExecHooks = walletStorage.executionDetails[IPluginExecutor
            .executeFromPluginExternal
            .selector].executionHooks._processPreExecHooks(msg.data);
        // call externally
        bytes memory returnData = target.callWithReturnDataOrRevert(value, data);
        // post executeFromPluginToExternalContract hooks
        postExecHooks._processPostExecHooks();
        return returnData;
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {ExecutionUtils} from "../../../../utils/ExecutionUtils.sol";
import "../common/Structs.sol";
import {IPlugin} from "../interfaces/IPlugin.sol";
import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";

/**
 * @dev Default implementation of https://eips.ethereum.org/EIPS/eip-6900. MSCAs must implement this interface to
 * support open-ended execution.
 */
library StandardExecutor {
    using ExecutionUtils for address;

    error TargetIsPlugin(address plugin);

    /// @dev Refer to IStandardExecutor
    function execute(address target, uint256 value, bytes calldata data) internal returns (bytes memory returnData) {
        // reverts if the target is a plugin because modular account should be calling plugin via execution functions
        // defined in IPluginExecutor
        if (ERC165Checker.supportsInterface(target, type(IPlugin).interfaceId)) {
            revert TargetIsPlugin(target);
        }
        return target.callWithReturnDataOrRevert(value, data);
    }

    /// @dev Refer to IStandardExecutor
    function executeBatch(Call[] calldata calls) internal returns (bytes[] memory returnData) {
        returnData = new bytes[](calls.length);
        for (uint256 i = 0; i < calls.length; ++i) {
            if (ERC165Checker.supportsInterface(calls[i].target, type(IPlugin).interfaceId)) {
                revert TargetIsPlugin(calls[i].target);
            }
            returnData[i] = calls[i].target.callWithReturnDataOrRevert(calls[i].value, calls[i].data);
        }
        return returnData;
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

import {WalletStorageV1Lib} from "../libs/WalletStorageV1Lib.sol";

/// @notice Forked from OpenZeppelin (proxy/utils/Initializable.sol) with wallet storage access.
///         Reinitialization is removed.
///         For V1 MSCA.
abstract contract WalletStorageInitializable {
    /**
     * @dev Triggered when the contract has been initialized.
     */
    event WalletStorageInitialized();

    error WalletStorageIsInitializing();
    error WalletStorageIsNotInitializing();
    error WalletStorageIsInitialized();

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyWalletStorageInitializing` functions can be used to initialize parent contracts.
     *
     * Functions marked with `walletStorageInitializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {WalletStorageInitialized} event.
     */
    modifier walletStorageInitializer() {
        bool isTopLevelCall = _setWalletStorageInitializing();
        _;
        if (isTopLevelCall) {
            WalletStorageV1Lib.getLayout().initializing = false;
            emit WalletStorageInitialized();
        }
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {walletStorageInitializer} modifier, directly or indirectly.
     */
    modifier onlyWalletStorageInitializing() {
        if (!WalletStorageV1Lib.getLayout().initializing) {
            revert WalletStorageIsNotInitializing();
        }
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {WalletStorageInitialized} event the first time it is successfully executed.
     */
    function _disableWalletStorageInitializers() internal virtual {
        if (WalletStorageV1Lib.getLayout().initializing) {
            revert WalletStorageIsInitializing();
        }
        if (WalletStorageV1Lib.getLayout().initialized != type(uint8).max) {
            WalletStorageV1Lib.getLayout().initialized = type(uint8).max;
            emit WalletStorageInitialized();
        }
    }

    function _setWalletStorageInitializing() internal returns (bool) {
        bool isTopLevelCall = !WalletStorageV1Lib.getLayout().initializing;
        uint8 initialized = WalletStorageV1Lib.getLayout().initialized;
        if (!(isTopLevelCall && initialized < 1) || (address(this).code.length <= 0 && initialized == 1)) {
            revert WalletStorageIsInitialized();
        }
        WalletStorageV1Lib.getLayout().initialized = 1;
        if (isTopLevelCall) {
            WalletStorageV1Lib.getLayout().initializing = true;
        }
        return isTopLevelCall;
    }
}

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

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

/**
 * returned data from validateUserOp.
 * validateUserOp returns a uint256, with 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
    function _parseValidationData(uint 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);
    }

// intersect account and paymaster ranges.
    function _intersectTimeRange(uint256 validationData, uint256 paymasterValidationData) pure returns (ValidationData memory) {
        ValidationData memory accountValidationData = _parseValidationData(validationData);
        ValidationData memory pmValidationData = _parseValidationData(paymasterValidationData);
        address aggregator = accountValidationData.aggregator;
        if (aggregator == address(0)) {
            aggregator = pmValidationData.aggregator;
        }
        uint48 validAfter = accountValidationData.validAfter;
        uint48 validUntil = accountValidationData.validUntil;
        uint48 pmValidAfter = pmValidationData.validAfter;
        uint48 pmValidUntil = pmValidationData.validUntil;

        if (validAfter < pmValidAfter) validAfter = pmValidAfter;
        if (validUntil > pmValidUntil) validUntil = pmValidUntil;
        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 {
            let mem := mload(0x40)
            let len := data.length
            calldatacopy(mem, data.offset, len)
            ret := keccak256(mem, len)
        }
    }

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822ProxiableUpgradeable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeaconUpgradeable.sol";
import "../../interfaces/IERC1967Upgradeable.sol";
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/StorageSlotUpgradeable.sol";
import {Initializable} from "../utils/Initializable.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 */
abstract contract ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    function __ERC1967Upgrade_init() internal onlyInitializing {
    }

    function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            AddressUpgradeable.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            AddressUpgradeable.functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
        }
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

/*
 * Copyright 2024 Circle Internet Group, Inc. All rights reserved.

 * SPDX-License-Identifier: GPL-3.0-or-later

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
pragma solidity 0.8.24;

/**
 * @notice Forked from OZ V5 as it doesn't exist in V4.
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"1901")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

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

import "./UserOperation.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 {
        opSucceeded, // user op succeeded
        opReverted, // user op reverted. still has to pay for gas.
        postOpReverted //user op succeeded, but caused postOp to revert. Now it's a 2nd call, after user's op was deliberately reverted.
    }

    /**
     * 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,
     *         otherwise, an address of an "authorizer" contract.
     *      <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(UserOperation 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. 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) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 *
 * _Available since v4.8.3._
 */
interface IERC1967 {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC777/IERC777Recipient.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC777TokensRecipient standard as defined in the EIP.
 *
 * Accounts can be notified of {IERC777} tokens being sent to them by having a
 * contract implement this interface (contract holders can be their own
 * implementer) and registering it on the
 * https://eips.ethereum.org/EIPS/eip-1820[ERC1820 global registry].
 *
 * See {IERC1820Registry} and {ERC1820Implementer}.
 */
interface IERC777Recipient {
    /**
     * @dev Called by an {IERC777} token contract whenever tokens are being
     * moved or created into a registered account (`to`). The type of operation
     * is conveyed by `from` being the zero address or not.
     *
     * This call occurs _after_ the token contract's state is updated, so
     * {IERC777-balanceOf}, etc., can be used to query the post-operation state.
     *
     * This function may revert to prevent the operation from being executed.
     */
    function tokensReceived(
        address operator,
        address from,
        address to,
        uint256 amount,
        bytes calldata userData,
        bytes calldata operatorData
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeaconUpgradeable {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 *
 * _Available since v4.8.3._
 */
interface IERC1967Upgradeable {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlotUpgradeable {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/",
    "@account-abstraction/=lib/account-abstraction/",
    "@modular-account-libs/=node_modules/@modular-account-libs/src/",
    "@solady/=node_modules/solady/src/",
    "@fcl/=node_modules/fcl/solidity/src/",
    "forge-std/=node_modules/forge-std/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": true,
  "libraries": {}
}

[{"inputs":[{"internalType":"address","name":"_entryPointAddr","type":"address"},{"internalType":"address","name":"_pluginManagerAddr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"Create2FailedDeployment","type":"error"},{"inputs":[],"name":"InvalidInitializationInput","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"AccountCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"factory","type":"address"},{"indexed":false,"internalType":"address","name":"accountImplementation","type":"address"},{"indexed":false,"internalType":"address","name":"entryPoint","type":"address"}],"name":"FactoryDeployed","type":"event"},{"inputs":[],"name":"accountImplementation","outputs":[{"internalType":"contract SingleOwnerMSCA","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"},{"internalType":"bytes","name":"_initializingData","type":"bytes"}],"name":"createAccount","outputs":[{"internalType":"contract SingleOwnerMSCA","name":"account","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"entryPoint","outputs":[{"internalType":"contract IEntryPoint","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"bytes32","name":"_salt","type":"bytes32"},{"internalType":"bytes","name":"_initializingData","type":"bytes"}],"name":"getAddress","outputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes32","name":"mixedSalt","type":"bytes32"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000005ff137d4b0fdcd49dca30c7cf57e578a026d27890000000000000000000000003169ad878021b87c9caa9b5cda740ff3ca270ce9

-----Decoded View---------------
Arg [0] : _entryPointAddr (address): 0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789
Arg [1] : _pluginManagerAddr (address): 0x3169Ad878021B87C9CaA9b5CDA740ff3ca270Ce9

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005ff137d4b0fdcd49dca30c7cf57e578a026d2789
Arg [1] : 0000000000000000000000003169ad878021b87c9caa9b5cda740ff3ca270ce9