{"matchId":"2100295","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2024-08-08T14:34:59Z","creationBytecode":{"onchainBytecode":"0x60806001600160401b03601f610b5938819003918201601f1916840191838311858410176105b75780859260409485528339810103126105f15761004e602061004784610633565b9301610633565b7f5e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c980546001600160a01b039485166001600160a01b03198216811790925591939091167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a36100bd610614565b91600183525f5b602081106105cb57506100d5610614565b60018152602036818301376307e4c70760e21b6100f182610647565b526100fa6105f5565b6001600160a01b0390921682525f6020830152604082015261011b83610647565b5261012582610647565b506040519060208201908111828210176105b7576040525f808252825b805182101561045c5760206101578383610668565b5101516003811015610448578061028f57506001600160a01b0361017b8383610668565b515116604061018a8484610668565b51015180511561027d57811561026b576001600160a01b0382165f9081525f80516020610b3983398151915260205260409020546001600160601b039390841690811561025d575b5f915b8351831015610249576001600160e01b03196101f18486610668565b51165f8181525f80516020610af983398151915260205260409020549091906001600160a01b03166102375760018161022d888a948496610994565b01169201916101d5565b60405163a023275d60e01b8152600490fd5b50959492505050600191505b019091610142565b6102668461091b565b6101d2565b604051636347641d60e11b8152600490fd5b6040516307bc559560e41b8152600490fd5b6001810361038f57506001600160a01b036102aa8383610668565b5151169260406102ba8484610668565b51015180511561027d57841561026b576001600160a01b0385165f9081525f80516020610b3983398151915260205260409020546001600160601b0393908416908115610381575b5f915b8351831015610372576001600160e01b03196103218486610668565b51165f8181525f80516020610af983398151915260205260409020546001600160a01b03169089821461023757826103688b6001958461036388968e986106c0565b610994565b0116920191610305565b50955050509160019150610255565b61038a8761091b565b610302565b600203610436576001600160a01b036103a88383610668565b5151169060406103b88483610668565b5101519182511561027d57610424575f5b8251811015610418576001906104126001600160e01b03196103eb8387610668565b5116805f525f80516020610af9833981519152602052838060a01b0360405f2054166106c0565b016103c9565b50929160019150610255565b604051633ce4ef9160e11b8152600490fd5b60405163e548e6b560e01b8152600490fd5b634e487b7160e01b5f52602160045260245ffd5b905060405190606082016060835281518091526080830190602060808260051b8601019301915f905b82821061052157505050505f6020830152818103604083015282518082525f5b81811061050c57508282825f602080957f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6739897010152601f801991011601030190a1516104fa5760405160b49081610a458239f35b6040516304c08b4360e51b8152600490fd5b806020809287010151828286010152016104a5565b858503607f19018152835180516001600160a01b03168652602081015194959394929391929060038210156104485760409160208401520151906060604082015260206080835192836060820152019201905f905b80821061059457505050602080600192960192019201909291610485565b82516001600160e01b031916845260209384019390920191600190910190610576565b634e487b7160e01b5f52604160045260245ffd5b6020906105d66105f5565b5f81525f8382015260606040820152828287010152016100c4565b5f80fd5b60405190606082016001600160401b038111838210176105b757604052565b60408051919082016001600160401b038111838210176105b757604052565b51906001600160a01b03821682036105f157565b8051156106545760200190565b634e487b7160e01b5f52603260045260245ffd5b80518210156106545760209160051b010190565b9190918054831015610654575f52601c60205f208360031c019260021b1690565b5f80516020610b198339815191528054821015610654575f5260205f2001905f90565b6001600160a01b03908116918215610909573083146108f75763ffffffff60e01b809116805f525f80516020610af983398151915293602090858252604093845f205460a01c96825f525f80516020610b3983398151915294858552865f2054925f19998a850194851161085857889187898888850361086c575b9450505050505f52858552865f20805480156107f4578a019061075e828261067c565b63ffffffff82549160031b1b19169055555f5283525f8581205515610786575b505050505050565b5f80516020610b1983398151915294855487810190811161085857825f52848452816001875f20015491808303610808575b50505085549586156107f4575f9760019701916107d48361069d565b909182549160031b1b1916905555855252822001555f808080808061077e565b634e487b7160e01b5f52603160045260245ffd5b6108119061069d565b90549060031b1c16610844816108268461069d565b90919060018060a01b038084549260031b9316831b921b1916179055565b5f528484526001865f2001555f81816107b8565b634e487b7160e01b5f52601160045260245ffd5b6108a1856108ec976108be94845f5280875261088a8d835f2061067c565b90549060031b1c60e01b9687955f52525f2061067c565b90919063ffffffff83549160031b9260e01c831b921b1916179055565b165f90815284885289902080546001600160a01b031660a09290921b6001600160a01b031916919091179055565b865f8087898861073b565b60405163c3c5ec3760e01b8152600490fd5b604051631535ac5f60e31b8152600490fd5b803b15610983575f80516020610b1983398151915280546001600160a01b0383165f9081525f80516020610b39833981519152602052604090206001018190559190680100000000000000008310156105b757826108269160016109819501905561069d565b565b6040516271a80360e91b8152600490fd5b6001600160e01b031981165f8181525f80516020610af98339815191526020819052604090912080546001600160a01b031660a09590951b6001600160a01b0319169490941790935590926001600160a01b03165f8181525f80516020610b39833981519152602052604090208054919490680100000000000000008310156105b757826108a1916001610a2a9501815561067c565b5f5260205260405f209060018060a01b031982541617905556fe60806040523615607c575f80356001600160e01b03191681527f5e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c560205260409020546001600160a01b03168015606b575f8091368280378136915af43d5f803e156067573d5ff35b3d5ffd5b631535ac5f60e31b60805260046080fd5b00fea2646970667358221220930a620c99a7318ca205c3fd7de61f4589313a6f74e2a079ea59f03d58767f3464736f6c634300081700335e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c55e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c75e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c6000000000000000000000000ee7b429ea01f76102f053213463d4e95d5d24ae800000000000000000000000057fe1cbb349c2bf575ac201c36a61a9d821e5e95","recompiledBytecode":"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","sourceMap":"220:2178:0:-:0;-1:-1:-1;;;;;220:2178:0;;;;;;;;;-1:-1:-1;;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;2390:16:4;220:2178:0;;-1:-1:-1;;;;;220:2178:0;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;2390:16:4;;220:2178:0;;;2459:46:4;-1:-1:-1;;2459:46:4;220:2178:0;;:::i;:::-;;513:1;220:2178;;-1:-1:-1;220:2178:0;;;;;;;;;:::i;:::-;513:1;220:2178;;;;;;;;-1:-1:-1;;;586:54:0;;;:::i;:::-;220:2178;;;:::i;:::-;-1:-1:-1;;;;;220:2178:0;;;;;-1:-1:-1;220:2178:0;659:178;;220:2178;;659:178;;220:2178;650:187;;;:::i;:::-;;;;;:::i;:::-;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;3095:18:4;220:2178:0;;3115:31:4;;;;;220:2178:0;3199:23:4;;;;:::i;:::-;;:30;220:2178:0;;;;;;;3247:40:4;;;-1:-1:-1;;;;;;3320:23:4;;;;:::i;:::-;;220:2178:0;;;3358:23:4;;;;:::i;:::-;;:41;;220:2178:0;;4154:30:4;4150:87;;883:18:5;;4300:94:4;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;4570:21:4;;4566:79;;3243:613;-1:-1:-1;4654:540:4;4659:21;220:2178:0;;4682:41:4;;;;;-1:-1:-1;;;;;;4758:33:4;;;;:::i;:::-;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;-1:-1:-1;;;;;220:2178:0;4897:108:4;;513:1:0;5062:13:4;;;;;;;;:::i;:::-;220:2178:0;;;;4659:21:4;;;4897:108;220:2178:0;;-1:-1:-1;;;4967:23:4;;2390:16;;4967:23;4682:41;;;;;;;;513:1:0;4682:41:4;;3243:613;220:2178:0;3095:18:4;;;;4566:79;4620:13;;;:::i;:::-;4566:79;;4300:94;220:2178:0;;-1:-1:-1;;;4363:20:4;;2390:16;;4363:20;4150:87;220:2178:0;;-1:-1:-1;;;4207:19:4;;2390:16;;4207:19;3243:613;513:1:0;3425:44:4;;513:1:0;;-1:-1:-1;;;;;;3506:23:4;;;;:::i;:::-;;220:2178:0;;3544:23:4;220:2178:0;3544:23:4;;;;:::i;:::-;;:41;;220:2178:0;;5314:30:4;5310:87;;883:18:5;;5460:94:4;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;5730:21:4;;5726:79;;3421:435;-1:-1:-1;5814:592:4;5819:21;220:2178:0;;5842:41:4;;;;;-1:-1:-1;;;;;;5918:33:4;;;;:::i;:::-;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;220:2178:0;;6061:32:4;;;6057:101;;6207:8;6274:13;6207:8;513:1:0;6207:8:4;;;;;;;;:::i;:::-;6274:13;:::i;:::-;220:2178:0;;;;5819:21:4;;;5842:41;;;;;;;513:1:0;5842:41:4;;3243:613;;5726:79;5780:13;;;:::i;:::-;5726:79;;3421:435;3621:33;3611:43;3621:33;;-1:-1:-1;;;;;3690:23:4;;;;:::i;:::-;;220:2178:0;;3728:23:4;220:2178:0;3728:23:4;;;;:::i;:::-;;:41;;220:2178:0;;;6525:30:4;6521:87;;6736:98;;-1:-1:-1;6848:21:4;220:2178:0;;6871:41:4;;;;;513:1:0;;7122:8:4;-1:-1:-1;;;;;;6947:33:4;220:2178:0;6947:33:4;;:::i;:::-;220:2178:0;;;-1:-1:-1;220:2178:0;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;-1:-1:-1;220:2178:0;;;7122:8:4;:::i;:::-;220:2178:0;6848:21:4;;6871:41;;;;513:1:0;6871:41:4;;3243:613;;6736:98;220:2178:0;;-1:-1:-1;;;6800:23:4;;2390:16;;6800:23;3607:249;220:2178:0;;-1:-1:-1;;;3816:25:4;;2390:16;;3816:25;220:2178:0;;;;-1:-1:-1;220:2178:0;;2390:16:4;220:2178:0;;-1:-1:-1;220:2178:0;3115:31:4;;;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;-1:-1:-1;220:2178:0;;;3948:41:4;220:2178:0;;;;;;;;;;;;3948:41:4;;;;220:2178:0;10271:96:4;;220:2178:0;;;;;;;;;10271:96:4;220:2178:0;;-1:-1:-1;;;10323:29:4;;2390:16;;10323:29;220:2178:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;220:2178:0;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;;513:1;220:2178;;;;;;;;;;;;;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;;;;;;513:1;220:2178;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;-1:-1:-1;220:2178:0;;;;;;:::i;:::-;-1:-1:-1;220:2178:0;;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;220:2178:0;;;;;;:::o;:::-;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;-1:-1:-1;220:2178:0;;;-1:-1:-1;220:2178:0;;;;;;;;;;:::o;:::-;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;-1:-1:-1;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;220:2178:0;:::o;7914:2215:4:-;-1:-1:-1;;;;;220:2178:0;;;;883:18:5;;8025:96:4;;8236:4;8211:30;;8207:89;;220:2178:0;;;;;;;899:1:5;220:2178:0;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;899:1:5;220:2178:0;;;;;;899:1:5;220:2178:0;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;899:1:5;220:2178:0;;;;;;;;;;;;;;8663:40:4;;;;;;;;8659:387;;7914:2215;220:2178:0;;;;;;899:1:5;220:2178:0;;;;;899:1:5;220:2178:0;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;899:1:5;220:2178:0;;;899:1:5;220:2178:0;;;;9307:25:4;9303:820;;7914:2215;;;;;;;:::o;9303:820::-;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;;;;899:1:5;220:2178:0;;;;;8512:25:4;220:2178:0;899:1:5;220:2178:0;9547:61:4;220:2178:0;9626:48:4;;;;9622:338;;9303:820;220:2178:0;;;;;;;;;;899:1:5;220:2178:0;8512:25:4;220:2178:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;10017:95:4;220:2178:0;9303:820:4;;;;;;;;220:2178:0;;;;899:1:5;220:2178:0;;;;;899:1:5;220:2178:0;9622:338:4;9721:43;;;:::i;:::-;220:2178:0;;;;;;;9782:58:4;:39;;;;:::i;:::-;:58;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;9782:58:4;899:1:5;220:2178:0;;;;8512:25:4;220:2178:0;899:1:5;220:2178:0;9858:64:4;220:2178:0;9622:338:4;;;;;220:2178:0;;;;899:1:5;220:2178:0;;;;;899:1:5;220:2178:0;8659:387:4;8835:76;220:2178:0;8940:95:4;220:2178:0;8835:91:4;220:2178:0;;899:1:5;220:2178:0;;;;8741:80:4;220:2178:0;;899:1:5;220:2178:0;8741:80:4;:::i;:::-;220:2178:0;;;;;;;;;;;899:1:5;220:2178:0;;899:1:5;220:2178:0;8835:76:4;:::i;:::-;:91;220:2178:0;;;;;;;;;;;;;;;;;;;;;8835:91:4;220:2178:0;899:1:5;220:2178:0;;;;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;;8940:95:4;8659:387;;;;;;;;8207:89;220:2178:0;;-1:-1:-1;;;8264:21:4;;;;;8025:96;220:2178:0;;-1:-1:-1;;;8088:22:4;;;;;7225:276;11176:71;;11260:17;11256:76;;-1:-1:-1;;;;;;;;;;;220:2178:0;;-1:-1:-1;;;;;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;7359:61:4;220:2178:0;;;;;;;;;;;;;;7359:25:4;220:2178:0;;;;;;:::i;:::-;7225:276:4:o;11256:76::-;220:2178:0;;-1:-1:-1;;;11300:21:4;;;;;7507:401;-1:-1:-1;;;;;;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;;7507:401:4;;-1:-1:-1;;;;;220:2178:0;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;;;;;;;;;;;7748:25:4;220:2178:0;;;;;;:::i;:::-;-1:-1:-1;220:2178:0;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;7507:401:4:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220930a620c99a7318ca205c3fd7de61f4589313a6f74e2a079ea59f03d58767f3464736f6c63430008170033","offset":2756}},"transformations":[{"type":"insert","offset":2905,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000ee7b429ea01f76102f053213463d4e95d5d24ae800000000000000000000000057fe1cbb349c2bf575ac201c36a61a9d821e5e95"}},"runtimeBytecode":{"onchainBytecode":"0x60806040523615607c575f80356001600160e01b03191681527f5e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c560205260409020546001600160a01b03168015606b575f8091368280378136915af43d5f803e156067573d5ff35b3d5ffd5b631535ac5f60e31b60805260046080fd5b00fea2646970667358221220930a620c99a7318ca205c3fd7de61f4589313a6f74e2a079ea59f03d58767f3464736f6c63430008170033","recompiledBytecode":"0x60806040523615607c575f80356001600160e01b03191681527f5e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c560205260409020546001600160a01b03168015606b575f8091368280378136915af43d5f803e156067573d5ff35b3d5ffd5b631535ac5f60e31b60805260046080fd5b00fea2646970667358221220930a620c99a7318ca205c3fd7de61f4589313a6f74e2a079ea59f03d58767f3464736f6c63430008170033","sourceMap":"220:2178:0:-:0;;;;;;;-1:-1:-1;1463:7:0;;-1:-1:-1;;;;;;1463:7:0;400:44:4;;;;;220:2178:0;400:44:4;;;-1:-1:-1;;;;;400:44:4;1499:19:0;;1495:90;;-1:-1:-1;220:2178:0;;;1740:537;;;220:2178;;1740:537;;;;-1:-1:-1;1740:537:0;;;;;;-1:-1:-1;1740:537:0;;;-1:-1:-1;1740:537:0;1495:90;1541:33;;;220:2178;1541:33;;220:2178;1541:33;220:2178;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220930a620c99a7318ca205c3fd7de61f4589313a6f74e2a079ea59f03d58767f3464736f6c63430008170033","offset":127}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x4262d8b1a463ff47cadc9f63c43f42dc188bb0c52c9596fe6c060ea3f66962ef","blockNumber":"19958398","transactionIndex":"37","deployer":"0xEe7b429Ea01F76102f053213463D4e95D5D24AE8"},"sources":{"src/Diamond.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport {LibDiamond} from \"./Libraries/LibDiamond.sol\";\nimport {IDiamondCut} from \"./Interfaces/IDiamondCut.sol\";\nimport {LibUtil} from \"./Libraries/LibUtil.sol\";\n\ncontract Diamond {\n    constructor(address _contractOwner, address _diamondCutFacet) payable {\n        LibDiamond.setContractOwner(_contractOwner);\n\n        // Add the diamondCut external function from the diamondCutFacet\n        IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](1);\n        bytes4[] memory functionSelectors = new bytes4[](1);\n        functionSelectors[0] = IDiamondCut.diamondCut.selector;\n        cut[0] = IDiamondCut.FacetCut({\n            facetAddress: _diamondCutFacet,\n            action: IDiamondCut.FacetCutAction.Add,\n            functionSelectors: functionSelectors\n        });\n        LibDiamond.diamondCut(cut, address(0), \"\");\n    }\n\n    // Find facet for function that is called and execute the\n    // function if a facet is found and return any value.\n    // solhint-disable-next-line no-complex-fallback\n    fallback() external payable {\n        LibDiamond.DiamondStorage storage ds;\n        bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\n\n        // get diamond storage\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            ds.slot := position\n        }\n\n        // get facet from function selector\n        address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\n\n        if (facet == address(0)) {\n            revert LibDiamond.FunctionDoesNotExist();\n        }\n\n        // Execute external function from facet using delegatecall and return any value.\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            // copy function selector and any arguments\n            calldatacopy(0, 0, calldatasize())\n            // execute function call using the facet\n            let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\n            // get any return value\n            returndatacopy(0, 0, returndatasize())\n            // return any return value or error back to the caller\n            switch result\n            case 0 { revert(0, returndatasize()) }\n            default { return(0, returndatasize()) }\n        }\n    }\n\n    // Able to receive ether\n    // solhint-disable-next-line no-empty-blocks\n    receive() external payable {}\n}\n"},"src/Libraries/LibUtil.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport \"./LibBytes.sol\";\n\nlibrary LibUtil {\n    using LibBytes for bytes;\n\n    function getRevertMsg(bytes memory _res) internal pure returns (string memory) {\n        // If the _res length is less than 68, then the transaction failed silently (without a revert message)\n        if (_res.length < 68) return \"Transaction reverted silently\";\n        bytes memory revertData = _res.slice(4, _res.length - 4); // Remove the selector which is the first 4 bytes\n        return abi.decode(revertData, (string)); // All that remains is the revert string\n    }\n\n    /// @notice Determines whether the given address is the zero address\n    /// @param addr The address to verify\n    /// @return Boolean indicating if the address is the zero address\n    function isZeroAddress(address addr) internal pure returns (bool) {\n        return addr == address(0);\n    }\n}\n"},"src/Libraries/LibBytes.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nlibrary LibBytes {\n    // solhint-disable no-inline-assembly\n\n    // LibBytes specific errors\n    error SliceOverflow();\n    error SliceOutOfBounds();\n    error AddressOutOfBounds();\n\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n\n    // -------------------------\n\n    function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {\n        unchecked {\n            if (_length + 31 < _length) revert SliceOverflow();\n            if (_bytes.length < _start + _length) revert SliceOutOfBounds();\n            if (_start + _length < _start) revert SliceOverflow();\n        }\n\n        bytes memory tempBytes;\n\n        assembly {\n            switch iszero(_length)\n            case 0 {\n                // Get a location of some free memory and store it in tempBytes as\n                // Solidity does for memory variables.\n                tempBytes := mload(0x40)\n\n                // The first word of the slice result is potentially a partial\n                // word read from the original array. To read it, we calculate\n                // the length of that partial word and start copying that many\n                // bytes into the array. The first word we copy will start with\n                // data we don't care about, but the last `lengthmod` bytes will\n                // land at the beginning of the contents of the new array. When\n                // we're done copying, we overwrite the full first word with\n                // the actual length of the slice.\n                let lengthmod := and(_length, 31)\n\n                // The multiplication in the next line is necessary\n                // because when slicing multiples of 32 bytes (lengthmod == 0)\n                // the following copy loop was copying the origin's length\n                // and then ending prematurely not copying everything it should.\n                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))\n                let end := add(mc, _length)\n\n                for {\n                    // The multiplication in the next line has the same exact purpose\n                    // as the one above.\n                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)\n                } lt(mc, end) {\n                    mc := add(mc, 0x20)\n                    cc := add(cc, 0x20)\n                } { mstore(mc, mload(cc)) }\n\n                mstore(tempBytes, _length)\n\n                //update free-memory pointer\n                //allocating the array padded to 32 bytes like the compiler does now\n                mstore(0x40, and(add(mc, 31), not(31)))\n            }\n            //if we want a zero-length slice let's just return a zero-length array\n            default {\n                tempBytes := mload(0x40)\n                //zero out the 32 bytes slice we are about to return\n                //we need to do it because Solidity does not garbage collect\n                mstore(tempBytes, 0)\n\n                mstore(0x40, add(tempBytes, 0x20))\n            }\n        }\n\n        return tempBytes;\n    }\n\n    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {\n        if (_bytes.length < _start + 20) {\n            revert AddressOutOfBounds();\n        }\n        address tempAddress;\n\n        assembly {\n            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)\n        }\n\n        return tempAddress;\n    }\n\n    /// Copied from OpenZeppelin's `Strings.sol` utility library.\n    /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/8335676b0e99944eef6a742e16dcd9ff6e68e609/contracts/utils/Strings.sol\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n}\n"},"src/Errors/GenericErrors.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nerror OnlyContractOwner();\n"},"src/Libraries/LibDiamond.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport {IDiamondCut} from \"../Interfaces/IDiamondCut.sol\";\nimport {LibUtil} from \"../Libraries/LibUtil.sol\";\nimport {OnlyContractOwner} from \"../Errors/GenericErrors.sol\";\n\n/// Implementation of EIP-2535 Diamond Standard\n/// https://eips.ethereum.org/EIPS/eip-2535\nlibrary LibDiamond {\n    bytes32 internal constant DIAMOND_STORAGE_POSITION = keccak256(\"com.binance.w3w.diamond.storage\");\n\n    // Diamond specific errors\n    error IncorrectFacetCutAction();\n    error NoSelectorsInFace();\n    error FunctionAlreadyExists();\n    error FacetAddressIsZero();\n    error FacetAddressIsNotZero();\n    error FacetContainsNoCode();\n    error FunctionDoesNotExist();\n    error FunctionIsImmutable();\n    error InitZeroButCalldataNotEmpty();\n    error CalldataEmptyButInitNotZero();\n    error InitReverted();\n    // ----------------\n\n    struct FacetAddressAndPosition {\n        address facetAddress;\n        uint96 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\n    }\n\n    struct FacetFunctionSelectors {\n        bytes4[] functionSelectors;\n        uint256 facetAddressPosition; // position of facetAddress in facetAddresses array\n    }\n\n    struct DiamondStorage {\n        // maps function selector to the facet address and\n        // the position of the selector in the facetFunctionSelectors.selectors array\n        mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\n        // maps facet addresses to function selectors\n        mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\n        // facet addresses\n        address[] facetAddresses;\n        // Used to query if a contract implements an interface.\n        // Used to implement ERC-165.\n        mapping(bytes4 => bool) supportedInterfaces;\n        // owner of the contract\n        address contractOwner;\n    }\n\n    function diamondStorage() internal pure returns (DiamondStorage storage ds) {\n        bytes32 position = DIAMOND_STORAGE_POSITION;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            ds.slot := position\n        }\n    }\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    function setContractOwner(address _newOwner) internal {\n        DiamondStorage storage ds = diamondStorage();\n        address previousOwner = ds.contractOwner;\n        ds.contractOwner = _newOwner;\n        emit OwnershipTransferred(previousOwner, _newOwner);\n    }\n\n    function contractOwner() internal view returns (address contractOwner_) {\n        contractOwner_ = diamondStorage().contractOwner;\n    }\n\n    function enforceIsContractOwner() internal view {\n        if (msg.sender != diamondStorage().contractOwner) {\n            revert OnlyContractOwner();\n        }\n    }\n\n    event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\n\n    // Internal function version of diamondCut\n    function diamondCut(IDiamondCut.FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\n        for (uint256 facetIndex; facetIndex < _diamondCut.length;) {\n            IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\n            if (action == IDiamondCut.FacetCutAction.Add) {\n                addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n            } else if (action == IDiamondCut.FacetCutAction.Replace) {\n                replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n            } else if (action == IDiamondCut.FacetCutAction.Remove) {\n                removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n            } else {\n                revert IncorrectFacetCutAction();\n            }\n            unchecked {\n                ++facetIndex;\n            }\n        }\n        emit DiamondCut(_diamondCut, _init, _calldata);\n        initializeDiamondCut(_init, _calldata);\n    }\n\n    function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n        if (_functionSelectors.length == 0) {\n            revert NoSelectorsInFace();\n        }\n        DiamondStorage storage ds = diamondStorage();\n        if (LibUtil.isZeroAddress(_facetAddress)) {\n            revert FacetAddressIsZero();\n        }\n        uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\n        // add new facet address if it does not exist\n        if (selectorPosition == 0) {\n            addFacet(ds, _facetAddress);\n        }\n        for (uint256 selectorIndex; selectorIndex < _functionSelectors.length;) {\n            bytes4 selector = _functionSelectors[selectorIndex];\n            address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n            if (!LibUtil.isZeroAddress(oldFacetAddress)) {\n                revert FunctionAlreadyExists();\n            }\n            addFunction(ds, selector, selectorPosition, _facetAddress);\n            unchecked {\n                ++selectorPosition;\n                ++selectorIndex;\n            }\n        }\n    }\n\n    function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n        if (_functionSelectors.length == 0) {\n            revert NoSelectorsInFace();\n        }\n        DiamondStorage storage ds = diamondStorage();\n        if (LibUtil.isZeroAddress(_facetAddress)) {\n            revert FacetAddressIsZero();\n        }\n        uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\n        // add new facet address if it does not exist\n        if (selectorPosition == 0) {\n            addFacet(ds, _facetAddress);\n        }\n        for (uint256 selectorIndex; selectorIndex < _functionSelectors.length;) {\n            bytes4 selector = _functionSelectors[selectorIndex];\n            address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n            if (oldFacetAddress == _facetAddress) {\n                revert FunctionAlreadyExists();\n            }\n            removeFunction(ds, oldFacetAddress, selector);\n            addFunction(ds, selector, selectorPosition, _facetAddress);\n            unchecked {\n                ++selectorPosition;\n                ++selectorIndex;\n            }\n        }\n    }\n\n    function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n        if (_functionSelectors.length == 0) {\n            revert NoSelectorsInFace();\n        }\n        DiamondStorage storage ds = diamondStorage();\n        // if function does not exist then do nothing and return\n        if (!LibUtil.isZeroAddress(_facetAddress)) {\n            revert FacetAddressIsNotZero();\n        }\n        for (uint256 selectorIndex; selectorIndex < _functionSelectors.length;) {\n            bytes4 selector = _functionSelectors[selectorIndex];\n            address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n            removeFunction(ds, oldFacetAddress, selector);\n            unchecked {\n                ++selectorIndex;\n            }\n        }\n    }\n\n    function addFacet(DiamondStorage storage ds, address _facetAddress) internal {\n        enforceHasContractCode(_facetAddress);\n        ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = ds.facetAddresses.length;\n        ds.facetAddresses.push(_facetAddress);\n    }\n\n    function addFunction(DiamondStorage storage ds, bytes4 _selector, uint96 _selectorPosition, address _facetAddress)\n        internal\n    {\n        ds.selectorToFacetAndPosition[_selector].functionSelectorPosition = _selectorPosition;\n        ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(_selector);\n        ds.selectorToFacetAndPosition[_selector].facetAddress = _facetAddress;\n    }\n\n    function removeFunction(DiamondStorage storage ds, address _facetAddress, bytes4 _selector) internal {\n        if (LibUtil.isZeroAddress(_facetAddress)) {\n            revert FunctionDoesNotExist();\n        }\n        // an immutable function is a function defined directly in a diamond\n        if (_facetAddress == address(this)) {\n            revert FunctionIsImmutable();\n        }\n        // replace selector with last selector, then delete last selector\n        uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\n        uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\n        // if not the same then replace _selector with lastSelector\n        if (selectorPosition != lastSelectorPosition) {\n            bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\n            ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\n            ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint96(selectorPosition);\n        }\n        // delete the last selector\n        ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\n        delete ds.selectorToFacetAndPosition[_selector];\n\n        // if no more selectors for facet address then delete the facet address\n        if (lastSelectorPosition == 0) {\n            // replace facet address with last facet address and delete last facet address\n            uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\n            uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\n            if (facetAddressPosition != lastFacetAddressPosition) {\n                address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\n                ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\n                ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = facetAddressPosition;\n            }\n            ds.facetAddresses.pop();\n            delete ds\n                .facetFunctionSelectors[_facetAddress]\n                .facetAddressPosition;\n        }\n    }\n\n    function initializeDiamondCut(address _init, bytes memory _calldata) internal {\n        if (LibUtil.isZeroAddress(_init)) {\n            if (_calldata.length != 0) {\n                revert InitZeroButCalldataNotEmpty();\n            }\n        } else {\n            if (_calldata.length == 0) {\n                revert CalldataEmptyButInitNotZero();\n            }\n            if (_init != address(this)) {\n                enforceHasContractCode(_init);\n            }\n            // solhint-disable-next-line avoid-low-level-calls\n            (bool success, bytes memory error) = _init.delegatecall(_calldata);\n            if (!success) {\n                if (error.length > 0) {\n                    // bubble up the error\n                    revert(string(error));\n                } else {\n                    revert InitReverted();\n                }\n            }\n        }\n    }\n\n    function enforceHasContractCode(address _contract) internal view {\n        uint256 contractSize;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            contractSize := extcodesize(_contract)\n        }\n        if (contractSize == 0) {\n            revert FacetContainsNoCode();\n        }\n    }\n}\n"},"src/Interfaces/IDiamondCut.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\ninterface IDiamondCut {\n    // Add=0, Replace=1, Remove=2\n    enum FacetCutAction {\n        Add,\n        Replace,\n        Remove\n    }\n\n    struct FacetCut {\n        address facetAddress;\n        FacetCutAction action;\n        bytes4[] functionSelectors;\n    }\n\n    /// @notice Add/replace/remove any number of functions and optionally execute\n    ///         a function with delegatecall\n    /// @param _diamondCut Contains the facet addresses and function selectors\n    /// @param _init The address of the contract or facet to execute _calldata\n    /// @param _calldata A function call, including function selector and arguments\n    ///                  _calldata is executed with delegatecall on _init\n    function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\n\n    event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.23+commit.f704f362","compilerSettings":{"viaIR":true,"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"shanghai","remappings":[":@1inch/limit-order-protocol-contract/contracts/=lib/limit-order-protocol/contracts/",":@1inch/solidity-utils/contracts/=lib/solidity-utils/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":limit-order-protocol/=lib/limit-order-protocol/contracts/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":solidity-utils/=lib/solidity-utils/contracts/"]},"name":"Diamond","fullyQualifiedName":"src/Diamond.sol:Diamond"},"abi":[{"type":"constructor","inputs":[{"name":"_contractOwner","type":"address","internalType":"address"},{"name":"_diamondCutFacet","type":"address","internalType":"address"}],"stateMutability":"payable"},{"name":"CalldataEmptyButInitNotZero","type":"error","inputs":[]},{"name":"FacetAddressIsNotZero","type":"error","inputs":[]},{"name":"FacetAddressIsZero","type":"error","inputs":[]},{"name":"FacetContainsNoCode","type":"error","inputs":[]},{"name":"FunctionAlreadyExists","type":"error","inputs":[]},{"name":"FunctionDoesNotExist","type":"error","inputs":[]},{"name":"FunctionIsImmutable","type":"error","inputs":[]},{"name":"IncorrectFacetCutAction","type":"error","inputs":[]},{"name":"InitReverted","type":"error","inputs":[]},{"name":"InitZeroButCalldataNotEmpty","type":"error","inputs":[]},{"name":"NoSelectorsInFace","type":"error","inputs":[]},{"name":"DiamondCut","type":"event","inputs":[{"name":"_diamondCut","type":"tuple[]","indexed":false,"components":[{"name":"facetAddress","type":"address","internalType":"address"},{"name":"action","type":"uint8","internalType":"enum IDiamondCut.FacetCutAction"},{"name":"functionSelectors","type":"bytes4[]","internalType":"bytes4[]"}],"internalType":"struct IDiamondCut.FacetCut[]"},{"name":"_init","type":"address","indexed":false,"internalType":"address"},{"name":"_calldata","type":"bytes","indexed":false,"internalType":"bytes"}],"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},{"type":"fallback","stateMutability":"payable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.23+commit.f704f362"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_contractOwner","type":"address"},{"internalType":"address","name":"_diamondCutFacet","type":"address"}],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"CalldataEmptyButInitNotZero","type":"error"},{"inputs":[],"name":"FacetAddressIsNotZero","type":"error"},{"inputs":[],"name":"FacetAddressIsZero","type":"error"},{"inputs":[],"name":"FacetContainsNoCode","type":"error"},{"inputs":[],"name":"FunctionAlreadyExists","type":"error"},{"inputs":[],"name":"FunctionDoesNotExist","type":"error"},{"inputs":[],"name":"FunctionIsImmutable","type":"error"},{"inputs":[],"name":"IncorrectFacetCutAction","type":"error"},{"inputs":[],"name":"InitReverted","type":"error"},{"inputs":[],"name":"InitZeroButCalldataNotEmpty","type":"error"},{"inputs":[],"name":"NoSelectorsInFace","type":"error"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"facetAddress","type":"address"},{"internalType":"enum IDiamondCut.FacetCutAction","name":"action","type":"uint8"},{"internalType":"bytes4[]","name":"functionSelectors","type":"bytes4[]"}],"indexed":false,"internalType":"struct IDiamondCut.FacetCut[]","name":"_diamondCut","type":"tuple[]"},{"indexed":false,"internalType":"address","name":"_init","type":"address"},{"indexed":false,"internalType":"bytes","name":"_calldata","type":"bytes"}],"name":"DiamondCut","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"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"src/Diamond.sol":"Diamond"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@1inch/limit-order-protocol-contract/contracts/=lib/limit-order-protocol/contracts/",":@1inch/solidity-utils/contracts/=lib/solidity-utils/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":limit-order-protocol/=lib/limit-order-protocol/contracts/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":solidity-utils/=lib/solidity-utils/contracts/"],"viaIR":true},"sources":{"src/Diamond.sol":{"keccak256":"0x4e6f759e236979db63c2eeeb13f8edd5891bf9e0a5c9e7619cc8cc0a869d4815","license":"MIT","urls":["bzz-raw://ea94e7ceec8c7c4ce11304ea311185c5d68c865b891fa8af5d5e5f46b9d8e9b6","dweb:/ipfs/QmcQdMRFqQ9QFZMDtncgZXvqyDQVKTaoexGptjU2PTHSAE"]},"src/Errors/GenericErrors.sol":{"keccak256":"0xac057b461086939bb36fa047c8ce35590a38aef5d9bcbac162c94be4e59e7ffe","license":"MIT","urls":["bzz-raw://a3e888efb264f030692361d2f658df8ab3cb87218671de87f3cdc3ea67568128","dweb:/ipfs/QmTo2vF6NAmFzxjZwVdp1Eanr6Ha5LSXNn8R2bKLszmjH9"]},"src/Interfaces/IDiamondCut.sol":{"keccak256":"0x4f770dc7740f76fc3b998cc90267e42c87df15ce32024eceedd36357894b4be3","license":"MIT","urls":["bzz-raw://a991ed20ae638e61b1f74c6440d4d5d95a0d7bde0cf6ef07179a5a638d7114b2","dweb:/ipfs/QmRiQyTffpaATigXNQK3gSDw72i3R7ZdwWENNJv5xV3PZT"]},"src/Libraries/LibBytes.sol":{"keccak256":"0xdb013ff73e1ae9522e9f0489a6246d27b263a24d8087d0efb79a0e5478550baa","license":"MIT","urls":["bzz-raw://cc24491b3ef2d2edeb9528835e63f28e7e8a076ae23d91aa0fd673b7a29e5978","dweb:/ipfs/Qmb2gxxabrjkCqw9tr1U9pkybo9nUZRoix8BFSWk4sPifU"]},"src/Libraries/LibDiamond.sol":{"keccak256":"0xa4bf914c1ce1b5b2221816d0a3f3b78ab79d4837a03eec1bb2863ef3382ccf3b","license":"MIT","urls":["bzz-raw://53ea1b378f7f1460ff10535bac60428e7e523ef00df42cd0655aa76c76fd192d","dweb:/ipfs/QmebhrXpQGiWEtq7xVndSZmPnD6TdF4yUkcNtCKoWn8JFL"]},"src/Libraries/LibUtil.sol":{"keccak256":"0xb9eada257618776e801dd81148919031865c4e32ab9e0ef18ecb984fb4a04032","license":"MIT","urls":["bzz-raw://6cc465f0941cfe5a44d7702e86daccf3ecc7a665dc75b10bb2543210a76bf775","dweb:/ipfs/QmcP3TEu6RdCMS7HeATivx3Yv3dPSY8xxRiGnjThxMsgQ6"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{},"version":1},"sourceIds":{"src/Diamond.sol":{"id":0},"src/Libraries/LibUtil.sol":{"id":5},"src/Libraries/LibBytes.sol":{"id":3},"src/Errors/GenericErrors.sol":{"id":1},"src/Libraries/LibDiamond.sol":{"id":4},"src/Interfaces/IDiamondCut.sol":{"id":2}},"additionalInput":null,"stdJsonInput":{"sources":{"src/Diamond.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport {LibDiamond} from \"./Libraries/LibDiamond.sol\";\nimport {IDiamondCut} from \"./Interfaces/IDiamondCut.sol\";\nimport {LibUtil} from \"./Libraries/LibUtil.sol\";\n\ncontract Diamond {\n    constructor(address _contractOwner, address _diamondCutFacet) payable {\n        LibDiamond.setContractOwner(_contractOwner);\n\n        // Add the diamondCut external function from the diamondCutFacet\n        IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](1);\n        bytes4[] memory functionSelectors = new bytes4[](1);\n        functionSelectors[0] = IDiamondCut.diamondCut.selector;\n        cut[0] = IDiamondCut.FacetCut({\n            facetAddress: _diamondCutFacet,\n            action: IDiamondCut.FacetCutAction.Add,\n            functionSelectors: functionSelectors\n        });\n        LibDiamond.diamondCut(cut, address(0), \"\");\n    }\n\n    // Find facet for function that is called and execute the\n    // function if a facet is found and return any value.\n    // solhint-disable-next-line no-complex-fallback\n    fallback() external payable {\n        LibDiamond.DiamondStorage storage ds;\n        bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;\n\n        // get diamond storage\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            ds.slot := position\n        }\n\n        // get facet from function selector\n        address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;\n\n        if (facet == address(0)) {\n            revert LibDiamond.FunctionDoesNotExist();\n        }\n\n        // Execute external function from facet using delegatecall and return any value.\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            // copy function selector and any arguments\n            calldatacopy(0, 0, calldatasize())\n            // execute function call using the facet\n            let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)\n            // get any return value\n            returndatacopy(0, 0, returndatasize())\n            // return any return value or error back to the caller\n            switch result\n            case 0 { revert(0, returndatasize()) }\n            default { return(0, returndatasize()) }\n        }\n    }\n\n    // Able to receive ether\n    // solhint-disable-next-line no-empty-blocks\n    receive() external payable {}\n}\n"},"src/Libraries/LibUtil.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport \"./LibBytes.sol\";\n\nlibrary LibUtil {\n    using LibBytes for bytes;\n\n    function getRevertMsg(bytes memory _res) internal pure returns (string memory) {\n        // If the _res length is less than 68, then the transaction failed silently (without a revert message)\n        if (_res.length < 68) return \"Transaction reverted silently\";\n        bytes memory revertData = _res.slice(4, _res.length - 4); // Remove the selector which is the first 4 bytes\n        return abi.decode(revertData, (string)); // All that remains is the revert string\n    }\n\n    /// @notice Determines whether the given address is the zero address\n    /// @param addr The address to verify\n    /// @return Boolean indicating if the address is the zero address\n    function isZeroAddress(address addr) internal pure returns (bool) {\n        return addr == address(0);\n    }\n}\n"},"src/Libraries/LibBytes.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nlibrary LibBytes {\n    // solhint-disable no-inline-assembly\n\n    // LibBytes specific errors\n    error SliceOverflow();\n    error SliceOutOfBounds();\n    error AddressOutOfBounds();\n\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n\n    // -------------------------\n\n    function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {\n        unchecked {\n            if (_length + 31 < _length) revert SliceOverflow();\n            if (_bytes.length < _start + _length) revert SliceOutOfBounds();\n            if (_start + _length < _start) revert SliceOverflow();\n        }\n\n        bytes memory tempBytes;\n\n        assembly {\n            switch iszero(_length)\n            case 0 {\n                // Get a location of some free memory and store it in tempBytes as\n                // Solidity does for memory variables.\n                tempBytes := mload(0x40)\n\n                // The first word of the slice result is potentially a partial\n                // word read from the original array. To read it, we calculate\n                // the length of that partial word and start copying that many\n                // bytes into the array. The first word we copy will start with\n                // data we don't care about, but the last `lengthmod` bytes will\n                // land at the beginning of the contents of the new array. When\n                // we're done copying, we overwrite the full first word with\n                // the actual length of the slice.\n                let lengthmod := and(_length, 31)\n\n                // The multiplication in the next line is necessary\n                // because when slicing multiples of 32 bytes (lengthmod == 0)\n                // the following copy loop was copying the origin's length\n                // and then ending prematurely not copying everything it should.\n                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))\n                let end := add(mc, _length)\n\n                for {\n                    // The multiplication in the next line has the same exact purpose\n                    // as the one above.\n                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)\n                } lt(mc, end) {\n                    mc := add(mc, 0x20)\n                    cc := add(cc, 0x20)\n                } { mstore(mc, mload(cc)) }\n\n                mstore(tempBytes, _length)\n\n                //update free-memory pointer\n                //allocating the array padded to 32 bytes like the compiler does now\n                mstore(0x40, and(add(mc, 31), not(31)))\n            }\n            //if we want a zero-length slice let's just return a zero-length array\n            default {\n                tempBytes := mload(0x40)\n                //zero out the 32 bytes slice we are about to return\n                //we need to do it because Solidity does not garbage collect\n                mstore(tempBytes, 0)\n\n                mstore(0x40, add(tempBytes, 0x20))\n            }\n        }\n\n        return tempBytes;\n    }\n\n    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {\n        if (_bytes.length < _start + 20) {\n            revert AddressOutOfBounds();\n        }\n        address tempAddress;\n\n        assembly {\n            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)\n        }\n\n        return tempAddress;\n    }\n\n    /// Copied from OpenZeppelin's `Strings.sol` utility library.\n    /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/8335676b0e99944eef6a742e16dcd9ff6e68e609/contracts/utils/Strings.sol\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n}\n"},"src/Errors/GenericErrors.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nerror OnlyContractOwner();\n"},"src/Libraries/LibDiamond.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\nimport {IDiamondCut} from \"../Interfaces/IDiamondCut.sol\";\nimport {LibUtil} from \"../Libraries/LibUtil.sol\";\nimport {OnlyContractOwner} from \"../Errors/GenericErrors.sol\";\n\n/// Implementation of EIP-2535 Diamond Standard\n/// https://eips.ethereum.org/EIPS/eip-2535\nlibrary LibDiamond {\n    bytes32 internal constant DIAMOND_STORAGE_POSITION = keccak256(\"com.binance.w3w.diamond.storage\");\n\n    // Diamond specific errors\n    error IncorrectFacetCutAction();\n    error NoSelectorsInFace();\n    error FunctionAlreadyExists();\n    error FacetAddressIsZero();\n    error FacetAddressIsNotZero();\n    error FacetContainsNoCode();\n    error FunctionDoesNotExist();\n    error FunctionIsImmutable();\n    error InitZeroButCalldataNotEmpty();\n    error CalldataEmptyButInitNotZero();\n    error InitReverted();\n    // ----------------\n\n    struct FacetAddressAndPosition {\n        address facetAddress;\n        uint96 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array\n    }\n\n    struct FacetFunctionSelectors {\n        bytes4[] functionSelectors;\n        uint256 facetAddressPosition; // position of facetAddress in facetAddresses array\n    }\n\n    struct DiamondStorage {\n        // maps function selector to the facet address and\n        // the position of the selector in the facetFunctionSelectors.selectors array\n        mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;\n        // maps facet addresses to function selectors\n        mapping(address => FacetFunctionSelectors) facetFunctionSelectors;\n        // facet addresses\n        address[] facetAddresses;\n        // Used to query if a contract implements an interface.\n        // Used to implement ERC-165.\n        mapping(bytes4 => bool) supportedInterfaces;\n        // owner of the contract\n        address contractOwner;\n    }\n\n    function diamondStorage() internal pure returns (DiamondStorage storage ds) {\n        bytes32 position = DIAMOND_STORAGE_POSITION;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            ds.slot := position\n        }\n    }\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    function setContractOwner(address _newOwner) internal {\n        DiamondStorage storage ds = diamondStorage();\n        address previousOwner = ds.contractOwner;\n        ds.contractOwner = _newOwner;\n        emit OwnershipTransferred(previousOwner, _newOwner);\n    }\n\n    function contractOwner() internal view returns (address contractOwner_) {\n        contractOwner_ = diamondStorage().contractOwner;\n    }\n\n    function enforceIsContractOwner() internal view {\n        if (msg.sender != diamondStorage().contractOwner) {\n            revert OnlyContractOwner();\n        }\n    }\n\n    event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);\n\n    // Internal function version of diamondCut\n    function diamondCut(IDiamondCut.FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\n        for (uint256 facetIndex; facetIndex < _diamondCut.length;) {\n            IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;\n            if (action == IDiamondCut.FacetCutAction.Add) {\n                addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n            } else if (action == IDiamondCut.FacetCutAction.Replace) {\n                replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n            } else if (action == IDiamondCut.FacetCutAction.Remove) {\n                removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);\n            } else {\n                revert IncorrectFacetCutAction();\n            }\n            unchecked {\n                ++facetIndex;\n            }\n        }\n        emit DiamondCut(_diamondCut, _init, _calldata);\n        initializeDiamondCut(_init, _calldata);\n    }\n\n    function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n        if (_functionSelectors.length == 0) {\n            revert NoSelectorsInFace();\n        }\n        DiamondStorage storage ds = diamondStorage();\n        if (LibUtil.isZeroAddress(_facetAddress)) {\n            revert FacetAddressIsZero();\n        }\n        uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\n        // add new facet address if it does not exist\n        if (selectorPosition == 0) {\n            addFacet(ds, _facetAddress);\n        }\n        for (uint256 selectorIndex; selectorIndex < _functionSelectors.length;) {\n            bytes4 selector = _functionSelectors[selectorIndex];\n            address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n            if (!LibUtil.isZeroAddress(oldFacetAddress)) {\n                revert FunctionAlreadyExists();\n            }\n            addFunction(ds, selector, selectorPosition, _facetAddress);\n            unchecked {\n                ++selectorPosition;\n                ++selectorIndex;\n            }\n        }\n    }\n\n    function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n        if (_functionSelectors.length == 0) {\n            revert NoSelectorsInFace();\n        }\n        DiamondStorage storage ds = diamondStorage();\n        if (LibUtil.isZeroAddress(_facetAddress)) {\n            revert FacetAddressIsZero();\n        }\n        uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);\n        // add new facet address if it does not exist\n        if (selectorPosition == 0) {\n            addFacet(ds, _facetAddress);\n        }\n        for (uint256 selectorIndex; selectorIndex < _functionSelectors.length;) {\n            bytes4 selector = _functionSelectors[selectorIndex];\n            address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n            if (oldFacetAddress == _facetAddress) {\n                revert FunctionAlreadyExists();\n            }\n            removeFunction(ds, oldFacetAddress, selector);\n            addFunction(ds, selector, selectorPosition, _facetAddress);\n            unchecked {\n                ++selectorPosition;\n                ++selectorIndex;\n            }\n        }\n    }\n\n    function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {\n        if (_functionSelectors.length == 0) {\n            revert NoSelectorsInFace();\n        }\n        DiamondStorage storage ds = diamondStorage();\n        // if function does not exist then do nothing and return\n        if (!LibUtil.isZeroAddress(_facetAddress)) {\n            revert FacetAddressIsNotZero();\n        }\n        for (uint256 selectorIndex; selectorIndex < _functionSelectors.length;) {\n            bytes4 selector = _functionSelectors[selectorIndex];\n            address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;\n            removeFunction(ds, oldFacetAddress, selector);\n            unchecked {\n                ++selectorIndex;\n            }\n        }\n    }\n\n    function addFacet(DiamondStorage storage ds, address _facetAddress) internal {\n        enforceHasContractCode(_facetAddress);\n        ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = ds.facetAddresses.length;\n        ds.facetAddresses.push(_facetAddress);\n    }\n\n    function addFunction(DiamondStorage storage ds, bytes4 _selector, uint96 _selectorPosition, address _facetAddress)\n        internal\n    {\n        ds.selectorToFacetAndPosition[_selector].functionSelectorPosition = _selectorPosition;\n        ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(_selector);\n        ds.selectorToFacetAndPosition[_selector].facetAddress = _facetAddress;\n    }\n\n    function removeFunction(DiamondStorage storage ds, address _facetAddress, bytes4 _selector) internal {\n        if (LibUtil.isZeroAddress(_facetAddress)) {\n            revert FunctionDoesNotExist();\n        }\n        // an immutable function is a function defined directly in a diamond\n        if (_facetAddress == address(this)) {\n            revert FunctionIsImmutable();\n        }\n        // replace selector with last selector, then delete last selector\n        uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;\n        uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;\n        // if not the same then replace _selector with lastSelector\n        if (selectorPosition != lastSelectorPosition) {\n            bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];\n            ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;\n            ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint96(selectorPosition);\n        }\n        // delete the last selector\n        ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();\n        delete ds.selectorToFacetAndPosition[_selector];\n\n        // if no more selectors for facet address then delete the facet address\n        if (lastSelectorPosition == 0) {\n            // replace facet address with last facet address and delete last facet address\n            uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;\n            uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;\n            if (facetAddressPosition != lastFacetAddressPosition) {\n                address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];\n                ds.facetAddresses[facetAddressPosition] = lastFacetAddress;\n                ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = facetAddressPosition;\n            }\n            ds.facetAddresses.pop();\n            delete ds\n                .facetFunctionSelectors[_facetAddress]\n                .facetAddressPosition;\n        }\n    }\n\n    function initializeDiamondCut(address _init, bytes memory _calldata) internal {\n        if (LibUtil.isZeroAddress(_init)) {\n            if (_calldata.length != 0) {\n                revert InitZeroButCalldataNotEmpty();\n            }\n        } else {\n            if (_calldata.length == 0) {\n                revert CalldataEmptyButInitNotZero();\n            }\n            if (_init != address(this)) {\n                enforceHasContractCode(_init);\n            }\n            // solhint-disable-next-line avoid-low-level-calls\n            (bool success, bytes memory error) = _init.delegatecall(_calldata);\n            if (!success) {\n                if (error.length > 0) {\n                    // bubble up the error\n                    revert(string(error));\n                } else {\n                    revert InitReverted();\n                }\n            }\n        }\n    }\n\n    function enforceHasContractCode(address _contract) internal view {\n        uint256 contractSize;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            contractSize := extcodesize(_contract)\n        }\n        if (contractSize == 0) {\n            revert FacetContainsNoCode();\n        }\n    }\n}\n"},"src/Interfaces/IDiamondCut.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.23;\n\ninterface IDiamondCut {\n    // Add=0, Replace=1, Remove=2\n    enum FacetCutAction {\n        Add,\n        Replace,\n        Remove\n    }\n\n    struct FacetCut {\n        address facetAddress;\n        FacetCutAction action;\n        bytes4[] functionSelectors;\n    }\n\n    /// @notice Add/replace/remove any number of functions and optionally execute\n    ///         a function with delegatecall\n    /// @param _diamondCut Contains the facet addresses and function selectors\n    /// @param _init The address of the contract or facet to execute _calldata\n    /// @param _calldata A function call, including function selector and arguments\n    ///                  _calldata is executed with delegatecall on _init\n    function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\n\n    event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"shanghai","remappings":[":@1inch/limit-order-protocol-contract/contracts/=lib/limit-order-protocol/contracts/",":@1inch/solidity-utils/contracts/=lib/solidity-utils/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":limit-order-protocol/=lib/limit-order-protocol/contracts/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":solidity-utils/=lib/solidity-utils/contracts/"]}},"stdJsonOutput":{"sources":{"src/Diamond.sol":{"id":0},"src/Libraries/LibUtil.sol":{"id":5},"src/Libraries/LibBytes.sol":{"id":3},"src/Errors/GenericErrors.sol":{"id":1},"src/Libraries/LibDiamond.sol":{"id":4},"src/Interfaces/IDiamondCut.sol":{"id":2}},"contracts":{"src/Diamond.sol":{"Diamond":{"abi":[{"type":"constructor","inputs":[{"name":"_contractOwner","type":"address","internalType":"address"},{"name":"_diamondCutFacet","type":"address","internalType":"address"}],"stateMutability":"payable"},{"name":"CalldataEmptyButInitNotZero","type":"error","inputs":[]},{"name":"FacetAddressIsNotZero","type":"error","inputs":[]},{"name":"FacetAddressIsZero","type":"error","inputs":[]},{"name":"FacetContainsNoCode","type":"error","inputs":[]},{"name":"FunctionAlreadyExists","type":"error","inputs":[]},{"name":"FunctionDoesNotExist","type":"error","inputs":[]},{"name":"FunctionIsImmutable","type":"error","inputs":[]},{"name":"IncorrectFacetCutAction","type":"error","inputs":[]},{"name":"InitReverted","type":"error","inputs":[]},{"name":"InitZeroButCalldataNotEmpty","type":"error","inputs":[]},{"name":"NoSelectorsInFace","type":"error","inputs":[]},{"name":"DiamondCut","type":"event","inputs":[{"name":"_diamondCut","type":"tuple[]","indexed":false,"components":[{"name":"facetAddress","type":"address","internalType":"address"},{"name":"action","type":"uint8","internalType":"enum IDiamondCut.FacetCutAction"},{"name":"functionSelectors","type":"bytes4[]","internalType":"bytes4[]"}],"internalType":"struct IDiamondCut.FacetCut[]"},{"name":"_init","type":"address","indexed":false,"internalType":"address"},{"name":"_calldata","type":"bytes","indexed":false,"internalType":"bytes"}],"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},{"type":"fallback","stateMutability":"payable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.23+commit.f704f362\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_contractOwner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_diamondCutFacet\",\"type\":\"address\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CalldataEmptyButInitNotZero\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FacetAddressIsNotZero\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FacetAddressIsZero\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FacetContainsNoCode\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FunctionAlreadyExists\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FunctionDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FunctionIsImmutable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"IncorrectFacetCutAction\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitReverted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitZeroButCalldataNotEmpty\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoSelectorsInFace\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"facetAddress\",\"type\":\"address\"},{\"internalType\":\"enum IDiamondCut.FacetCutAction\",\"name\":\"action\",\"type\":\"uint8\"},{\"internalType\":\"bytes4[]\",\"name\":\"functionSelectors\",\"type\":\"bytes4[]\"}],\"indexed\":false,\"internalType\":\"struct IDiamondCut.FacetCut[]\",\"name\":\"_diamondCut\",\"type\":\"tuple[]\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_init\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"_calldata\",\"type\":\"bytes\"}],\"name\":\"DiamondCut\",\"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\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/Diamond.sol\":\"Diamond\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@1inch/limit-order-protocol-contract/contracts/=lib/limit-order-protocol/contracts/\",\":@1inch/solidity-utils/contracts/=lib/solidity-utils/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":limit-order-protocol/=lib/limit-order-protocol/contracts/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":solidity-utils/=lib/solidity-utils/contracts/\"],\"viaIR\":true},\"sources\":{\"src/Diamond.sol\":{\"keccak256\":\"0x4e6f759e236979db63c2eeeb13f8edd5891bf9e0a5c9e7619cc8cc0a869d4815\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ea94e7ceec8c7c4ce11304ea311185c5d68c865b891fa8af5d5e5f46b9d8e9b6\",\"dweb:/ipfs/QmcQdMRFqQ9QFZMDtncgZXvqyDQVKTaoexGptjU2PTHSAE\"]},\"src/Errors/GenericErrors.sol\":{\"keccak256\":\"0xac057b461086939bb36fa047c8ce35590a38aef5d9bcbac162c94be4e59e7ffe\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a3e888efb264f030692361d2f658df8ab3cb87218671de87f3cdc3ea67568128\",\"dweb:/ipfs/QmTo2vF6NAmFzxjZwVdp1Eanr6Ha5LSXNn8R2bKLszmjH9\"]},\"src/Interfaces/IDiamondCut.sol\":{\"keccak256\":\"0x4f770dc7740f76fc3b998cc90267e42c87df15ce32024eceedd36357894b4be3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a991ed20ae638e61b1f74c6440d4d5d95a0d7bde0cf6ef07179a5a638d7114b2\",\"dweb:/ipfs/QmRiQyTffpaATigXNQK3gSDw72i3R7ZdwWENNJv5xV3PZT\"]},\"src/Libraries/LibBytes.sol\":{\"keccak256\":\"0xdb013ff73e1ae9522e9f0489a6246d27b263a24d8087d0efb79a0e5478550baa\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cc24491b3ef2d2edeb9528835e63f28e7e8a076ae23d91aa0fd673b7a29e5978\",\"dweb:/ipfs/Qmb2gxxabrjkCqw9tr1U9pkybo9nUZRoix8BFSWk4sPifU\"]},\"src/Libraries/LibDiamond.sol\":{\"keccak256\":\"0xa4bf914c1ce1b5b2221816d0a3f3b78ab79d4837a03eec1bb2863ef3382ccf3b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53ea1b378f7f1460ff10535bac60428e7e523ef00df42cd0655aa76c76fd192d\",\"dweb:/ipfs/QmebhrXpQGiWEtq7xVndSZmPnD6TdF4yUkcNtCKoWn8JFL\"]},\"src/Libraries/LibUtil.sol\":{\"keccak256\":\"0xb9eada257618776e801dd81148919031865c4e32ab9e0ef18ecb984fb4a04032\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6cc465f0941cfe5a44d7702e86daccf3ecc7a665dc75b10bb2543210a76bf775\",\"dweb:/ipfs/QmcP3TEu6RdCMS7HeATivx3Yv3dPSY8xxRiGnjThxMsgQ6\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"60806001600160401b03601f610b5938819003918201601f1916840191838311858410176105b75780859260409485528339810103126105f15761004e602061004784610633565b9301610633565b7f5e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c980546001600160a01b039485166001600160a01b03198216811790925591939091167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a36100bd610614565b91600183525f5b602081106105cb57506100d5610614565b60018152602036818301376307e4c70760e21b6100f182610647565b526100fa6105f5565b6001600160a01b0390921682525f6020830152604082015261011b83610647565b5261012582610647565b506040519060208201908111828210176105b7576040525f808252825b805182101561045c5760206101578383610668565b5101516003811015610448578061028f57506001600160a01b0361017b8383610668565b515116604061018a8484610668565b51015180511561027d57811561026b576001600160a01b0382165f9081525f80516020610b3983398151915260205260409020546001600160601b039390841690811561025d575b5f915b8351831015610249576001600160e01b03196101f18486610668565b51165f8181525f80516020610af983398151915260205260409020549091906001600160a01b03166102375760018161022d888a948496610994565b01169201916101d5565b60405163a023275d60e01b8152600490fd5b50959492505050600191505b019091610142565b6102668461091b565b6101d2565b604051636347641d60e11b8152600490fd5b6040516307bc559560e41b8152600490fd5b6001810361038f57506001600160a01b036102aa8383610668565b5151169260406102ba8484610668565b51015180511561027d57841561026b576001600160a01b0385165f9081525f80516020610b3983398151915260205260409020546001600160601b0393908416908115610381575b5f915b8351831015610372576001600160e01b03196103218486610668565b51165f8181525f80516020610af983398151915260205260409020546001600160a01b03169089821461023757826103688b6001958461036388968e986106c0565b610994565b0116920191610305565b50955050509160019150610255565b61038a8761091b565b610302565b600203610436576001600160a01b036103a88383610668565b5151169060406103b88483610668565b5101519182511561027d57610424575f5b8251811015610418576001906104126001600160e01b03196103eb8387610668565b5116805f525f80516020610af9833981519152602052838060a01b0360405f2054166106c0565b016103c9565b50929160019150610255565b604051633ce4ef9160e11b8152600490fd5b60405163e548e6b560e01b8152600490fd5b634e487b7160e01b5f52602160045260245ffd5b905060405190606082016060835281518091526080830190602060808260051b8601019301915f905b82821061052157505050505f6020830152818103604083015282518082525f5b81811061050c57508282825f602080957f8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb6739897010152601f801991011601030190a1516104fa5760405160b49081610a458239f35b6040516304c08b4360e51b8152600490fd5b806020809287010151828286010152016104a5565b858503607f19018152835180516001600160a01b03168652602081015194959394929391929060038210156104485760409160208401520151906060604082015260206080835192836060820152019201905f905b80821061059457505050602080600192960192019201909291610485565b82516001600160e01b031916845260209384019390920191600190910190610576565b634e487b7160e01b5f52604160045260245ffd5b6020906105d66105f5565b5f81525f8382015260606040820152828287010152016100c4565b5f80fd5b60405190606082016001600160401b038111838210176105b757604052565b60408051919082016001600160401b038111838210176105b757604052565b51906001600160a01b03821682036105f157565b8051156106545760200190565b634e487b7160e01b5f52603260045260245ffd5b80518210156106545760209160051b010190565b9190918054831015610654575f52601c60205f208360031c019260021b1690565b5f80516020610b198339815191528054821015610654575f5260205f2001905f90565b6001600160a01b03908116918215610909573083146108f75763ffffffff60e01b809116805f525f80516020610af983398151915293602090858252604093845f205460a01c96825f525f80516020610b3983398151915294858552865f2054925f19998a850194851161085857889187898888850361086c575b9450505050505f52858552865f20805480156107f4578a019061075e828261067c565b63ffffffff82549160031b1b19169055555f5283525f8581205515610786575b505050505050565b5f80516020610b1983398151915294855487810190811161085857825f52848452816001875f20015491808303610808575b50505085549586156107f4575f9760019701916107d48361069d565b909182549160031b1b1916905555855252822001555f808080808061077e565b634e487b7160e01b5f52603160045260245ffd5b6108119061069d565b90549060031b1c16610844816108268461069d565b90919060018060a01b038084549260031b9316831b921b1916179055565b5f528484526001865f2001555f81816107b8565b634e487b7160e01b5f52601160045260245ffd5b6108a1856108ec976108be94845f5280875261088a8d835f2061067c565b90549060031b1c60e01b9687955f52525f2061067c565b90919063ffffffff83549160031b9260e01c831b921b1916179055565b165f90815284885289902080546001600160a01b031660a09290921b6001600160a01b031916919091179055565b865f8087898861073b565b60405163c3c5ec3760e01b8152600490fd5b604051631535ac5f60e31b8152600490fd5b803b15610983575f80516020610b1983398151915280546001600160a01b0383165f9081525f80516020610b39833981519152602052604090206001018190559190680100000000000000008310156105b757826108269160016109819501905561069d565b565b6040516271a80360e91b8152600490fd5b6001600160e01b031981165f8181525f80516020610af98339815191526020819052604090912080546001600160a01b031660a09590951b6001600160a01b0319169490941790935590926001600160a01b03165f8181525f80516020610b39833981519152602052604090208054919490680100000000000000008310156105b757826108a1916001610a2a9501815561067c565b5f5260205260405f209060018060a01b031982541617905556fe60806040523615607c575f80356001600160e01b03191681527f5e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c560205260409020546001600160a01b03168015606b575f8091368280378136915af43d5f803e156067573d5ff35b3d5ffd5b631535ac5f60e31b60805260046080fd5b00fea2646970667358221220930a620c99a7318ca205c3fd7de61f4589313a6f74e2a079ea59f03d58767f3464736f6c634300081700335e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c55e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c75e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c6","sourceMap":"220:2178:0:-:0;-1:-1:-1;;;;;220:2178:0;;;;;;;;;-1:-1:-1;;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;2390:16:4;220:2178:0;;-1:-1:-1;;;;;220:2178:0;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;2390:16:4;;220:2178:0;;;2459:46:4;-1:-1:-1;;2459:46:4;220:2178:0;;:::i;:::-;;513:1;220:2178;;-1:-1:-1;220:2178:0;;;;;;;;;:::i;:::-;513:1;220:2178;;;;;;;;-1:-1:-1;;;586:54:0;;;:::i;:::-;220:2178;;;:::i;:::-;-1:-1:-1;;;;;220:2178:0;;;;;-1:-1:-1;220:2178:0;659:178;;220:2178;;659:178;;220:2178;650:187;;;:::i;:::-;;;;;:::i;:::-;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;3095:18:4;220:2178:0;;3115:31:4;;;;;220:2178:0;3199:23:4;;;;:::i;:::-;;:30;220:2178:0;;;;;;;3247:40:4;;;-1:-1:-1;;;;;;3320:23:4;;;;:::i;:::-;;220:2178:0;;;3358:23:4;;;;:::i;:::-;;:41;;220:2178:0;;4154:30:4;4150:87;;883:18:5;;4300:94:4;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;4570:21:4;;4566:79;;3243:613;-1:-1:-1;4654:540:4;4659:21;220:2178:0;;4682:41:4;;;;;-1:-1:-1;;;;;;4758:33:4;;;;:::i;:::-;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;-1:-1:-1;;;;;220:2178:0;4897:108:4;;513:1:0;5062:13:4;;;;;;;;:::i;:::-;220:2178:0;;;;4659:21:4;;;4897:108;220:2178:0;;-1:-1:-1;;;4967:23:4;;2390:16;;4967:23;4682:41;;;;;;;;513:1:0;4682:41:4;;3243:613;220:2178:0;3095:18:4;;;;4566:79;4620:13;;;:::i;:::-;4566:79;;4300:94;220:2178:0;;-1:-1:-1;;;4363:20:4;;2390:16;;4363:20;4150:87;220:2178:0;;-1:-1:-1;;;4207:19:4;;2390:16;;4207:19;3243:613;513:1:0;3425:44:4;;513:1:0;;-1:-1:-1;;;;;;3506:23:4;;;;:::i;:::-;;220:2178:0;;3544:23:4;220:2178:0;3544:23:4;;;;:::i;:::-;;:41;;220:2178:0;;5314:30:4;5310:87;;883:18:5;;5460:94:4;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;5730:21:4;;5726:79;;3421:435;-1:-1:-1;5814:592:4;5819:21;220:2178:0;;5842:41:4;;;;;-1:-1:-1;;;;;;5918:33:4;;;;:::i;:::-;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;220:2178:0;;6061:32:4;;;6057:101;;6207:8;6274:13;6207:8;513:1:0;6207:8:4;;;;;;;;:::i;:::-;6274:13;:::i;:::-;220:2178:0;;;;5819:21:4;;;5842:41;;;;;;;513:1:0;5842:41:4;;3243:613;;5726:79;5780:13;;;:::i;:::-;5726:79;;3421:435;3621:33;3611:43;3621:33;;-1:-1:-1;;;;;3690:23:4;;;;:::i;:::-;;220:2178:0;;3728:23:4;220:2178:0;3728:23:4;;;;:::i;:::-;;:41;;220:2178:0;;;6525:30:4;6521:87;;6736:98;;-1:-1:-1;6848:21:4;220:2178:0;;6871:41:4;;;;;513:1:0;;7122:8:4;-1:-1:-1;;;;;;6947:33:4;220:2178:0;6947:33:4;;:::i;:::-;220:2178:0;;;-1:-1:-1;220:2178:0;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;-1:-1:-1;220:2178:0;;;7122:8:4;:::i;:::-;220:2178:0;6848:21:4;;6871:41;;;;513:1:0;6871:41:4;;3243:613;;6736:98;220:2178:0;;-1:-1:-1;;;6800:23:4;;2390:16;;6800:23;3607:249;220:2178:0;;-1:-1:-1;;;3816:25:4;;2390:16;;3816:25;220:2178:0;;;;-1:-1:-1;220:2178:0;;2390:16:4;220:2178:0;;-1:-1:-1;220:2178:0;3115:31:4;;;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;-1:-1:-1;220:2178:0;;;3948:41:4;220:2178:0;;;;;;;;;;;;3948:41:4;;;;220:2178:0;10271:96:4;;220:2178:0;;;;;;;;;10271:96:4;220:2178:0;;-1:-1:-1;;;10323:29:4;;2390:16;;10323:29;220:2178:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;220:2178:0;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;;513:1;220:2178;;;;;;;;;;;;;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;;;;;;513:1;220:2178;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;-1:-1:-1;220:2178:0;;;;;;:::i;:::-;-1:-1:-1;220:2178:0;;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;220:2178:0;;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;220:2178:0;;;;;;:::o;:::-;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;-1:-1:-1;220:2178:0;;;-1:-1:-1;220:2178:0;;;;;;;;;;:::o;:::-;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;-1:-1:-1;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;220:2178:0;:::o;7914:2215:4:-;-1:-1:-1;;;;;220:2178:0;;;;883:18:5;;8025:96:4;;8236:4;8211:30;;8207:89;;220:2178:0;;;;;;;899:1:5;220:2178:0;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;899:1:5;220:2178:0;;;;;;899:1:5;220:2178:0;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;899:1:5;220:2178:0;;;;;;;;;;;;;;8663:40:4;;;;;;;;8659:387;;7914:2215;220:2178:0;;;;;;899:1:5;220:2178:0;;;;;899:1:5;220:2178:0;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;899:1:5;220:2178:0;;;899:1:5;220:2178:0;;;;9307:25:4;9303:820;;7914:2215;;;;;;;:::o;9303:820::-;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;;;;899:1:5;220:2178:0;;;;;8512:25:4;220:2178:0;899:1:5;220:2178:0;9547:61:4;220:2178:0;9626:48:4;;;;9622:338;;9303:820;220:2178:0;;;;;;;;;;899:1:5;220:2178:0;8512:25:4;220:2178:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;10017:95:4;220:2178:0;9303:820:4;;;;;;;;220:2178:0;;;;899:1:5;220:2178:0;;;;;899:1:5;220:2178:0;9622:338:4;9721:43;;;:::i;:::-;220:2178:0;;;;;;;9782:58:4;:39;;;;:::i;:::-;:58;220:2178:0;;;;;;;;;;;;;;;;;;;;;;;;;9782:58:4;899:1:5;220:2178:0;;;;8512:25:4;220:2178:0;899:1:5;220:2178:0;9858:64:4;220:2178:0;9622:338:4;;;;;220:2178:0;;;;899:1:5;220:2178:0;;;;;899:1:5;220:2178:0;8659:387:4;8835:76;220:2178:0;8940:95:4;220:2178:0;8835:91:4;220:2178:0;;899:1:5;220:2178:0;;;;8741:80:4;220:2178:0;;899:1:5;220:2178:0;8741:80:4;:::i;:::-;220:2178:0;;;;;;;;;;;899:1:5;220:2178:0;;899:1:5;220:2178:0;8835:76:4;:::i;:::-;:91;220:2178:0;;;;;;;;;;;;;;;;;;;;;8835:91:4;220:2178:0;899:1:5;220:2178:0;;;;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;;8940:95:4;8659:387;;;;;;;;8207:89;220:2178:0;;-1:-1:-1;;;8264:21:4;;;;;8025:96;220:2178:0;;-1:-1:-1;;;8088:22:4;;;;;7225:276;11176:71;;11260:17;11256:76;;-1:-1:-1;;;;;;;;;;;220:2178:0;;-1:-1:-1;;;;;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;7359:61:4;220:2178:0;;;;;;;;;;;;;;7359:25:4;220:2178:0;;;;;;:::i;:::-;7225:276:4:o;11256:76::-;220:2178:0;;-1:-1:-1;;;11300:21:4;;;;;7507:401;-1:-1:-1;;;;;;220:2178:0;;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;;-1:-1:-1;;;;;220:2178:0;;;;;;-1:-1:-1;;;;;;220:2178:0;;;;;;;;7507:401:4;;-1:-1:-1;;;;;220:2178:0;-1:-1:-1;220:2178:0;;;-1:-1:-1;;;;;;;;;;;220:2178:0;;;;;;;;;;;;;;;;;;;7748:25:4;220:2178:0;;;;;;:::i;:::-;-1:-1:-1;220:2178:0;;;;-1:-1:-1;220:2178:0;;;;;;;;;;;;;;7507:401:4:o","linkReferences":{}},"deployedBytecode":{"object":"60806040523615607c575f80356001600160e01b03191681527f5e12654f390e4153c4f63b3dfcc122cf7876a5cdfb496dccf7284c10517a35c560205260409020546001600160a01b03168015606b575f8091368280378136915af43d5f803e156067573d5ff35b3d5ffd5b631535ac5f60e31b60805260046080fd5b00fea2646970667358221220930a620c99a7318ca205c3fd7de61f4589313a6f74e2a079ea59f03d58767f3464736f6c63430008170033","sourceMap":"220:2178:0:-:0;;;;;;;-1:-1:-1;1463:7:0;;-1:-1:-1;;;;;;1463:7:0;400:44:4;;;;;220:2178:0;400:44:4;;;-1:-1:-1;;;;;400:44:4;1499:19:0;;1495:90;;-1:-1:-1;220:2178:0;;;1740:537;;;220:2178;;1740:537;;;;-1:-1:-1;1740:537:0;;;;;;-1:-1:-1;1740:537:0;;;-1:-1:-1;1740:537:0;1495:90;1541:33;;;220:2178;1541:33;;220:2178;1541:33;220:2178;","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[],"event":[{"signature":"DiamondCut((address,uint8,bytes4[])[],address,bytes)","signatureHash4":"0x8faa7087","signatureHash32":"0x8faa70878671ccd212d20771b795c50af8fd3ff6cf27f4bde57e5d4de0aeb673"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"}],"error":[{"signature":"CalldataEmptyButInitNotZero()","signatureHash4":"0x42200566","signatureHash32":"0x4220056682eba2f3273eba0a7139a145e151c5faa145d059a3392a7878b4b381"},{"signature":"FacetAddressIsNotZero()","signatureHash4":"0x79c9df22","signatureHash32":"0x79c9df2277935e90595f09af9250f16496ef4592c14bed9888c0918d92db40f5"},{"signature":"FacetAddressIsZero()","signatureHash4":"0xc68ec83a","signatureHash32":"0xc68ec83a11ebac743720c9a68844bf269b645639ca613b3d1411cfcc91a2c553"},{"signature":"FacetContainsNoCode()","signatureHash4":"0xe3500600","signatureHash32":"0xe35006004ee37483c5ee6040f516742018996871c617a0cd6eeae72ddc29ab03"},{"signature":"FunctionAlreadyExists()","signatureHash4":"0xa023275d","signatureHash32":"0xa023275db1c8c522cc4bec2f421a270d85c4ccf4abb82fd6cf067fc7fb140ad7"},{"signature":"FunctionDoesNotExist()","signatureHash4":"0xa9ad62f8","signatureHash32":"0xa9ad62f865ff1882e3c16eda6d78c6dcc12d6df017682c1f8578acc6c3d23926"},{"signature":"FunctionIsImmutable()","signatureHash4":"0xc3c5ec37","signatureHash32":"0xc3c5ec3755f5a015b7c6dd7d3d9c3077e4292b4f8ea8039af7701c875a3f2c3a"},{"signature":"IncorrectFacetCutAction()","signatureHash4":"0xe548e6b5","signatureHash32":"0xe548e6b5a30fe4803accc33321aee4640e98c812e9b497483dcbd0f5cf607548"},{"signature":"InitReverted()","signatureHash4":"0xc53ebed5","signatureHash32":"0xc53ebed56a2f5ab1b5135980507a60ecd03b6e4f35ef3da1b52436871b6c7257"},{"signature":"InitZeroButCalldataNotEmpty()","signatureHash4":"0x98116860","signatureHash32":"0x98116860878de268782876d730a346476c1fc68d96b67439b7b26e58df1863fc"},{"signature":"NoSelectorsInFace()","signatureHash4":"0x7bc55950","signatureHash32":"0x7bc5595019d68eaf6919b2a5a5aec6edbecb83ef63b2e78d12eabf6cec0373dd"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0xb300000b72DEAEb607a12d5f54773D1C19c7028d"}