{"matchId":"51566557","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-09-23T15:14:29Z","creationBytecode":{"onchainBytecode":"0x608060405234801561001057600080fd5b506040516101b63803806101b68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101946022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050607b806101196000396000f3fe608060405260005463a619486e60003560e01c14156024578060601b606c5260206060f35b3660008037600080366000845af43d6000803e806040573d6000fd5b3d6000f3fea2646970667358221220e61834ebd2d8cd909d362bf67c47ef58fd665df38e6dd036ce65611101d072e964736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f7669646564000000000000000000000000ff51a5898e281db6dfc7855790607438df2ca44b","recompiledBytecode":"0x608060405234801561001057600080fd5b506040516101b63803806101b68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101946022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050607b806101196000396000f3fe608060405260005463a619486e60003560e01c14156024578060601b606c5260206060f35b3660008037600080366000845af43d6000803e806040573d6000fd5b3d6000f3fea26469706673582212203fad3a1954e0e504166e7bdcd87cc9df0c1f3f5ced6e3679e81661a81316f0f664736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f7669646564","sourceMap":"609:3613:0:-:0;;;1136:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1208:1;1186:24;;:10;:24;;;;1178:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1271:10;1259:9;;:22;;;;;;;;;;;;;;;;;;1136:152;609:3613;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212203fad3a1954e0e504166e7bdcd87cc9df0c1f3f5ced6e3679e81661a81316f0f664736f6c63430007060033","offset":351}},"transformations":[{"id":"1","type":"replace","offset":351,"reason":"cborAuxdata"},{"type":"insert","offset":438,"reason":"constructorArguments"}],"transformationValues":{"cborAuxdata":{"1":"0xa2646970667358221220e61834ebd2d8cd909d362bf67c47ef58fd665df38e6dd036ce65611101d072e964736f6c63430007060033"},"constructorArguments":"0x000000000000000000000000ff51a5898e281db6dfc7855790607438df2ca44b"}},"runtimeBytecode":{"onchainBytecode":"0x608060405260005463a619486e60003560e01c14156024578060601b606c5260206060f35b3660008037600080366000845af43d6000803e806040573d6000fd5b3d6000f3fea2646970667358221220e61834ebd2d8cd909d362bf67c47ef58fd665df38e6dd036ce65611101d072e964736f6c63430007060033","recompiledBytecode":"0x608060405260005463a619486e60003560e01c14156024578060601b606c5260206060f35b3660008037600080366000845af43d6000803e806040573d6000fd5b3d6000f3fea26469706673582212203fad3a1954e0e504166e7bdcd87cc9df0c1f3f5ced6e3679e81661a81316f0f664736f6c63430007060033","sourceMap":"609:3613:0:-:0;;;2174:1;2168:8;2400:10;2395:1;2382:15;2377:3;2373:25;2370:41;2367:2;;;3782:10;3778:2;3774:19;3768:4;3761:33;3824:4;3818;3811:18;2367:2;3875:14;3872:1;3869;3856:34;3972:1;3969;3953:14;3950:1;3938:10;3931:5;3918:56;4008:16;4005:1;4002;3987:38;4048:7;4038:2;;4085:16;4082:1;4075:27;4038:2;4139:16;4136:1;4129:27","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212203fad3a1954e0e504166e7bdcd87cc9df0c1f3f5ced6e3679e81661a81316f0f664736f6c63430007060033","offset":70}},"immutableReferences":{},"transformations":[{"id":"1","type":"replace","offset":70,"reason":"cborAuxdata"}],"transformationValues":{"cborAuxdata":{"1":"0xa2646970667358221220e61834ebd2d8cd909d362bf67c47ef58fd665df38e6dd036ce65611101d072e964736f6c63430007060033"}}},"deployment":{"transactionHash":"0x2201c12dce51edfa95ca19ed5976c84de316088e8ae31af086f39cfcf078b25a","blockNumber":"26040999","transactionIndex":"137","deployer":"0x45d11217458aEE68A4D976A8f17e2E24Fc5898A1"},"sources":{"contracts/proxies/SafeProxy.sol":{"content":"// SPDX-License-Identifier: LGPL-3.0-only\n/* solhint-disable one-contract-per-file */\npragma solidity >=0.7.0 <0.9.0;\n\n/**\n * @title Proxy Interface\n * @notice Helper interface to access the singleton address of the Proxy onchain.\n * @author Richard Meissner - @rmeissner\n */\ninterface IProxy {\n    function masterCopy() external view returns (address);\n}\n\n/**\n * @title SafeProxy\n * @notice A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.\n * @author Stefan George - <stefan@gnosis.io>\n * @author Richard Meissner - <richard@gnosis.io>\n */\ncontract SafeProxy {\n    /**\n     * @dev The singleton address to delegate all calls to.\n     *      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.\n     *      Its value can be retrieved via the {masterCopy} function.\n     */\n    address internal singleton;\n\n    /**\n     * @notice Safe proxy constructor.\n     * @dev Sets the address of the singleton contract.\n     * @param _singleton Singleton address.\n     */\n    constructor(address _singleton) {\n        require(_singleton != address(0), \"Invalid singleton address provided\");\n        singleton = _singleton;\n    }\n\n    /**\n     * @notice Delegate all calls to the `singleton` implementation, and forward all return data to the caller.\n     */\n    fallback() external payable {\n        // Note that this assembly block is **intentionally** not marked as memory-safe. First of all, it isn't memory\n        // safe to begin with, and turning this into memory-safe assembly would just make it less gas efficient.\n        // Additionally, we noticed that converting this to memory-safe assembly had no affect on optimizations of other\n        // contracts (as it always gets compiled alone in its own compilation unit anyway). Because the assembly block\n        // always halts and never returns control back to Solidity, disrespecting Solidity's memory safety invariants\n        // is not an issue.\n        /* solhint-disable no-inline-assembly */\n        assembly {\n            let _singleton := sload(0)\n            // 0xa619486e == uint32(bytes4(keccak256(\"masterCopy()\"))). Only the 4 first bytes of calldata are\n            // considered to make it 100% Solidity ABI conformant.\n            if eq(shr(224, calldataload(0)), 0xa619486e) {\n                // We mask the singleton address when handling the `masterCopy()` call to ensure that it is correctly\n                // ABI-encoded. We do this by shifting the address left by 96 bits (or 12 bytes) and then storing it in\n                // memory with a 12 byte offset from where the return data starts. Note that we **intentionally** only\n                // do this for the `masterCopy()` call, since the EVM `DELEGATECALL` opcode ignores the most-significant\n                // 12 bytes from the address, so we do not need to make sure the top bytes are cleared when proxying\n                // calls to the `singleton`. This saves us a tiny amount of gas per proxied call. Additionally, we write\n                // to the \"zero-memory\" slot instead of the scratch space, which guarantees that 12 bytes of memory\n                // preceding the singleton address are zero (which would not be guaranteed for the scratch space) [1].\n                // This ensures that the data we return has the leading 12 bytes set to zero and conforms to the\n                // Solidity ABI [2].\n                //\n                // [1]: https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html\n                // [2]: https://docs.soliditylang.org/en/v0.7.6/abi-spec.html#formal-specification-of-the-encoding\n                mstore(0x6c, shl(96, _singleton))\n                return(0x60, 0x20)\n            }\n            calldatacopy(0, 0, calldatasize())\n            let success := delegatecall(gas(), _singleton, 0, calldatasize(), 0, 0)\n            returndatacopy(0, 0, returndatasize())\n            if iszero(success) {\n                revert(0, returndatasize())\n            }\n            return(0, returndatasize())\n        }\n        /* solhint-enable no-inline-assembly */\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.7.6+commit.7338295f","compilerSettings":{"metadata":{"useLiteralContent":true},"optimizer":{"runs":200,"enabled":false}},"name":"SafeProxy","fullyQualifiedName":"contracts/proxies/SafeProxy.sol:SafeProxy"},"abi":[{"type":"constructor","inputs":[{"name":"_singleton","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"type":"fallback","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.7.6+commit.7338295f"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_singleton","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"}],"devdoc":{"author":"Stefan George - <stefan@gnosis.io>Richard Meissner - <richard@gnosis.io>","kind":"dev","methods":{"constructor":{"details":"Sets the address of the singleton contract.","params":{"_singleton":"Singleton address."}}},"stateVariables":{"singleton":{"details":"The singleton address to delegate all calls to.      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.      Its value can be retrieved via the {masterCopy} function."}},"title":"SafeProxy","version":1},"userdoc":{"kind":"user","methods":{"constructor":{"notice":"Safe proxy constructor."}},"notice":"A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.","version":1}},"settings":{"compilationTarget":{"contracts/proxies/SafeProxy.sol":"SafeProxy"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":false,"runs":200},"remappings":[]},"sources":{"contracts/proxies/SafeProxy.sol":{"content":"// SPDX-License-Identifier: LGPL-3.0-only\n/* solhint-disable one-contract-per-file */\npragma solidity >=0.7.0 <0.9.0;\n\n/**\n * @title Proxy Interface\n * @notice Helper interface to access the singleton address of the Proxy onchain.\n * @author Richard Meissner - @rmeissner\n */\ninterface IProxy {\n    function masterCopy() external view returns (address);\n}\n\n/**\n * @title SafeProxy\n * @notice A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.\n * @author Stefan George - <stefan@gnosis.io>\n * @author Richard Meissner - <richard@gnosis.io>\n */\ncontract SafeProxy {\n    /**\n     * @dev The singleton address to delegate all calls to.\n     *      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.\n     *      Its value can be retrieved via the {masterCopy} function.\n     */\n    address internal singleton;\n\n    /**\n     * @notice Safe proxy constructor.\n     * @dev Sets the address of the singleton contract.\n     * @param _singleton Singleton address.\n     */\n    constructor(address _singleton) {\n        require(_singleton != address(0), \"Invalid singleton address provided\");\n        singleton = _singleton;\n    }\n\n    /**\n     * @notice Delegate all calls to the `singleton` implementation, and forward all return data to the caller.\n     */\n    fallback() external payable {\n        // Note that this assembly block is **intentionally** not marked as memory-safe. First of all, it isn't memory\n        // safe to begin with, and turning this into memory-safe assembly would just make it less gas efficient.\n        // Additionally, we noticed that converting this to memory-safe assembly had no affect on optimizations of other\n        // contracts (as it always gets compiled alone in its own compilation unit anyway). Because the assembly block\n        // always halts and never returns control back to Solidity, disrespecting Solidity's memory safety invariants\n        // is not an issue.\n        /* solhint-disable no-inline-assembly */\n        assembly {\n            let _singleton := sload(0)\n            // 0xa619486e == uint32(bytes4(keccak256(\"masterCopy()\"))). Only the 4 first bytes of calldata are\n            // considered to make it 100% Solidity ABI conformant.\n            if eq(shr(224, calldataload(0)), 0xa619486e) {\n                // We mask the singleton address when handling the `masterCopy()` call to ensure that it is correctly\n                // ABI-encoded. We do this by shifting the address left by 96 bits (or 12 bytes) and then storing it in\n                // memory with a 12 byte offset from where the return data starts. Note that we **intentionally** only\n                // do this for the `masterCopy()` call, since the EVM `DELEGATECALL` opcode ignores the most-significant\n                // 12 bytes from the address, so we do not need to make sure the top bytes are cleared when proxying\n                // calls to the `singleton`. This saves us a tiny amount of gas per proxied call. Additionally, we write\n                // to the \"zero-memory\" slot instead of the scratch space, which guarantees that 12 bytes of memory\n                // preceding the singleton address are zero (which would not be guaranteed for the scratch space) [1].\n                // This ensures that the data we return has the leading 12 bytes set to zero and conforms to the\n                // Solidity ABI [2].\n                //\n                // [1]: https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html\n                // [2]: https://docs.soliditylang.org/en/v0.7.6/abi-spec.html#formal-specification-of-the-encoding\n                mstore(0x6c, shl(96, _singleton))\n                return(0x60, 0x20)\n            }\n            calldatacopy(0, 0, calldatasize())\n            let success := delegatecall(gas(), _singleton, 0, calldatasize(), 0, 0)\n            returndatacopy(0, 0, returndatasize())\n            if iszero(success) {\n                revert(0, returndatasize())\n            }\n            return(0, returndatasize())\n        }\n        /* solhint-enable no-inline-assembly */\n    }\n}\n","keccak256":"0xa7c17e3b41f7e05754d950ffc1e3cf74b2d50981aab65dc7f4ab9915023642ba","license":"LGPL-3.0-only"}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":12,"label":"singleton","offset":0,"contract":"contracts/proxies/SafeProxy.sol:SafeProxy"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.","methods":{"constructor":{"notice":"Safe proxy constructor."}},"version":1},"devdoc":{"kind":"dev","title":"SafeProxy","author":"Stefan George - <stefan@gnosis.io>Richard Meissner - <richard@gnosis.io>","methods":{"constructor":{"params":{"_singleton":"Singleton address."},"details":"Sets the address of the singleton contract."}},"version":1,"stateVariables":{"singleton":{"details":"The singleton address to delegate all calls to.      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.      Its value can be retrieved via the {masterCopy} function."}}},"sourceIds":{"contracts/proxies/SafeProxy.sol":{"id":0}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/proxies/SafeProxy.sol":{"content":"// SPDX-License-Identifier: LGPL-3.0-only\n/* solhint-disable one-contract-per-file */\npragma solidity >=0.7.0 <0.9.0;\n\n/**\n * @title Proxy Interface\n * @notice Helper interface to access the singleton address of the Proxy onchain.\n * @author Richard Meissner - @rmeissner\n */\ninterface IProxy {\n    function masterCopy() external view returns (address);\n}\n\n/**\n * @title SafeProxy\n * @notice A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.\n * @author Stefan George - <stefan@gnosis.io>\n * @author Richard Meissner - <richard@gnosis.io>\n */\ncontract SafeProxy {\n    /**\n     * @dev The singleton address to delegate all calls to.\n     *      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.\n     *      Its value can be retrieved via the {masterCopy} function.\n     */\n    address internal singleton;\n\n    /**\n     * @notice Safe proxy constructor.\n     * @dev Sets the address of the singleton contract.\n     * @param _singleton Singleton address.\n     */\n    constructor(address _singleton) {\n        require(_singleton != address(0), \"Invalid singleton address provided\");\n        singleton = _singleton;\n    }\n\n    /**\n     * @notice Delegate all calls to the `singleton` implementation, and forward all return data to the caller.\n     */\n    fallback() external payable {\n        // Note that this assembly block is **intentionally** not marked as memory-safe. First of all, it isn't memory\n        // safe to begin with, and turning this into memory-safe assembly would just make it less gas efficient.\n        // Additionally, we noticed that converting this to memory-safe assembly had no affect on optimizations of other\n        // contracts (as it always gets compiled alone in its own compilation unit anyway). Because the assembly block\n        // always halts and never returns control back to Solidity, disrespecting Solidity's memory safety invariants\n        // is not an issue.\n        /* solhint-disable no-inline-assembly */\n        assembly {\n            let _singleton := sload(0)\n            // 0xa619486e == uint32(bytes4(keccak256(\"masterCopy()\"))). Only the 4 first bytes of calldata are\n            // considered to make it 100% Solidity ABI conformant.\n            if eq(shr(224, calldataload(0)), 0xa619486e) {\n                // We mask the singleton address when handling the `masterCopy()` call to ensure that it is correctly\n                // ABI-encoded. We do this by shifting the address left by 96 bits (or 12 bytes) and then storing it in\n                // memory with a 12 byte offset from where the return data starts. Note that we **intentionally** only\n                // do this for the `masterCopy()` call, since the EVM `DELEGATECALL` opcode ignores the most-significant\n                // 12 bytes from the address, so we do not need to make sure the top bytes are cleared when proxying\n                // calls to the `singleton`. This saves us a tiny amount of gas per proxied call. Additionally, we write\n                // to the \"zero-memory\" slot instead of the scratch space, which guarantees that 12 bytes of memory\n                // preceding the singleton address are zero (which would not be guaranteed for the scratch space) [1].\n                // This ensures that the data we return has the leading 12 bytes set to zero and conforms to the\n                // Solidity ABI [2].\n                //\n                // [1]: https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html\n                // [2]: https://docs.soliditylang.org/en/v0.7.6/abi-spec.html#formal-specification-of-the-encoding\n                mstore(0x6c, shl(96, _singleton))\n                return(0x60, 0x20)\n            }\n            calldatacopy(0, 0, calldatasize())\n            let success := delegatecall(gas(), _singleton, 0, calldatasize(), 0, 0)\n            returndatacopy(0, 0, returndatasize())\n            if iszero(success) {\n                revert(0, returndatasize())\n            }\n            return(0, returndatasize())\n        }\n        /* solhint-enable no-inline-assembly */\n    }\n}\n"}},"language":"Solidity","settings":{"metadata":{"useLiteralContent":true},"optimizer":{"runs":200,"enabled":false}}},"stdJsonOutput":{"sources":{"contracts/proxies/SafeProxy.sol":{"id":0}},"contracts":{"contracts/proxies/SafeProxy.sol":{"SafeProxy":{"abi":[{"type":"constructor","inputs":[{"name":"_singleton","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"type":"fallback","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.7.6+commit.7338295f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_singleton\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"}],\"devdoc\":{\"author\":\"Stefan George - <stefan@gnosis.io>Richard Meissner - <richard@gnosis.io>\",\"kind\":\"dev\",\"methods\":{\"constructor\":{\"details\":\"Sets the address of the singleton contract.\",\"params\":{\"_singleton\":\"Singleton address.\"}}},\"stateVariables\":{\"singleton\":{\"details\":\"The singleton address to delegate all calls to.      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.      Its value can be retrieved via the {masterCopy} function.\"}},\"title\":\"SafeProxy\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"constructor\":{\"notice\":\"Safe proxy constructor.\"}},\"notice\":\"A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/proxies/SafeProxy.sol\":\"SafeProxy\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/proxies/SafeProxy.sol\":{\"content\":\"// SPDX-License-Identifier: LGPL-3.0-only\\n/* solhint-disable one-contract-per-file */\\npragma solidity >=0.7.0 <0.9.0;\\n\\n/**\\n * @title Proxy Interface\\n * @notice Helper interface to access the singleton address of the Proxy onchain.\\n * @author Richard Meissner - @rmeissner\\n */\\ninterface IProxy {\\n    function masterCopy() external view returns (address);\\n}\\n\\n/**\\n * @title SafeProxy\\n * @notice A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.\\n * @author Stefan George - <stefan@gnosis.io>\\n * @author Richard Meissner - <richard@gnosis.io>\\n */\\ncontract SafeProxy {\\n    /**\\n     * @dev The singleton address to delegate all calls to.\\n     *      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.\\n     *      Its value can be retrieved via the {masterCopy} function.\\n     */\\n    address internal singleton;\\n\\n    /**\\n     * @notice Safe proxy constructor.\\n     * @dev Sets the address of the singleton contract.\\n     * @param _singleton Singleton address.\\n     */\\n    constructor(address _singleton) {\\n        require(_singleton != address(0), \\\"Invalid singleton address provided\\\");\\n        singleton = _singleton;\\n    }\\n\\n    /**\\n     * @notice Delegate all calls to the `singleton` implementation, and forward all return data to the caller.\\n     */\\n    fallback() external payable {\\n        // Note that this assembly block is **intentionally** not marked as memory-safe. First of all, it isn't memory\\n        // safe to begin with, and turning this into memory-safe assembly would just make it less gas efficient.\\n        // Additionally, we noticed that converting this to memory-safe assembly had no affect on optimizations of other\\n        // contracts (as it always gets compiled alone in its own compilation unit anyway). Because the assembly block\\n        // always halts and never returns control back to Solidity, disrespecting Solidity's memory safety invariants\\n        // is not an issue.\\n        /* solhint-disable no-inline-assembly */\\n        assembly {\\n            let _singleton := sload(0)\\n            // 0xa619486e == uint32(bytes4(keccak256(\\\"masterCopy()\\\"))). Only the 4 first bytes of calldata are\\n            // considered to make it 100% Solidity ABI conformant.\\n            if eq(shr(224, calldataload(0)), 0xa619486e) {\\n                // We mask the singleton address when handling the `masterCopy()` call to ensure that it is correctly\\n                // ABI-encoded. We do this by shifting the address left by 96 bits (or 12 bytes) and then storing it in\\n                // memory with a 12 byte offset from where the return data starts. Note that we **intentionally** only\\n                // do this for the `masterCopy()` call, since the EVM `DELEGATECALL` opcode ignores the most-significant\\n                // 12 bytes from the address, so we do not need to make sure the top bytes are cleared when proxying\\n                // calls to the `singleton`. This saves us a tiny amount of gas per proxied call. Additionally, we write\\n                // to the \\\"zero-memory\\\" slot instead of the scratch space, which guarantees that 12 bytes of memory\\n                // preceding the singleton address are zero (which would not be guaranteed for the scratch space) [1].\\n                // This ensures that the data we return has the leading 12 bytes set to zero and conforms to the\\n                // Solidity ABI [2].\\n                //\\n                // [1]: https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html\\n                // [2]: https://docs.soliditylang.org/en/v0.7.6/abi-spec.html#formal-specification-of-the-encoding\\n                mstore(0x6c, shl(96, _singleton))\\n                return(0x60, 0x20)\\n            }\\n            calldatacopy(0, 0, calldatasize())\\n            let success := delegatecall(gas(), _singleton, 0, calldatasize(), 0, 0)\\n            returndatacopy(0, 0, returndatasize())\\n            if iszero(success) {\\n                revert(0, returndatasize())\\n            }\\n            return(0, returndatasize())\\n        }\\n        /* solhint-enable no-inline-assembly */\\n    }\\n}\\n\",\"keccak256\":\"0xa7c17e3b41f7e05754d950ffc1e3cf74b2d50981aab65dc7f4ab9915023642ba\",\"license\":\"LGPL-3.0-only\"}},\"version\":1}","userdoc":{"kind":"user","notice":"A generic proxy contract that allows the execution of all transactions by applying the code of a singleton contract.","methods":{"constructor":{"notice":"Safe proxy constructor."}},"version":1},"devdoc":{"kind":"dev","title":"SafeProxy","author":"Stefan George - <stefan@gnosis.io>Richard Meissner - <richard@gnosis.io>","methods":{"constructor":{"params":{"_singleton":"Singleton address."},"details":"Sets the address of the singleton contract."}},"version":1,"stateVariables":{"singleton":{"details":"The singleton address to delegate all calls to.      The singleton always needs to be first declared variable, in order to ensure that it is at the same location in the contracts to which calls are delegated.      Its value can be retrieved via the {masterCopy} function."}}},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":12,"label":"singleton","offset":0,"contract":"contracts/proxies/SafeProxy.sol:SafeProxy"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"608060405234801561001057600080fd5b506040516101b63803806101b68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101946022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050607b806101196000396000f3fe608060405260005463a619486e60003560e01c14156024578060601b606c5260206060f35b3660008037600080366000845af43d6000803e806040573d6000fd5b3d6000f3fea26469706673582212203fad3a1954e0e504166e7bdcd87cc9df0c1f3f5ced6e3679e81661a81316f0f664736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f7669646564","sourceMap":"609:3613:0:-:0;;;1136:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1208:1;1186:24;;:10;:24;;;;1178:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1271:10;1259:9;;:22;;;;;;;;;;;;;;;;;;1136:152;609:3613;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"608060405260005463a619486e60003560e01c14156024578060601b606c5260206060f35b3660008037600080366000845af43d6000803e806040573d6000fd5b3d6000f3fea26469706673582212203fad3a1954e0e504166e7bdcd87cc9df0c1f3f5ced6e3679e81661a81316f0f664736f6c63430007060033","sourceMap":"609:3613:0:-:0;;;2174:1;2168:8;2400:10;2395:1;2382:15;2377:3;2373:25;2370:41;2367:2;;;3782:10;3778:2;3774:19;3768:4;3761:33;3824:4;3818;3811:18;2367:2;3875:14;3872:1;3869;3856:34;3972:1;3969;3953:14;3950:1;3938:10;3931:5;3918:56;4008:16;4005:1;4002;3987:38;4048:7;4038:2;;4085:16;4082:1;4075:27;4038:2;4139:16;4136:1;4129:27","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[],"event":[],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0x3033D2A52E69bfe4Ae439F61Ca724ca978a1E871"}