{"matchId":"54164454","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-09-30T02:42:51Z","creationBytecode":{"onchainBytecode":"0x60803460c157601f61082b38819003918201601f19168301916001600160401b0383118484101760c55780849260209460405283398101031260c157516001600160a01b0381169081900360c157801560ae57600180546001600160a01b03199081169091555f80549182168317815560405192916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a361075190816100da8239f35b631e4fbdf760e01b5f525f60045260245ffd5b5f80fd5b634e487b7160e01b5f52604160045260245ffdfe6080604052600436101561001a575b3615610018575f80fd5b005b5f3560e01c8063041d7aed146103de5780631e1bff3f14610361578063715018a6146102fe57806379ba5097146102795780638da5cb5b146102525780639ac2a01114610215578063b61d27f61461011f578063e30c3978146100f75763f2fde38b0361000e57346100f35760203660031901126100f35761009a610632565b6100a261073e565b60018060a01b0316806bffffffffffffffffffffffff60a01b600154161760015560018060a01b035f54167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e227005f80a3005b5f80fd5b346100f3575f3660031901126100f3576001546040516001600160a01b039091168152602090f35b60603660031901126100f357610133610632565b6044359067ffffffffffffffff82116100f357366023830112156100f35781600401359067ffffffffffffffff82116100f35736602483850101116100f3575f546001600160a01b0316331415806101fe575b6101eb575f92828460206101a261019d83976106ba565b61067c565b9280845280602483860196018637830101525191602435905af16101c46106d6565b90156101e6576101e29060405191829160208352602083019061060e565b0390f35b610723565b63b665426360e01b5f523360045260245ffd5b50335f52600260205260ff60405f20541615610186565b346100f35760203660031901126100f3576001600160a01b03610236610632565b165f526002602052602060ff60405f2054166040519015158152f35b346100f3575f3660031901126100f3575f546040516001600160a01b039091168152602090f35b346100f3575f3660031901126100f357600154336001600160a01b03909116036102eb57600180546001600160a01b03199081169091555f805433928116831782556001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a3005b63118cdaa760e01b5f523360045260245ffd5b346100f3575f3660031901126100f35761031661073e565b600180546001600160a01b03199081169091555f80549182168155906001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a3005b346100f35760403660031901126100f35761037a610632565b602435908115158092036100f35760207f278b09622564dd3991fe7744514513d64ea2c8ed2b2b9ec1150ad964fde80a99916103b461073e565b60018060a01b031692835f526002825260405f2060ff1981541660ff8316179055604051908152a2005b346100f35760203660031901126100f35760043567ffffffffffffffff81116100f357366023820112156100f35780600401359067ffffffffffffffff82116100f3573660248360051b830101116100f3575f546001600160a01b0316331415806105f7575b6101eb5761045461019d836106a2565b82815291601f19610464826106a2565b015f5b8181106105d7575050905f9060821981360301915b8381101561055d5760248160051b83010135838112156100f357820160248101356001600160a01b03811681036100f357606482013560421936849003018112156100f35782016024018035919067ffffffffffffffff83116100f3576020019082360382136100f357825f80949381946040519384928337810182815203925af16105066106d6565b901580928193610548575b506101e6579060019291610523610648565b91158252602082015261053682886106fb565b5261054181876106fb565b500161047c565b60449150013580151581036100f35788610511565b846040518091602082016020835281518091526040830190602060408260051b8601019301915f905b82821061059557505050500390f35b919360019193955060206105c78192603f198a82030186526040838a518051151584520151918185820152019061060e565b9601920192018594939192610586565b6020906105e2610648565b5f815260608382015282828801015201610467565b50335f52600260205260ff60405f20541615610444565b805180835260209291819084018484015e5f828201840152601f01601f1916010190565b600435906001600160a01b03821682036100f357565b604051906040820182811067ffffffffffffffff82111761066857604052565b634e487b7160e01b5f52604160045260245ffd5b6040519190601f01601f1916820167ffffffffffffffff81118382101761066857604052565b67ffffffffffffffff81116106685760051b60200190565b67ffffffffffffffff811161066857601f01601f191660200190565b3d156106f6573d906106ea61019d836106ba565b9182523d5f602084013e565b606090565b805182101561070f5760209160051b010190565b634e487b7160e01b5f52603260045260245ffd5b8051908161073957625672ed60e91b5f5260045ffd5b602001fd5b5f546001600160a01b031633036102eb5756000000000000000000000000de123e2a7ddcf4088986cc10f4099070466c31e0","recompiledBytecode":"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","sourceMap":"440:3322:3:-:0;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;1273:26:0;;1269:95;;440:3322:3;;;-1:-1:-1;;;;;;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;;3052:40:0;;-1:-1:-1;3052:40:0;440:3322:3;;;;;;;1269:95:0;1322:31;;;-1:-1:-1;1322:31:0;-1:-1:-1;1322:31:0;440:3322:3;;-1:-1:-1;1322:31:0;440:3322:3;-1:-1:-1;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;;;;-1:-1:-1;440:3322:3","linkReferences":{},"cborAuxdata":{},"transformations":[{"type":"insert","offset":2091,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000de123e2a7ddcf4088986cc10f4099070466c31e0"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"440:3322:3:-:0;;;;;;;;;-1:-1:-1;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;:::i;:::-;1500:62:0;;:::i;:::-;440:3322:3;;;;;;;;;;1738:24:1;440:3322:3;;;1738:24:1;440:3322:3;;;;;;;;;1777:43:1;440:3322:3;1777:43:1;;440:3322:3;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;1344:10;:21;;;:47;;440:3322;1340:123;;440:3322;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;3367:33;440:3322;;;3367:33;;;;;:::i;:::-;3414:8;;3410:60;;440:3322;;;;;;;;;;;;;;;:::i;:::-;;;;3410:60;3450:8;:::i;1340:123::-;1414:38;;;440:3322;1414:38;1344:10;440:3322;;;;1414:38;1344:47;:10;;440:3322;;1370:9;440:3322;;;;;;;;1369:22;1344:47;;440:3322;;;;;;-1:-1:-1;;440:3322:3;;;;-1:-1:-1;;;;;440:3322:3;;:::i;:::-;;;;557:60;440:3322;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;735:10:2;-1:-1:-1;;;;;440:3322:3;;;2339:24:1;2335:96;;1311:13;440:3322:3;;-1:-1:-1;;;;;;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;735:10:2;440:3322:3;;;;;;;-1:-1:-1;;;;;440:3322:3;;3052:40:0;;-1:-1:-1;3052:40:0;440:3322:3;2335:96:1;2386:34;;;440:3322:3;2386:34:1;735:10:2;440:3322:3;;;;2386:34:1;440:3322:3;;;;;;-1:-1:-1;;440:3322:3;;;;1500:62:0;;:::i;:::-;2093:20:1;440:3322:3;;-1:-1:-1;;;;;;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;;;;;;-1:-1:-1;;;;;;440:3322:3;3052:40:0;-1:-1:-1;;3052:40:0;440:3322:3;;;;;;;-1:-1:-1;;440:3322:3;;;;;;:::i;:::-;;;;;;;;;;;;;3162:30;1500:62:0;;;:::i;:::-;440:3322:3;;;;;;;;;;3118:9;440:3322;;;;;;;;;;;;;;;;;;;;;3162:30;440:3322;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;1344:10;:21;;;:47;;440:3322;1340:123;;440:3322;;;;:::i;:::-;;;;;-1:-1:-1;;440:3322:3;;;:::i;:::-;;;;;;;;;2478:9;;;440:3322;;;;;;;;2473:355;2507:3;2489:16;;;;;;440:3322;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;2628:9;;;440:3322;-1:-1:-1;;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2611:27;;;;;;:::i;:::-;2656:8;;;;;:25;;;2507:3;2652:87;;;440:3322;;;;;;:::i;:::-;;;;;;2765:52;;440:3322;2752:65;;;;:::i;:::-;;;;;;:::i;:::-;;440:3322;2478:9;;2656:25;2668:13;;;;440:3322;;;;;;;;2656:25;;;2489:16;;440:3322;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;1344:47;:10;;440:3322;;1370:9;440:3322;;;;;;;;1369:22;1344:47;;440:3322;;;;;;;;;;;;;;;;;-1:-1:-1;440:3322:3;;;;;;;;-1:-1:-1;;440:3322:3;;;;:::o;:::-;;;;-1:-1:-1;;;;;440:3322:3;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;440:3322:3;;;;;-1:-1:-1;440:3322:3;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;440:3322:3;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;440:3322:3;;;;:::o;:::-;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;3482:278;440:3322;;3553:19;;3549:150;;3715:38;;;3571:1;3715:38;;3571:1;3715:38;3549:150;3588:101;;;1796:162:0;1710:6;440:3322:3;-1:-1:-1;;;;;440:3322:3;735:10:2;1855:23:0;1851:101;;1796:162::o","linkReferences":{},"cborAuxdata":{},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x0bc6c200e39bd3a520af1bd3d8594c68f3f21449e787130a02f1c56782233d05","blockNumber":"25885789","transactionIndex":"269","deployer":"0xDe123e2A7dDcf4088986CC10F4099070466C31E0"},"sources":{"src/wallet/KeeperWallet.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity ^0.8.28;\n\nimport { Ownable, Ownable2Step } from \"openzeppelin-contracts/access/Ownable2Step.sol\";\n\nstruct Call {\n    address target;\n    bool required;\n    bytes data;\n}\n\nstruct Result {\n    bool success;\n    bytes returnData;\n}\n\n/// @title KeeperWallet\n/// @author Enso\n/// @notice Simple wallet that executes single or batched calls, restricted to the owner and approved executors\ncontract KeeperWallet is Ownable2Step {\n    /// @notice Accounts authorized to execute calls through this wallet\n    mapping(address executor => bool isAllowed) public executors;\n\n    /// @notice Emitted when an executor is added or removed\n    /// @param executor The address of the executor\n    /// @param allowed Whether the executor is allowed to execute calls\n    event ExecutorSet(address indexed executor, bool allowed);\n\n    /// @notice Thrown when the sender is neither the owner nor an approved executor\n    /// @param sender The address that attempted the unauthorized call\n    error KeeperWallet_InvalidSender(address sender);\n\n    /// @notice Thrown when a call fails without a revert reason\n    error KeeperWallet_ExecutionFailedNoReason();\n\n    /// @dev The owner is always allowed to execute, so funds can be moved out even with no executors set\n    modifier onlyExecutor() {\n        if (msg.sender != owner() && !executors[msg.sender]) {\n            revert KeeperWallet_InvalidSender(msg.sender);\n        }\n        _;\n    }\n\n    constructor(address owner_) Ownable(owner_) { }\n\n    receive() external payable { }\n\n    /// @notice Executes a single call\n    /// @param target The address of the contract to call\n    /// @param value The amount of native token to send with the call\n    /// @param data The calldata to send to the target contract\n    /// @return response The return data of the call\n    function execute(\n        address target,\n        uint256 value,\n        bytes calldata data\n    )\n        external\n        payable\n        onlyExecutor\n        returns (bytes memory response)\n    {\n        response = _execute(target, value, data);\n    }\n\n    /// @notice Executes multiple calls, reverting all only if a required call fails\n    /// @param calls The calls to execute\n    /// @return results The success flag and return data of each call\n    function executeMulti(Call[] calldata calls) external onlyExecutor returns (Result[] memory results) {\n        results = new Result[](calls.length);\n        for (uint256 i; i < calls.length; ++i) {\n            Call calldata call = calls[i];\n            (bool success, bytes memory returnData) = call.target.call(call.data);\n            if (!success && call.required) {\n                _revertWith(returnData);\n            }\n            results[i] = Result({ success: success, returnData: returnData });\n        }\n    }\n\n    /// @notice Authorizes or deauthorizes an address to execute calls\n    /// @param executor The address to authorize or deauthorize\n    /// @param allowed Whether the address should be allowed\n    function setExecutor(address executor, bool allowed) external onlyOwner {\n        executors[executor] = allowed;\n        emit ExecutorSet(executor, allowed);\n    }\n\n    function _execute(address target, uint256 value, bytes memory data) private returns (bytes memory response) {\n        bool success;\n        (success, response) = target.call{ value: value }(data);\n        if (!success) {\n            _revertWith(response);\n        }\n    }\n\n    function _revertWith(bytes memory response) private pure {\n        if (response.length > 0) {\n            assembly (\"memory-safe\") {\n                revert(add(0x20, response), mload(response))\n            }\n        }\n        revert KeeperWallet_ExecutionFailedNoReason();\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable2Step.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * This extension of the {Ownable} contract includes a two-step mechanism to transfer\n * ownership, where the new owner must call {acceptOwnership} in order to replace the\n * old one. This can help prevent common mistakes, such as transfers of ownership to\n * incorrect accounts, or to contracts that are unable to interact with the\n * permission system.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     *\n     * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        if (pendingOwner() != sender) {\n            revert OwnableUnauthorizedAccount(sender);\n        }\n        _transferOwnership(sender);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["@layerzerolabs/oapp-evm/=dependencies/devtools-0.0.1/packages/oapp-evm/","@layerzerolabs/lz-evm-protocol-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/protocol/","@layerzerolabs/lz-evm-oapp-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/oapp/","@uniswap/v4-core/=dependencies/v4-core-4.0.0/","@uniswap/v4-periphery/=dependencies/v4-periphery-4.0.0/","@uniswap/universal-router/=dependencies/universal-router-4.0.0/","@uniswap/permit2/=dependencies/permit2-4.0.0/","devtools/=dependencies/devtools-0.0.1/packages/toolbox-foundry/src/","ds-test/=dependencies/forge-std-1.9.7/dependencies/ds-test/src/","enso-weiroll/=dependencies/enso-weiroll-1.4.1/contracts/","erc4626-tests/=dependencies/@openzeppelin-contracts-5.2.0/lib/erc4626-tests/","forge-std/=dependencies/forge-std-1.9.7/src/","halmos-cheatcodes/=dependencies/@openzeppelin-contracts-5.2.0/lib/halmos-cheatcodes/src/","layerzero-v2/=dependencies/layerzero-v2-2.0.2/","openzeppelin-contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/","safe-contracts/=dependencies/safe-tools-0.2.0/lib/safe-contracts/contracts/","safe-tools/=dependencies/safe-tools-0.2.0/src/","solady/=dependencies/solady-0.1.22/src/","solmate/=dependencies/solady-0.1.22/lib/solmate/src/","@ensdomains/=dependencies/v4-core-4.0.0/node_modules/@ensdomains/","forge-gas-snapshot/=dependencies/v4-periphery-4.0.0/lib/permit2/lib/forge-gas-snapshot/src/","hardhat/=dependencies/v4-core-4.0.0/node_modules/hardhat/","permit2/=dependencies/v4-periphery-4.0.0/lib/permit2/","v4-core/=dependencies/v4-core-4.0.0/src/","v4-periphery/=dependencies/v4-periphery-4.0.0/","account-abstraction-v7/=dependencies/account-abstraction-v7-0.7.0/contracts/","@openzeppelin-contracts-5.2.0/=dependencies/@openzeppelin-contracts-5.2.0/","account-abstraction-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/","devtools-0.0.1/=dependencies/devtools-0.0.1/","enso-weiroll-1.4.1/=dependencies/enso-weiroll-1.4.1/contracts/","forge-std-1.9.7/=dependencies/forge-std-1.9.7/src/","layerzero-v2-2.0.2/=dependencies/layerzero-v2-2.0.2/","safe-smart-account-1.5.0/=dependencies/safe-smart-account-1.5.0/contracts/","safe-tools-0.2.0/=dependencies/safe-tools-0.2.0/src/","solady-0.1.22/=dependencies/solady-0.1.22/src/","v4-core-4.0.0/=dependencies/v4-core-4.0.0/src/","v4-periphery-4.0.0/=dependencies/v4-periphery-4.0.0/src/","chainlink-ccip/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/","chainlink-ccip-1.6.2/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/","chainlink-evm/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/","chainlink-evm-1.5.0/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/","@chainlink/=dependencies/chainlink-evm-1.5.0/","@openzeppelin/contracts@5.0.2/utils/introspection/IERC165.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/IERC165.sol","@openzeppelin/contracts@5.0.2/utils/introspection/ERC165Checker.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/ERC165Checker.sol","@openzeppelin/contracts@4.8.3/token/ERC20/utils/SafeERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/utils/SafeERC20.sol","@openzeppelin/contracts@4.8.3/token/ERC20/IERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/IERC20.sol","universal-router-4.0.0/=dependencies/universal-router-4.0.0/","@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/","@uniswap/v2-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v2-core/","@uniswap/v3-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v3-core/","@uniswap/v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/","account-abstraction-v7-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/","permit2-4.0.0/=dependencies/permit2-4.0.0/","shortcuts-vm-0.1.0/=dependencies/shortcuts-vm-0.1.0/src/","v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/contracts/"]},"name":"KeeperWallet","fullyQualifiedName":"src/wallet/KeeperWallet.sol:KeeperWallet"},"abi":[{"type":"constructor","inputs":[{"name":"owner_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"KeeperWallet_ExecutionFailedNoReason","type":"error","inputs":[]},{"name":"KeeperWallet_InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ExecutorSet","type":"event","inputs":[{"name":"executor","type":"address","indexed":true,"internalType":"address"},{"name":"allowed","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"execute","type":"function","inputs":[{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"response","type":"bytes","internalType":"bytes"}],"stateMutability":"payable"},{"name":"executeMulti","type":"function","inputs":[{"name":"calls","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"required","type":"bool","internalType":"bool"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct Call[]"}],"outputs":[{"name":"results","type":"tuple[]","components":[{"name":"success","type":"bool","internalType":"bool"},{"name":"returnData","type":"bytes","internalType":"bytes"}],"internalType":"struct Result[]"}],"stateMutability":"nonpayable"},{"name":"executors","type":"function","inputs":[{"name":"executor","type":"address","internalType":"address"}],"outputs":[{"name":"isAllowed","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setExecutor","type":"function","inputs":[{"name":"executor","type":"address","internalType":"address"},{"name":"allowed","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"owner_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"KeeperWallet_ExecutionFailedNoReason","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"KeeperWallet_InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"executor","type":"address"},{"indexed":false,"internalType":"bool","name":"allowed","type":"bool"}],"name":"ExecutorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"execute","outputs":[{"internalType":"bytes","name":"response","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"required","type":"bool"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Call[]","name":"calls","type":"tuple[]"}],"name":"executeMulti","outputs":[{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"returnData","type":"bytes"}],"internalType":"struct Result[]","name":"results","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"executor","type":"address"}],"name":"executors","outputs":[{"internalType":"bool","name":"isAllowed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"executor","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"}],"name":"setExecutor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"author":"Enso","errors":{"KeeperWallet_InvalidSender(address)":[{"params":{"sender":"The address that attempted the unauthorized call"}}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}]},"events":{"ExecutorSet(address,bool)":{"params":{"allowed":"Whether the executor is allowed to execute calls","executor":"The address of the executor"}}},"kind":"dev","methods":{"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"execute(address,uint256,bytes)":{"params":{"data":"The calldata to send to the target contract","target":"The address of the contract to call","value":"The amount of native token to send with the call"},"returns":{"response":"The return data of the call"}},"executeMulti((address,bool,bytes)[])":{"params":{"calls":"The calls to execute"},"returns":{"results":"The success flag and return data of each call"}},"owner()":{"details":"Returns the address of the current owner."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"setExecutor(address,bool)":{"params":{"allowed":"Whether the address should be allowed","executor":"The address to authorize or deauthorize"}},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer."}},"title":"KeeperWallet","version":1},"userdoc":{"errors":{"KeeperWallet_ExecutionFailedNoReason()":[{"notice":"Thrown when a call fails without a revert reason"}],"KeeperWallet_InvalidSender(address)":[{"notice":"Thrown when the sender is neither the owner nor an approved executor"}]},"events":{"ExecutorSet(address,bool)":{"notice":"Emitted when an executor is added or removed"}},"kind":"user","methods":{"execute(address,uint256,bytes)":{"notice":"Executes a single call"},"executeMulti((address,bool,bytes)[])":{"notice":"Executes multiple calls, reverting all only if a required call fails"},"executors(address)":{"notice":"Accounts authorized to execute calls through this wallet"},"setExecutor(address,bool)":{"notice":"Authorizes or deauthorizes an address to execute calls"}},"notice":"Simple wallet that executes single or batched calls, restricted to the owner and approved executors","version":1}},"settings":{"compilationTarget":{"src/wallet/KeeperWallet.sol":"KeeperWallet"},"evmVersion":"cancun","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@chainlink/=dependencies/chainlink-evm-1.5.0/",":@ensdomains/=dependencies/v4-core-4.0.0/node_modules/@ensdomains/",":@layerzerolabs/lz-evm-oapp-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/oapp/",":@layerzerolabs/lz-evm-protocol-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/protocol/",":@layerzerolabs/oapp-evm/=dependencies/devtools-0.0.1/packages/oapp-evm/",":@openzeppelin-contracts-5.2.0/=dependencies/@openzeppelin-contracts-5.2.0/",":@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/",":@openzeppelin/contracts@4.8.3/token/ERC20/IERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/IERC20.sol",":@openzeppelin/contracts@4.8.3/token/ERC20/utils/SafeERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/utils/SafeERC20.sol",":@openzeppelin/contracts@5.0.2/utils/introspection/ERC165Checker.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/ERC165Checker.sol",":@openzeppelin/contracts@5.0.2/utils/introspection/IERC165.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/IERC165.sol",":@uniswap/permit2/=dependencies/permit2-4.0.0/",":@uniswap/universal-router/=dependencies/universal-router-4.0.0/",":@uniswap/v2-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v2-core/",":@uniswap/v3-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v3-core/",":@uniswap/v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/",":@uniswap/v4-core/=dependencies/v4-core-4.0.0/",":@uniswap/v4-periphery/=dependencies/v4-periphery-4.0.0/",":account-abstraction-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/",":account-abstraction-v7-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/",":account-abstraction-v7/=dependencies/account-abstraction-v7-0.7.0/contracts/",":chainlink-ccip-1.6.2/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/",":chainlink-ccip/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/",":chainlink-evm-1.5.0/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/",":chainlink-evm/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/",":devtools-0.0.1/=dependencies/devtools-0.0.1/",":devtools/=dependencies/devtools-0.0.1/packages/toolbox-foundry/src/",":ds-test/=dependencies/forge-std-1.9.7/dependencies/ds-test/src/",":enso-weiroll-1.4.1/=dependencies/enso-weiroll-1.4.1/contracts/",":enso-weiroll/=dependencies/enso-weiroll-1.4.1/contracts/",":erc4626-tests/=dependencies/@openzeppelin-contracts-5.2.0/lib/erc4626-tests/",":forge-gas-snapshot/=dependencies/v4-periphery-4.0.0/lib/permit2/lib/forge-gas-snapshot/src/",":forge-std-1.9.7/=dependencies/forge-std-1.9.7/src/",":forge-std/=dependencies/forge-std-1.9.7/src/",":halmos-cheatcodes/=dependencies/@openzeppelin-contracts-5.2.0/lib/halmos-cheatcodes/src/",":hardhat/=dependencies/v4-core-4.0.0/node_modules/hardhat/",":layerzero-v2-2.0.2/=dependencies/layerzero-v2-2.0.2/",":layerzero-v2/=dependencies/layerzero-v2-2.0.2/",":openzeppelin-contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/",":permit2-4.0.0/=dependencies/permit2-4.0.0/",":permit2/=dependencies/v4-periphery-4.0.0/lib/permit2/",":safe-contracts/=dependencies/safe-tools-0.2.0/lib/safe-contracts/contracts/",":safe-smart-account-1.5.0/=dependencies/safe-smart-account-1.5.0/contracts/",":safe-tools-0.2.0/=dependencies/safe-tools-0.2.0/src/",":safe-tools/=dependencies/safe-tools-0.2.0/src/",":shortcuts-vm-0.1.0/=dependencies/shortcuts-vm-0.1.0/src/",":solady-0.1.22/=dependencies/solady-0.1.22/src/",":solady/=dependencies/solady-0.1.22/src/",":solmate/=dependencies/solady-0.1.22/lib/solmate/src/",":universal-router-4.0.0/=dependencies/universal-router-4.0.0/",":v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/contracts/",":v4-core-4.0.0/=dependencies/v4-core-4.0.0/src/",":v4-core/=dependencies/v4-core-4.0.0/src/",":v4-periphery-4.0.0/=dependencies/v4-periphery-4.0.0/src/",":v4-periphery/=dependencies/v4-periphery-4.0.0/"],"viaIR":true},"sources":{"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable.sol":{"keccak256":"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb","license":"MIT","urls":["bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6","dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a"]},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable2Step.sol":{"keccak256":"0xdcad8898fda432696597752e8ec361b87d85c82cb258115427af006dacf7128c","license":"MIT","urls":["bzz-raw://e2c9d517f0c136d54bd00cd57959d25681d4d6273f5bbbc263afe228303772f0","dweb:/ipfs/QmReNFjXBiufByiAAzfSQ2SM5r3qeUErn46BmN3yVRvrek"]},"dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"src/wallet/KeeperWallet.sol":{"keccak256":"0x19c3f13be8d39d3d13c86248a7b697c4a97ee6c0bcdce31bd100f3d5c8cae8f2","license":"GPL-3.0-only","urls":["bzz-raw://61c50d8f5e7e44107b1174a0511bc922fec5649c8fa6ed7d211acdc0dc887ed2","dweb:/ipfs/QmeABi8DaaaJgoaDDSLDg44TpD18CpaEBtbeJ3FchjmuW1"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"src/wallet/KeeperWallet.sol:KeeperWallet"},{"slot":"1","type":"t_address","astId":156,"label":"_pendingOwner","offset":0,"contract":"src/wallet/KeeperWallet.sol:KeeperWallet"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":288,"label":"executors","offset":0,"contract":"src/wallet/KeeperWallet.sol:KeeperWallet"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","errors":{"KeeperWallet_InvalidSender(address)":[{"notice":"Thrown when the sender is neither the owner nor an approved executor"}],"KeeperWallet_ExecutionFailedNoReason()":[{"notice":"Thrown when a call fails without a revert reason"}]},"events":{"ExecutorSet(address,bool)":{"notice":"Emitted when an executor is added or removed"}},"notice":"Simple wallet that executes single or batched calls, restricted to the owner and approved executors","methods":{"executors(address)":{"notice":"Accounts authorized to execute calls through this wallet"},"setExecutor(address,bool)":{"notice":"Authorizes or deauthorizes an address to execute calls"},"execute(address,uint256,bytes)":{"notice":"Executes a single call"},"executeMulti((address,bool,bytes)[])":{"notice":"Executes multiple calls, reverting all only if a required call fails"}},"version":1},"devdoc":{"kind":"dev","title":"KeeperWallet","author":"Enso","errors":{"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"KeeperWallet_InvalidSender(address)":[{"params":{"sender":"The address that attempted the unauthorized call"}}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}]},"events":{"ExecutorSet(address,bool)":{"params":{"allowed":"Whether the executor is allowed to execute calls","executor":"The address of the executor"}}},"methods":{"owner()":{"details":"Returns the address of the current owner."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"setExecutor(address,bool)":{"params":{"allowed":"Whether the address should be allowed","executor":"The address to authorize or deauthorize"}},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer."},"execute(address,uint256,bytes)":{"params":{"data":"The calldata to send to the target contract","value":"The amount of native token to send with the call","target":"The address of the contract to call"},"returns":{"response":"The return data of the call"}},"executeMulti((address,bool,bytes)[])":{"params":{"calls":"The calls to execute"},"returns":{"results":"The success flag and return data of each call"}}},"version":1},"sourceIds":{"src/wallet/KeeperWallet.sol":{"id":3},"dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/Context.sol":{"id":2},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable.sol":{"id":0},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable2Step.sol":{"id":1}},"additionalInput":null,"stdJsonInput":{"sources":{"src/wallet/KeeperWallet.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity ^0.8.28;\n\nimport { Ownable, Ownable2Step } from \"openzeppelin-contracts/access/Ownable2Step.sol\";\n\nstruct Call {\n    address target;\n    bool required;\n    bytes data;\n}\n\nstruct Result {\n    bool success;\n    bytes returnData;\n}\n\n/// @title KeeperWallet\n/// @author Enso\n/// @notice Simple wallet that executes single or batched calls, restricted to the owner and approved executors\ncontract KeeperWallet is Ownable2Step {\n    /// @notice Accounts authorized to execute calls through this wallet\n    mapping(address executor => bool isAllowed) public executors;\n\n    /// @notice Emitted when an executor is added or removed\n    /// @param executor The address of the executor\n    /// @param allowed Whether the executor is allowed to execute calls\n    event ExecutorSet(address indexed executor, bool allowed);\n\n    /// @notice Thrown when the sender is neither the owner nor an approved executor\n    /// @param sender The address that attempted the unauthorized call\n    error KeeperWallet_InvalidSender(address sender);\n\n    /// @notice Thrown when a call fails without a revert reason\n    error KeeperWallet_ExecutionFailedNoReason();\n\n    /// @dev The owner is always allowed to execute, so funds can be moved out even with no executors set\n    modifier onlyExecutor() {\n        if (msg.sender != owner() && !executors[msg.sender]) {\n            revert KeeperWallet_InvalidSender(msg.sender);\n        }\n        _;\n    }\n\n    constructor(address owner_) Ownable(owner_) { }\n\n    receive() external payable { }\n\n    /// @notice Executes a single call\n    /// @param target The address of the contract to call\n    /// @param value The amount of native token to send with the call\n    /// @param data The calldata to send to the target contract\n    /// @return response The return data of the call\n    function execute(\n        address target,\n        uint256 value,\n        bytes calldata data\n    )\n        external\n        payable\n        onlyExecutor\n        returns (bytes memory response)\n    {\n        response = _execute(target, value, data);\n    }\n\n    /// @notice Executes multiple calls, reverting all only if a required call fails\n    /// @param calls The calls to execute\n    /// @return results The success flag and return data of each call\n    function executeMulti(Call[] calldata calls) external onlyExecutor returns (Result[] memory results) {\n        results = new Result[](calls.length);\n        for (uint256 i; i < calls.length; ++i) {\n            Call calldata call = calls[i];\n            (bool success, bytes memory returnData) = call.target.call(call.data);\n            if (!success && call.required) {\n                _revertWith(returnData);\n            }\n            results[i] = Result({ success: success, returnData: returnData });\n        }\n    }\n\n    /// @notice Authorizes or deauthorizes an address to execute calls\n    /// @param executor The address to authorize or deauthorize\n    /// @param allowed Whether the address should be allowed\n    function setExecutor(address executor, bool allowed) external onlyOwner {\n        executors[executor] = allowed;\n        emit ExecutorSet(executor, allowed);\n    }\n\n    function _execute(address target, uint256 value, bytes memory data) private returns (bytes memory response) {\n        bool success;\n        (success, response) = target.call{ value: value }(data);\n        if (!success) {\n            _revertWith(response);\n        }\n    }\n\n    function _revertWith(bytes memory response) private pure {\n        if (response.length > 0) {\n            assembly (\"memory-safe\") {\n                revert(add(0x20, response), mload(response))\n            }\n        }\n        revert KeeperWallet_ExecutionFailedNoReason();\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable2Step.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {Ownable} from \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * This extension of the {Ownable} contract includes a two-step mechanism to transfer\n * ownership, where the new owner must call {acceptOwnership} in order to replace the\n * old one. This can help prevent common mistakes, such as transfers of ownership to\n * incorrect accounts, or to contracts that are unable to interact with the\n * permission system.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     *\n     * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        if (pendingOwner() != sender) {\n            revert OwnableUnauthorizedAccount(sender);\n        }\n        _transferOwnership(sender);\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["@layerzerolabs/oapp-evm/=dependencies/devtools-0.0.1/packages/oapp-evm/","@layerzerolabs/lz-evm-protocol-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/protocol/","@layerzerolabs/lz-evm-oapp-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/oapp/","@uniswap/v4-core/=dependencies/v4-core-4.0.0/","@uniswap/v4-periphery/=dependencies/v4-periphery-4.0.0/","@uniswap/universal-router/=dependencies/universal-router-4.0.0/","@uniswap/permit2/=dependencies/permit2-4.0.0/","devtools/=dependencies/devtools-0.0.1/packages/toolbox-foundry/src/","ds-test/=dependencies/forge-std-1.9.7/dependencies/ds-test/src/","enso-weiroll/=dependencies/enso-weiroll-1.4.1/contracts/","erc4626-tests/=dependencies/@openzeppelin-contracts-5.2.0/lib/erc4626-tests/","forge-std/=dependencies/forge-std-1.9.7/src/","halmos-cheatcodes/=dependencies/@openzeppelin-contracts-5.2.0/lib/halmos-cheatcodes/src/","layerzero-v2/=dependencies/layerzero-v2-2.0.2/","openzeppelin-contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/","safe-contracts/=dependencies/safe-tools-0.2.0/lib/safe-contracts/contracts/","safe-tools/=dependencies/safe-tools-0.2.0/src/","solady/=dependencies/solady-0.1.22/src/","solmate/=dependencies/solady-0.1.22/lib/solmate/src/","@ensdomains/=dependencies/v4-core-4.0.0/node_modules/@ensdomains/","forge-gas-snapshot/=dependencies/v4-periphery-4.0.0/lib/permit2/lib/forge-gas-snapshot/src/","hardhat/=dependencies/v4-core-4.0.0/node_modules/hardhat/","permit2/=dependencies/v4-periphery-4.0.0/lib/permit2/","v4-core/=dependencies/v4-core-4.0.0/src/","v4-periphery/=dependencies/v4-periphery-4.0.0/","account-abstraction-v7/=dependencies/account-abstraction-v7-0.7.0/contracts/","@openzeppelin-contracts-5.2.0/=dependencies/@openzeppelin-contracts-5.2.0/","account-abstraction-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/","devtools-0.0.1/=dependencies/devtools-0.0.1/","enso-weiroll-1.4.1/=dependencies/enso-weiroll-1.4.1/contracts/","forge-std-1.9.7/=dependencies/forge-std-1.9.7/src/","layerzero-v2-2.0.2/=dependencies/layerzero-v2-2.0.2/","safe-smart-account-1.5.0/=dependencies/safe-smart-account-1.5.0/contracts/","safe-tools-0.2.0/=dependencies/safe-tools-0.2.0/src/","solady-0.1.22/=dependencies/solady-0.1.22/src/","v4-core-4.0.0/=dependencies/v4-core-4.0.0/src/","v4-periphery-4.0.0/=dependencies/v4-periphery-4.0.0/src/","chainlink-ccip/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/","chainlink-ccip-1.6.2/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/","chainlink-evm/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/","chainlink-evm-1.5.0/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/","@chainlink/=dependencies/chainlink-evm-1.5.0/","@openzeppelin/contracts@5.0.2/utils/introspection/IERC165.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/IERC165.sol","@openzeppelin/contracts@5.0.2/utils/introspection/ERC165Checker.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/ERC165Checker.sol","@openzeppelin/contracts@4.8.3/token/ERC20/utils/SafeERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/utils/SafeERC20.sol","@openzeppelin/contracts@4.8.3/token/ERC20/IERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/IERC20.sol","universal-router-4.0.0/=dependencies/universal-router-4.0.0/","@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/","@uniswap/v2-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v2-core/","@uniswap/v3-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v3-core/","@uniswap/v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/","account-abstraction-v7-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/","permit2-4.0.0/=dependencies/permit2-4.0.0/","shortcuts-vm-0.1.0/=dependencies/shortcuts-vm-0.1.0/src/","v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/contracts/"]}},"stdJsonOutput":{"sources":{"src/wallet/KeeperWallet.sol":{"id":3},"dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/Context.sol":{"id":2},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable.sol":{"id":0},"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable2Step.sol":{"id":1}},"contracts":{"src/wallet/KeeperWallet.sol":{"KeeperWallet":{"abi":[{"type":"constructor","inputs":[{"name":"owner_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"KeeperWallet_ExecutionFailedNoReason","type":"error","inputs":[]},{"name":"KeeperWallet_InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ExecutorSet","type":"event","inputs":[{"name":"executor","type":"address","indexed":true,"internalType":"address"},{"name":"allowed","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"execute","type":"function","inputs":[{"name":"target","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"response","type":"bytes","internalType":"bytes"}],"stateMutability":"payable"},{"name":"executeMulti","type":"function","inputs":[{"name":"calls","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"required","type":"bool","internalType":"bool"},{"name":"data","type":"bytes","internalType":"bytes"}],"internalType":"struct Call[]"}],"outputs":[{"name":"results","type":"tuple[]","components":[{"name":"success","type":"bool","internalType":"bool"},{"name":"returnData","type":"bytes","internalType":"bytes"}],"internalType":"struct Result[]"}],"stateMutability":"nonpayable"},{"name":"executors","type":"function","inputs":[{"name":"executor","type":"address","internalType":"address"}],"outputs":[{"name":"isAllowed","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setExecutor","type":"function","inputs":[{"name":"executor","type":"address","internalType":"address"},{"name":"allowed","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"KeeperWallet_ExecutionFailedNoReason\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"KeeperWallet_InvalidSender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"executor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"ExecutorSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"response\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"required\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"struct Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"executeMulti\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"struct Result[]\",\"name\":\"results\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"executor\",\"type\":\"address\"}],\"name\":\"executors\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isAllowed\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"executor\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"setExecutor\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"author\":\"Enso\",\"errors\":{\"KeeperWallet_InvalidSender(address)\":[{\"params\":{\"sender\":\"The address that attempted the unauthorized call\"}}],\"OwnableInvalidOwner(address)\":[{\"details\":\"The owner is not a valid owner account. (eg. `address(0)`)\"}],\"OwnableUnauthorizedAccount(address)\":[{\"details\":\"The caller account is not authorized to perform an operation.\"}]},\"events\":{\"ExecutorSet(address,bool)\":{\"params\":{\"allowed\":\"Whether the executor is allowed to execute calls\",\"executor\":\"The address of the executor\"}}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"execute(address,uint256,bytes)\":{\"params\":{\"data\":\"The calldata to send to the target contract\",\"target\":\"The address of the contract to call\",\"value\":\"The amount of native token to send with the call\"},\"returns\":{\"response\":\"The return data of the call\"}},\"executeMulti((address,bool,bytes)[])\":{\"params\":{\"calls\":\"The calls to execute\"},\"returns\":{\"results\":\"The success flag and return data of each call\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"setExecutor(address,bool)\":{\"params\":{\"allowed\":\"Whether the address should be allowed\",\"executor\":\"The address to authorize or deauthorize\"}},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.\"}},\"title\":\"KeeperWallet\",\"version\":1},\"userdoc\":{\"errors\":{\"KeeperWallet_ExecutionFailedNoReason()\":[{\"notice\":\"Thrown when a call fails without a revert reason\"}],\"KeeperWallet_InvalidSender(address)\":[{\"notice\":\"Thrown when the sender is neither the owner nor an approved executor\"}]},\"events\":{\"ExecutorSet(address,bool)\":{\"notice\":\"Emitted when an executor is added or removed\"}},\"kind\":\"user\",\"methods\":{\"execute(address,uint256,bytes)\":{\"notice\":\"Executes a single call\"},\"executeMulti((address,bool,bytes)[])\":{\"notice\":\"Executes multiple calls, reverting all only if a required call fails\"},\"executors(address)\":{\"notice\":\"Accounts authorized to execute calls through this wallet\"},\"setExecutor(address,bool)\":{\"notice\":\"Authorizes or deauthorizes an address to execute calls\"}},\"notice\":\"Simple wallet that executes single or batched calls, restricted to the owner and approved executors\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/wallet/KeeperWallet.sol\":\"KeeperWallet\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@chainlink/=dependencies/chainlink-evm-1.5.0/\",\":@ensdomains/=dependencies/v4-core-4.0.0/node_modules/@ensdomains/\",\":@layerzerolabs/lz-evm-oapp-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/oapp/\",\":@layerzerolabs/lz-evm-protocol-v2/=dependencies/layerzero-v2-2.0.2/packages/layerzero-v2/evm/protocol/\",\":@layerzerolabs/oapp-evm/=dependencies/devtools-0.0.1/packages/oapp-evm/\",\":@openzeppelin-contracts-5.2.0/=dependencies/@openzeppelin-contracts-5.2.0/\",\":@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/\",\":@openzeppelin/contracts@4.8.3/token/ERC20/IERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/IERC20.sol\",\":@openzeppelin/contracts@4.8.3/token/ERC20/utils/SafeERC20.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/token/ERC20/utils/SafeERC20.sol\",\":@openzeppelin/contracts@5.0.2/utils/introspection/ERC165Checker.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/ERC165Checker.sol\",\":@openzeppelin/contracts@5.0.2/utils/introspection/IERC165.sol=dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/introspection/IERC165.sol\",\":@uniswap/permit2/=dependencies/permit2-4.0.0/\",\":@uniswap/universal-router/=dependencies/universal-router-4.0.0/\",\":@uniswap/v2-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v2-core/\",\":@uniswap/v3-core/=dependencies/universal-router-4.0.0/node_modules/@uniswap/v3-core/\",\":@uniswap/v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/\",\":@uniswap/v4-core/=dependencies/v4-core-4.0.0/\",\":@uniswap/v4-periphery/=dependencies/v4-periphery-4.0.0/\",\":account-abstraction-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/\",\":account-abstraction-v7-0.7.0/=dependencies/account-abstraction-v7-0.7.0/contracts/\",\":account-abstraction-v7/=dependencies/account-abstraction-v7-0.7.0/contracts/\",\":chainlink-ccip-1.6.2/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/\",\":chainlink-ccip/=dependencies/chainlink-ccip-1.6.2/chains/evm/contracts/\",\":chainlink-evm-1.5.0/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/\",\":chainlink-evm/=dependencies/chainlink-evm-1.5.0/contracts/src/v0.8/\",\":devtools-0.0.1/=dependencies/devtools-0.0.1/\",\":devtools/=dependencies/devtools-0.0.1/packages/toolbox-foundry/src/\",\":ds-test/=dependencies/forge-std-1.9.7/dependencies/ds-test/src/\",\":enso-weiroll-1.4.1/=dependencies/enso-weiroll-1.4.1/contracts/\",\":enso-weiroll/=dependencies/enso-weiroll-1.4.1/contracts/\",\":erc4626-tests/=dependencies/@openzeppelin-contracts-5.2.0/lib/erc4626-tests/\",\":forge-gas-snapshot/=dependencies/v4-periphery-4.0.0/lib/permit2/lib/forge-gas-snapshot/src/\",\":forge-std-1.9.7/=dependencies/forge-std-1.9.7/src/\",\":forge-std/=dependencies/forge-std-1.9.7/src/\",\":halmos-cheatcodes/=dependencies/@openzeppelin-contracts-5.2.0/lib/halmos-cheatcodes/src/\",\":hardhat/=dependencies/v4-core-4.0.0/node_modules/hardhat/\",\":layerzero-v2-2.0.2/=dependencies/layerzero-v2-2.0.2/\",\":layerzero-v2/=dependencies/layerzero-v2-2.0.2/\",\":openzeppelin-contracts/=dependencies/@openzeppelin-contracts-5.2.0/contracts/\",\":permit2-4.0.0/=dependencies/permit2-4.0.0/\",\":permit2/=dependencies/v4-periphery-4.0.0/lib/permit2/\",\":safe-contracts/=dependencies/safe-tools-0.2.0/lib/safe-contracts/contracts/\",\":safe-smart-account-1.5.0/=dependencies/safe-smart-account-1.5.0/contracts/\",\":safe-tools-0.2.0/=dependencies/safe-tools-0.2.0/src/\",\":safe-tools/=dependencies/safe-tools-0.2.0/src/\",\":shortcuts-vm-0.1.0/=dependencies/shortcuts-vm-0.1.0/src/\",\":solady-0.1.22/=dependencies/solady-0.1.22/src/\",\":solady/=dependencies/solady-0.1.22/src/\",\":solmate/=dependencies/solady-0.1.22/lib/solmate/src/\",\":universal-router-4.0.0/=dependencies/universal-router-4.0.0/\",\":v3-periphery/=dependencies/universal-router-4.0.0/lib/v3-periphery/contracts/\",\":v4-core-4.0.0/=dependencies/v4-core-4.0.0/src/\",\":v4-core/=dependencies/v4-core-4.0.0/src/\",\":v4-periphery-4.0.0/=dependencies/v4-periphery-4.0.0/src/\",\":v4-periphery/=dependencies/v4-periphery-4.0.0/\"],\"viaIR\":true},\"sources\":{\"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable.sol\":{\"keccak256\":\"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6\",\"dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a\"]},\"dependencies/@openzeppelin-contracts-5.2.0/contracts/access/Ownable2Step.sol\":{\"keccak256\":\"0xdcad8898fda432696597752e8ec361b87d85c82cb258115427af006dacf7128c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e2c9d517f0c136d54bd00cd57959d25681d4d6273f5bbbc263afe228303772f0\",\"dweb:/ipfs/QmReNFjXBiufByiAAzfSQ2SM5r3qeUErn46BmN3yVRvrek\"]},\"dependencies/@openzeppelin-contracts-5.2.0/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"src/wallet/KeeperWallet.sol\":{\"keccak256\":\"0x19c3f13be8d39d3d13c86248a7b697c4a97ee6c0bcdce31bd100f3d5c8cae8f2\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://61c50d8f5e7e44107b1174a0511bc922fec5649c8fa6ed7d211acdc0dc887ed2\",\"dweb:/ipfs/QmeABi8DaaaJgoaDDSLDg44TpD18CpaEBtbeJ3FchjmuW1\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"KeeperWallet_InvalidSender(address)":[{"notice":"Thrown when the sender is neither the owner nor an approved executor"}],"KeeperWallet_ExecutionFailedNoReason()":[{"notice":"Thrown when a call fails without a revert reason"}]},"events":{"ExecutorSet(address,bool)":{"notice":"Emitted when an executor is added or removed"}},"notice":"Simple wallet that executes single or batched calls, restricted to the owner and approved executors","methods":{"executors(address)":{"notice":"Accounts authorized to execute calls through this wallet"},"setExecutor(address,bool)":{"notice":"Authorizes or deauthorizes an address to execute calls"},"execute(address,uint256,bytes)":{"notice":"Executes a single call"},"executeMulti((address,bool,bytes)[])":{"notice":"Executes multiple calls, reverting all only if a required call fails"}},"version":1},"devdoc":{"kind":"dev","title":"KeeperWallet","author":"Enso","errors":{"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"KeeperWallet_InvalidSender(address)":[{"params":{"sender":"The address that attempted the unauthorized call"}}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}]},"events":{"ExecutorSet(address,bool)":{"params":{"allowed":"Whether the executor is allowed to execute calls","executor":"The address of the executor"}}},"methods":{"owner()":{"details":"Returns the address of the current owner."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"setExecutor(address,bool)":{"params":{"allowed":"Whether the address should be allowed","executor":"The address to authorize or deauthorize"}},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner. Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer."},"execute(address,uint256,bytes)":{"params":{"data":"The calldata to send to the target contract","value":"The amount of native token to send with the call","target":"The address of the contract to call"},"returns":{"response":"The return data of the call"}},"executeMulti((address,bool,bytes)[])":{"params":{"calls":"The calls to execute"},"returns":{"results":"The success flag and return data of each call"}}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"src/wallet/KeeperWallet.sol:KeeperWallet"},{"slot":"1","type":"t_address","astId":156,"label":"_pendingOwner","offset":0,"contract":"src/wallet/KeeperWallet.sol:KeeperWallet"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":288,"label":"executors","offset":0,"contract":"src/wallet/KeeperWallet.sol:KeeperWallet"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"440:3322:3:-:0;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;1273:26:0;;1269:95;;440:3322:3;;;-1:-1:-1;;;;;;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;;3052:40:0;;-1:-1:-1;3052:40:0;440:3322:3;;;;;;;1269:95:0;1322:31;;;-1:-1:-1;1322:31:0;-1:-1:-1;1322:31:0;440:3322:3;;-1:-1:-1;1322:31:0;440:3322:3;-1:-1:-1;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;;;;-1:-1:-1;440:3322:3","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"440:3322:3:-:0;;;;;;;;;-1:-1:-1;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;:::i;:::-;1500:62:0;;:::i;:::-;440:3322:3;;;;;;;;;;1738:24:1;440:3322:3;;;1738:24:1;440:3322:3;;;;;;;;;1777:43:1;440:3322:3;1777:43:1;;440:3322:3;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;1344:10;:21;;;:47;;440:3322;1340:123;;440:3322;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;3367:33;440:3322;;;3367:33;;;;;:::i;:::-;3414:8;;3410:60;;440:3322;;;;;;;;;;;;;;;:::i;:::-;;;;3410:60;3450:8;:::i;1340:123::-;1414:38;;;440:3322;1414:38;1344:10;440:3322;;;;1414:38;1344:47;:10;;440:3322;;1370:9;440:3322;;;;;;;;1369:22;1344:47;;440:3322;;;;;;-1:-1:-1;;440:3322:3;;;;-1:-1:-1;;;;;440:3322:3;;:::i;:::-;;;;557:60;440:3322;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;735:10:2;-1:-1:-1;;;;;440:3322:3;;;2339:24:1;2335:96;;1311:13;440:3322:3;;-1:-1:-1;;;;;;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;735:10:2;440:3322:3;;;;;;;-1:-1:-1;;;;;440:3322:3;;3052:40:0;;-1:-1:-1;3052:40:0;440:3322:3;2335:96:1;2386:34;;;440:3322:3;2386:34:1;735:10:2;440:3322:3;;;;2386:34:1;440:3322:3;;;;;;-1:-1:-1;;440:3322:3;;;;1500:62:0;;:::i;:::-;2093:20:1;440:3322:3;;-1:-1:-1;;;;;;440:3322:3;;;;;;-1:-1:-1;440:3322:3;;;;;;;-1:-1:-1;;;;;;440:3322:3;3052:40:0;-1:-1:-1;;3052:40:0;440:3322:3;;;;;;;-1:-1:-1;;440:3322:3;;;;;;:::i;:::-;;;;;;;;;;;;;3162:30;1500:62:0;;;:::i;:::-;440:3322:3;;;;;;;;;;3118:9;440:3322;;;;;;;;;;;;;;;;;;;;;3162:30;440:3322;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;1344:10;:21;;;:47;;440:3322;1340:123;;440:3322;;;;:::i;:::-;;;;;-1:-1:-1;;440:3322:3;;;:::i;:::-;;;;;;;;;2478:9;;;440:3322;;;;;;;;2473:355;2507:3;2489:16;;;;;;440:3322;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;440:3322:3;;;;;;2628:9;;;440:3322;-1:-1:-1;;440:3322:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2611:27;;;;;;:::i;:::-;2656:8;;;;;:25;;;2507:3;2652:87;;;440:3322;;;;;;:::i;:::-;;;;;;2765:52;;440:3322;2752:65;;;;:::i;:::-;;;;;;:::i;:::-;;440:3322;2478:9;;2656:25;2668:13;;;;440:3322;;;;;;;;2656:25;;;2489:16;;440:3322;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;1344:47;:10;;440:3322;;1370:9;440:3322;;;;;;;;1369:22;1344:47;;440:3322;;;;;;;;;;;;;;;;;-1:-1:-1;440:3322:3;;;;;;;;-1:-1:-1;;440:3322:3;;;;:::o;:::-;;;;-1:-1:-1;;;;;440:3322:3;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;440:3322:3;;;;;-1:-1:-1;440:3322:3;;;;;;;;-1:-1:-1;;440:3322:3;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;440:3322:3;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;440:3322:3;;;;:::o;:::-;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;3482:278;440:3322;;3553:19;;3549:150;;3715:38;;;3571:1;3715:38;;3571:1;3715:38;3549:150;3588:101;;;1796:162:0;1710:6;440:3322:3;-1:-1:-1;;;;;440:3322:3;735:10:2;1855:23:0;1851:101;;1796:162::o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"acceptOwnership()","signatureHash4":"0x79ba5097","signatureHash32":"0x79ba5097e5519a381a52113cdcc59540d13f73fd9d26abc0453484a096cc96f2"},{"signature":"execute(address,uint256,bytes)","signatureHash4":"0xb61d27f6","signatureHash32":"0xb61d27f68746b0955d4867ce6e77d35c62208909547ca5c62d2a533c00d5b837"},{"signature":"executeMulti((address,bool,bytes)[])","signatureHash4":"0x041d7aed","signatureHash32":"0x041d7aed1aad54f5488022139a9375e0017119b07d1ec9adb940ce851608b00e"},{"signature":"executors(address)","signatureHash4":"0x9ac2a011","signatureHash32":"0x9ac2a0112908b4b9697e1ca7712205b2dd57140d416a3a7b94f572d6233eda45"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"pendingOwner()","signatureHash4":"0xe30c3978","signatureHash32":"0xe30c3978ddd82956a01b5cb08d17f1a2d73e636aeefb7b36f896e41d4c2aab90"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"setExecutor(address,bool)","signatureHash4":"0x1e1bff3f","signatureHash32":"0x1e1bff3f1b94435fa4c8250ea47e392cd2a5c7fa78c0799ab53c929b4eb0db9a"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"event":[{"signature":"ExecutorSet(address,bool)","signatureHash4":"0x278b0962","signatureHash32":"0x278b09622564dd3991fe7744514513d64ea2c8ed2b2b9ec1150ad964fde80a99"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"OwnershipTransferStarted(address,address)","signatureHash4":"0x38d16b8c","signatureHash32":"0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700"}],"error":[{"signature":"KeeperWallet_ExecutionFailedNoReason()","signatureHash4":"0xace5da00","signatureHash32":"0xace5da0054cbe8a413ec7d47a69acfcbbda6e95d9e98caca683a4bc7ec438077"},{"signature":"KeeperWallet_InvalidSender(address)","signatureHash4":"0xb6654263","signatureHash32":"0xb6654263790a7011ad49790936698b5af5d30782c35c537ebc5087d2974fa6e0"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0x7AcC93938D4Fb2F8bf7A8E4344f8160c81697f07"}