{"matchId":"5644539","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2024-11-15T03:23:50Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1169:5905:6:-:0;;;2040:222;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1728:8:14;;;;;;;;;;;-1:-1:-1;;;1728:8:14;;;;;1712:26;1698:40;;;;1781:11;;;;;;;;;;-1:-1:-1;;;1781:11:14;;;;1765:29;1748:46;;1843:13;;;;;;;;;;;;;;;;;;1826:31;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1826:31:14;;;;;;;;;1816:42;;1826:31;1816:42;;;;1804:54;;2177:10:6;2163:24;;2238:17;-1:-1:-1;;;;;2238:15:6;;;:17::i;:::-;2040:222;1169:5905;;8375:365:13;8569:8;;;-1:-1:-1;;;;;;8616:17:13;;-1:-1:-1;;;;;8616:17:13;;;;;;;;;8695:38;;1822:66;;8569:8;;;;;;8695:38;;8466:24;;8695:38;8418:322;;8375:365;:::o;14:290:15:-;84:6;137:2;125:9;116:7;112:23;108:32;105:52;;;153:1;150;143:12;105:52;179:16;;-1:-1:-1;;;;;224:31:15;;214:42;;204:70;;270:1;267;260:12;204:70;293:5;14:290;-1:-1:-1;;;14:290:15:o;309:301::-;438:3;476:6;470:13;522:6;515:4;507:6;503:17;498:3;492:37;584:1;548:16;;573:13;;;-1:-1:-1;548:16:15;309:301;-1:-1:-1;309:301:15:o;:::-;1169:5905:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{},"transformations":[{"type":"insert","offset":5837,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000d7e24a49944f7972ceb826c7557580658f9c3303"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1169:5905:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5102:41;5278:7;;;;5258:28;;:19;:28;;;;;:42;1822:66:13;;5258:42:6;;5329:11;5258:42;5482:132;;5528:10;5525:1;5518:21;5595:4;5589;5582:18;5482:132;5682:4;5676:11;5740:10;5737:1;5730:21;5853:6;5846:4;5843:1;5839:12;5832:28;6171:4;6168:1;6162:4;6155;6152:1;6148:12;6138:8;6131:5;6120:56;6074:4;6070:1;6064:8;6061:18;5977:217;5950:377;;6240:10;6234:4;6227:24;6308:4;6302;6295:18;5950:377;6406:14;6400:4;6397:1;6384:37;6575:4;6569;6553:14;6550:1;6542:6;6535:5;6522:58;6654:16;6760:4;6754;6751:1;6736:29;6873:6;6863:37;;6893:4;6890:1;6883:15;6863:37;6963:4;6960:1;6953:15;3413:361;;;;;;;;;;-1:-1:-1;3413:361:6;;;;;:::i;:::-;;:::i;:::-;;2856:113:14;;;;;;;;;;;;;:::i;:::-;;;571:25:15;;;559:2;544:18;2856:113:14;;;;;;;;3993:169:6;;;;;;;;;;-1:-1:-1;3993:169:6;;;;;:::i;:::-;;:::i;2899:106::-;;;;;;;;;;;;;:::i;:::-;;;783:42:15;771:55;;;753:74;;741:2;726:18;2899:106:6;607:226:15;4383:115:6;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3039:156::-;;;;;;;;;;-1:-1:-1;3039:156:6;;;;;:::i;:::-;;:::i;3413:361::-;2641:26;:24;:26::i;:::-;3554:58:::1;::::0;;;;:41:::1;771:55:15::0;;;3554:58:6::1;::::0;::::1;753:74:15::0;3564:11:6::1;3554:41;::::0;::::1;::::0;726:18:15;;3554:58:6::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3549:118;;3635:21;;;;;;;;;;;;;;3549:118;3751:16;:6;:14;;;:16::i;:::-;3413:361:::0;:::o;2856:113:14:-;2916:7;2942:20;2301:80;;;2312:9;2301:80;;;7926:25:15;2323:11:14;7967:18:15;;;7960:34;;;;2336:14:14;8010:18:15;;;8003:34;2352:13:14;8053:18:15;;;8046:34;2375:4:14;8096:19:15;;;8089:84;2171:7:14;;7898:19:15;;2301:80:14;;;;;;;;;;;;2291:91;;;;;;2284:98;;2118:271;;2942:20;2935:27;;2856:113;:::o;3993:169:6:-;2641:26;:24;:26::i;:::-;4137:18:::1;:6;:16;;;:18::i;2899:106::-:0;2948:7;2974:24;8258:8:13;;;;;8101:172;4383:115:6;4428:15;4462:16;:27;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;3039:156::-;2641:26;:24;:26::i;:::-;3168:20:::1;:9;:18;;;:20::i;8825:231:13:-:0;8977:8;;1822:66;;8977:8;;8963:10;:22;8959:91;;9008:31;;;;;9028:10;9008:31;;;753:74:15;726:18;;9008:31:13;;;;;;;;3957:1292;4047:24;1822:66;4047:43;;4141:25;4177:6;4169:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4240:10;;;:23;;;;;;;-1:-1:-1;4240:23:13;;;;;;;;;;;;;;;;;;;;;;;4320:28;;;;;;;;;:50;;;;-1:-1:-1;4320:50:13;;:28;;:50;;;;:::i;:::-;-1:-1:-1;4501:10:13;;;:17;:21;;4521:1;;4501:21;:::i;:::-;4441:28;;;:20;:28;;;;;;;;;;:50;;:82;;;;;;;;;;;;;;;;4576:586;4599:9;:16;4595:1;:20;;;4576:586;;;4636:17;4656:2;:19;;:33;4676:9;4686:1;4676:12;;;;;;;;;;:::i;:::-;;;;;;;;;;;;4656:33;;;;;;;;;;;;-1:-1:-1;4656:33:13;:47;;;;-1:-1:-1;4802:23:13;;4798:208;;4967:9;4977:1;4967:12;;;;;;;;;;:::i;:::-;;;;;;;;;;;4948:43;;;;;7290:66:15;7278:79;;;4948:43:13;;;7260:98:15;7406:42;7394:55;;7374:18;;;7367:83;7233:18;;4948:43:13;7088:368:15;4798:208:13;5080:1;5019:2;:19;;:33;5039:9;5049:1;5039:12;;;;;;;;;;:::i;:::-;;;;;;;5019:33;;;;;;;;;;;;;;;;;:58;;;:62;;;;;;;;;;;;;;;;;;5145:6;5095:2;:19;;:33;5115:9;5125:1;5115:12;;;;;;;;;;:::i;:::-;;;;;;;;;;;;5095:33;;;;;;;;;;;;-1:-1:-1;5095:33:13;:56;;;;;;;;;;;;;;;-1:-1:-1;4617:3:13;;;;:::i;:::-;;;;4576:586;;;-1:-1:-1;5219:23:13;;;;;;;;;;;3999:1250;;3957:1292;:::o;5585:1415::-;5799:28;;;5677:24;5799:28;;;1822:66;5799:28;;;;;;;;5771:66;;;;;;;;;;;;;;;;;1822;;5677:24;5771:66;;5799:28;;5771:66;;;5799:28;5771:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5905:9;:16;5925:1;5905:21;5901:85;;5949:26;;;;;783:42:15;771:55;;5949:26:13;;;753:74:15;726:18;;5949:26:13;607:226:15;5901:85:13;6066:28;;;6042:21;6066:28;;;;;;;;;;:50;;;;;6212:10;;;:17;6066:50;;;;;6042:21;6212;;;:::i;:::-;6177:57;;6352:18;6334:36;;:14;:36;;;6330:256;;6386:18;6407:2;:10;;6418:18;6407:30;;;;;;;;;;:::i;:::-;;;;;;;;;;;6451:10;;;:26;;6407:30;;;;;-1:-1:-1;6407:30:13;;6451:26;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:39;;;;;;;;;;;6504:32;;;;;;;;;;;;;-1:-1:-1;6504:54:13;:71;;;;;;;;;;6330:256;6629:2;:10;;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;6711:28;;;;;;;;;;;6704:35;6711:28;6629:16;6704:35;:::i;:::-;-1:-1:-1;6704:35:13;;;;;;;;;6797:112;6821:9;:16;6817:1;:20;6797:112;;;6865:2;:19;;:33;6885:9;6895:1;6885:12;;;;;;;;:::i;:::-;;;;;;;;;;;;6865:33;;;;;;;;;;;;-1:-1:-1;6865:33:13;6858:40;;;;;;;6839:3;6797:112;;;-1:-1:-1;6968:25:13;;;;;;;;;;;5629:1371;;;;5585:1415;:::o;8375:365::-;8569:8;;;8616:17;;;8569:8;8616:17;;;;;;;;;8695:38;;1822:66;;8569:8;;;;;;8695:38;;8466:24;;8695:38;8418:322;;8375:365;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:154:15;100:42;93:5;89:54;82:5;79:65;69:93;;158:1;155;148:12;173:247;232:6;285:2;273:9;264:7;260:23;256:32;253:52;;;301:1;298;291:12;253:52;340:9;327:23;359:31;384:5;359:31;:::i;:::-;409:5;173:247;-1:-1:-1;;;173:247:15:o;838:1656::-;1028:4;1057:2;1097;1086:9;1082:18;1127:2;1116:9;1109:21;1150:6;1185;1179:13;1216:6;1208;1201:22;1242:2;1232:12;;1275:2;1264:9;1260:18;1253:25;;1337:2;1327:6;1324:1;1320:14;1309:9;1305:30;1301:39;1375:2;1367:6;1363:15;1396:1;1406:1059;1420:6;1417:1;1414:13;1406:1059;;;1485:22;;;1509:66;1481:95;1469:108;;1600:13;;1687:9;;1698:42;1683:58;1668:74;;1781:11;;1775:18;1813:15;;;1806:27;;;1894:19;;1640:15;;;1926:24;;;2016:21;;;;2061:1;;1984:2;1972:15;;;2075:282;2091:8;2086:3;2083:17;2075:282;;;2172:15;;2189:66;2168:88;2154:103;;2326:17;;;;2119:1;2110:11;;;;;2283:14;;;;2075:282;;;-1:-1:-1;2443:12:15;;;;2380:5;-1:-1:-1;;;2408:15:15;;;;1442:1;1435:9;1406:1059;;;-1:-1:-1;2482:6:15;;838:1656;-1:-1:-1;;;;;;;;838:1656:15:o;2499:277::-;2566:6;2619:2;2607:9;2598:7;2594:23;2590:32;2587:52;;;2635:1;2632;2625:12;2587:52;2667:9;2661:16;2720:5;2713:13;2706:21;2699:5;2696:32;2686:60;;2742:1;2739;2732:12;2781:184;2833:77;2830:1;2823:88;2930:4;2927:1;2920:15;2954:4;2951:1;2944:15;2970:257;3042:4;3036:11;;;3074:17;;3121:18;3106:34;;3142:22;;;3103:62;3100:88;;;3168:18;;:::i;:::-;3204:4;3197:24;2970:257;:::o;3232:334::-;3303:2;3297:9;3359:2;3349:13;;3364:66;3345:86;3333:99;;3462:18;3447:34;;3483:22;;;3444:62;3441:88;;;3509:18;;:::i;:::-;3545:2;3538:22;3232:334;;-1:-1:-1;3232:334:15:o;3571:189::-;3637:4;3670:18;3662:6;3659:30;3656:56;;;3692:18;;:::i;:::-;-1:-1:-1;3737:1:15;3733:14;3749:4;3729:25;;3571:189::o;3765:831::-;3829:5;3882:3;3875:4;3867:6;3863:17;3859:27;3849:55;;3900:1;3897;3890:12;3849:55;3929:6;3923:13;3955:4;3979:66;3995:49;4041:2;3995:49;:::i;:::-;3979:66;:::i;:::-;4067:3;4091:2;4086:3;4079:15;4119:4;4114:3;4110:14;4103:21;;4176:4;4170:2;4167:1;4163:10;4155:6;4151:23;4147:34;4133:48;;4204:3;4196:6;4193:15;4190:35;;;4221:1;4218;4211:12;4190:35;4257:4;4249:6;4245:17;4271:296;4287:6;4282:3;4279:15;4271:296;;;4360:3;4354:10;4408:66;4401:5;4397:78;4390:5;4387:89;4377:117;;4490:1;4487;4480:12;4377:117;4507:18;;4545:12;;;;4304;;4271:296;;;-1:-1:-1;4585:5:15;3765:831;-1:-1:-1;;;;;;3765:831:15:o;4601:1605::-;4720:6;4751:2;4794;4782:9;4773:7;4769:23;4765:32;4762:52;;;4810:1;4807;4800:12;4762:52;4843:9;4837:16;4872:18;4913:2;4905:6;4902:14;4899:34;;;4929:1;4926;4919:12;4899:34;4967:6;4956:9;4952:22;4942:32;;5012:7;5005:4;5001:2;4997:13;4993:27;4983:55;;5034:1;5031;5024:12;4983:55;5063:2;5057:9;5086:66;5102:49;5148:2;5102:49;:::i;5086:66::-;5186:15;;;5268:1;5264:10;;;;5256:19;;5252:28;;;5217:12;;;;5292:19;;;5289:39;;;5324:1;5321;5314:12;5289:39;5356:2;5352;5348:11;5368:808;5384:6;5379:3;5376:15;5368:808;;;5463:3;5457:10;5499:2;5486:11;5483:19;5480:39;;;5515:1;5512;5505:12;5480:39;5542:20;;5585:4;5613:16;;;5631:66;5609:89;5605:98;-1:-1:-1;5602:118:15;;;5716:1;5713;5706:12;5602:118;5746:22;;:::i;:::-;5810:2;5806;5802:11;5796:18;5827:33;5852:7;5827:33;:::i;:::-;5873:22;;5930:11;;;5924:18;;5958:16;;;5955:36;;;5987:1;5984;5977:12;5955:36;6027:75;6094:7;6089:2;6078:8;6074:2;6070:17;6066:26;6027:75;:::i;:::-;6011:14;;;6004:99;6116:18;;-1:-1:-1;;6154:12:15;;;;5401;;5368:808;;;-1:-1:-1;6195:5:15;4601:1605;-1:-1:-1;;;;;;;;4601:1605:15:o;6211:361::-;6305:6;6358:2;6346:9;6337:7;6333:23;6329:32;6326:52;;;6374:1;6371;6364:12;6326:52;6407:9;6401:16;6440:18;6432:6;6429:30;6426:50;;;6472:1;6469;6462:12;6426:50;6495:71;6558:7;6549:6;6538:9;6534:22;6495:71;:::i;:::-;6485:81;6211:361;-1:-1:-1;;;;6211:361:15:o;6577:184::-;6629:77;6626:1;6619:88;6726:4;6723:1;6716:15;6750:4;6747:1;6740:15;6766:128;6833:9;;;6854:11;;;6851:37;;;6868:18;;:::i;:::-;6766:128;;;;:::o;6899:184::-;6951:77;6948:1;6941:88;7048:4;7045:1;7038:15;7072:4;7069:1;7062:15;7461:201;7499:3;7527:10;7572:2;7565:5;7561:14;7599:2;7590:7;7587:15;7584:41;;7605:18;;:::i;:::-;7654:1;7641:15;;7461:201;-1:-1:-1;;;7461:201:15:o;8184:184::-;8236:77;8233:1;8226:88;8333:4;8330:1;8323:15;8357:4;8354:1;8347:15","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c6343000819000a","offset":5203}},"immutableReferences":{"3983":[{"start":249,"length":32},{"start":679,"length":32}],"4802":[{"start":921,"length":32}],"4804":[{"start":961,"length":32}],"4806":[{"start":883,"length":32}]},"transformations":[{"id":"3983","type":"replace","offset":249,"reason":"immutable"},{"id":"3983","type":"replace","offset":679,"reason":"immutable"},{"id":"4802","type":"replace","offset":921,"reason":"immutable"},{"id":"4804","type":"replace","offset":961,"reason":"immutable"},{"id":"4806","type":"replace","offset":883,"reason":"immutable"}],"transformationValues":{"immutables":{"3983":"0x0000000000000000000000000007005729e310000c6003402d8a0fb700da0c00","4802":"0xf0ad1de82e0eb024a6da385106f0bbff7da8aaec15457f8c4d79413072d81d6b","4804":"0xb4bcb154e38601c389396fa918314da42d4626f13ef6d0ceb07e5f5d26b2fbc3","4806":"0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f"}}},"deployment":{"transactionHash":"0xc64f65b2b3a170cf9c124d1cc4544ba821c8d5046a98695569c710fce5616099","blockNumber":"21099018","transactionIndex":"67","deployer":"0xD7e24A49944F7972cEb826C7557580658F9C3303"},"sources":{"src/adapter/Adapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Contracts\nimport { EIP712 } from \"@modules/util/EIP712.sol\";\n\n// Interfaces\nimport { IRegistry } from \"@interfaces/portikus/IRegistry.sol\";\nimport { IAdapter } from \"@adapter/interfaces/IAdapter.sol\";\nimport { IERC173 } from \"@adapter/interfaces/IERC173.sol\";\n\n// Libraries\nimport { ModuleManagerLib } from \"@modules/libraries/ModuleManagerLib.sol\";\n\n//\n//      ____  ____  ____  ____________ ____  _______    ___    ____  ___    ____  ________________\n//     / __ \\/ __ \\/ __ \\/_  __/  _/ //_/ / / / ___/   /   |  / __ \\/   |  / __ \\/_  __/ ____/ __ \\\n//    / /_/ / / / / /_/ / / /  / // ,< / / / /\\__ \\   / /| | / / / / /| | / /_/ / / / / __/ / /_/ /\n//   / ____/ /_/ / _, _/ / / _/ // /| / /_/ /___/ /  / ___ |/ /_/ / ___ |/ ____/ / / / /___/ _, _/\n//  /_/    \\____/_/ |_| /_/ /___/_/ |_\\____//____/  /_/  |_/_____/_/  |_/_/     /_/ /_____/_/ |_|\n//\n//\n/// @title Adapter\n/// @notice The base PortikusV2 adapter contract containing core functionality for managing modules,\n///         executing module functions and implementing the EIP712 standard for typed structured data hashing\n/// @author Laita Labs\ncontract Adapter is IAdapter, EIP712 {\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using ModuleManagerLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice The address of the PortikusV2 contract\n    address internal immutable PORTIKUS_V2;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    /// @param _owner The owner of the adapter, an owner has the ability to install\n    ///        and uninstall modules to the adapter contract\n    constructor(address _owner) {\n        /// The PortikusV2 address is the factory contract that deploys this adapter\n        PORTIKUS_V2 = msg.sender;\n        /// Set the owner of the adapter\n        _owner.setOwner();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               MODIFIERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Verifies that the caller is the owner of the adapter,\n    ///         reverts if the caller is not the owner with UnauthorizedAccount(msg.sender)\n    modifier onlyOwner() {\n        ModuleManagerLib.isOwner();\n        _;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               OWNERSHIP\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IERC173\n    function owner() external view override returns (address) {\n        return ModuleManagerLib.owner();\n    }\n\n    /// @inheritdoc IERC173\n    function transferOwnership(address _newOwner) external override onlyOwner {\n        // Transfer ownership of the adapter\n        _newOwner.setOwner();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                            INSTALL MODULES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IAdapter\n    function install(address module) external onlyOwner {\n        // Make sure the module is registered in the Portikus V2 registry\n        if (!IRegistry(PORTIKUS_V2).isModuleRegistered(address(module))) {\n            revert ModuleNotRegistered();\n        }\n        // Add the module and all of its function selectors to the adapter\n        module.install();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                           UNINSTALL MODULES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IAdapter\n    function uninstall(address module) external onlyOwner {\n        // Remove the module and all of its function selectors from the adapter\n        module.uninstall();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                         GET INSTALLED MODULES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IAdapter\n    function getModules() external view returns (Module[] memory) {\n        return ModuleManagerLib.getModules();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                FALLBACK\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Loads a module for the given function selector:\n    ///         1. Load the module address from the ModuleManagerLib storage\n    ///         2. If the module address is not set, revert\n    ///         3. If the module is not registered, revert\n    ///         4. If the module address is set and registered, delegatecall the module address with the given calldata\n    fallback() external payable {\n        ModuleManagerLib.ModuleStorage storage ms = ModuleManagerLib.modulesStorage();\n        // Get the module address from the selector\n        address module = ms.selectorToModule[msg.sig].moduleAddress;\n        address portikus = PORTIKUS_V2; // inline assembly cannot access immutable constants\n        assembly {\n            // If the module address is not set, revert\n            if iszero(module) {\n                mstore(0, 0x7252c08c) // error ModuleNotFound()\n                revert(0x1c, 0x04)\n            }\n            // Load free memory pointer\n            let x := mload(0x40)\n            // Copy signature\n            mstore(x, 0x1c5ebe2f) // `isModuleRegistered(address)`\n            // Copy module address\n            mstore(add(x, 0x20), module)\n            // Read the registry, reverting upon module being not registered\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left\n                    eq(mload(x), 0x01), // Returned `true`\n                    staticcall(gas(), portikus, add(x, 0x1c), 0x24, x, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x9c4aee9e) // `ModuleNotRegistered()`\n                revert(0x1c, 0x04)\n            }\n            // Copy calldata to free memory\n            calldatacopy(x, 0x00, calldatasize())\n            // Delegatecall to the module address with the given calldata\n            let result := delegatecall(gas(), module, x, calldatasize(), 0x00, 0x00)\n            // Get the size of the returned data\n            let size := returndatasize()\n            // Copy the returned data to free memory\n            returndatacopy(x, 0x00, size)\n            // If the delegatecall was not successful, revert with the returned data\n            if iszero(result) { revert(x, size) }\n            // Return the returned data\n            return(x, size)\n        }\n    }\n\n    /// @notice Allows the adapter to receive ether\n    receive() external payable { }\n}\n"},"src/modules/util/EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Dependencies\nimport { MessageHashUtils } from \"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol\";\n\n// Interfaces\nimport { IEIP712 } from \"@interfaces/util/IEIP712.sol\";\n\n/// @title EIP712\n/// @notice Implements EIP712 domain separator and hashing functionality\n/// @dev This contract is a modified version of the OpenZeppelin EIP712 contract\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/EIP712.sol\ncontract EIP712 is IEIP712 {\n    /*//////////////////////////////////////////////////////////////\n                                CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    // The raw EIP712 domain separator type string\n    bytes private constant TYPE_HASH_RAW =\n        \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\";\n\n    // Raw name\n    string private constant NAME_RAW = \"Portikus\";\n\n    // Raw version\n    string private constant VERSION_RAW = \"2.0.0\";\n\n    /*//////////////////////////////////////////////////////////////\n                               IMMUTABLE\n    //////////////////////////////////////////////////////////////*/\n\n    // Hash of the EIP712 Domain Separator data\n    bytes32 private immutable HASHED_NAME;\n    bytes32 private immutable HASHED_VERSION;\n    bytes32 private immutable TYPE_HASH;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Initializes the EIP712 domain separator fields\n    constructor() {\n        HASHED_NAME = keccak256(bytes(NAME_RAW));\n        HASHED_VERSION = keccak256(bytes(VERSION_RAW));\n        TYPE_HASH = keccak256(abi.encodePacked(TYPE_HASH_RAW));\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                INTERNAL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Returns the domain separator for the current chain\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        // Uses address(this) as the verifyingContract is the adapter that installed a module\n        return keccak256(abi.encode(TYPE_HASH, HASHED_NAME, HASHED_VERSION, block.chainid, address(this)));\n    }\n\n    /// @notice Hashes the EIP712 Domain Separator and the struct hash\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                EXTERNAL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IEIP712\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n}\n"},"src/interfaces/portikus/IRegistry.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @notice Interface for the Portikus V2 registry\ninterface IRegistry {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a new agent is registered\n    event AgentRegistered(address agent);\n\n    /// @notice Emitted when a new module is registered\n    event ModuleRegistered(address module);\n\n    /// @notice Emitted when an agent is unregistered\n    event AgentUnregistered(address agent);\n\n    /// @notice Emitted when a module is unregistered\n    event ModuleUnregistered(address module);\n\n    /*//////////////////////////////////////////////////////////////\n                                REGISTER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Register new agents\n    /// @param _agents The list of agents to register\n    function registerAgent(address[] calldata _agents) external;\n\n    /// @notice Register new modules\n    /// @param _modules The list of modules to register\n    function registerModule(address[] calldata _modules) external;\n\n    /*//////////////////////////////////////////////////////////////\n                                UNREGISTER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Unregister agents\n    /// @param _agents The list of agents to unregister\n    function unregisterAgent(address[] calldata _agents) external;\n\n    /// @notice Unregister modules\n    /// @param _modules The list of modules to unregister\n    function unregisterModule(address[] calldata _modules) external;\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get the list of registered agents\n    function getAgents() external returns (address[] memory);\n\n    /// @notice Get the list of registered modules\n    function getModules() external returns (address[] memory);\n\n    /// @notice Check if an agent is registered\n    function isAgentRegistered(address agent) external returns (bool);\n\n    /// @notice Check if a module is registered\n    function isModuleRegistered(address module) external returns (bool);\n}\n"},"src/adapter/interfaces/IAdapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Interfaces\nimport { IErrors } from \"./IErrors.sol\";\nimport { IERC173 } from \"./IERC173.sol\";\n\n/// @notice Interface for Portikus V2 adapters\ninterface IAdapter is IErrors, IERC173 {\n    /*//////////////////////////////////////////////////////////////\n                                STRUCTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice The module struct contains the address of the module and its selectors\n    struct Module {\n        address module;\n        bytes4[] selectors;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                INSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Add a new module to the adapter, the module must be registered in the Portikus registry\n    /// @param module The address of the module to install\n    function install(address module) external;\n\n    /*//////////////////////////////////////////////////////////////\n                               UNINSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Remove a previously installed module from the adapter\n    /// @param module The address of the module to uninstall\n    function uninstall(address module) external;\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Gets all installed modules and their selectors\n    /// @return modules The installed modules and their selectors\n    function getModules() external view returns (Module[] memory modules);\n}\n"},"src/adapter/interfaces/IERC173.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\n/// @title ERC-173 Contract Ownership Standard\ninterface IERC173 {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev This emits when ownership of a contract changes.\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get the address of the current contract owner\n    /// @return owner_ The address of the owner.\n    function owner() external view returns (address owner_);\n\n    /*//////////////////////////////////////////////////////////////\n                                SETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Set the address of the new owner of the contract\n    /// @dev Set _newOwner to address(0) to renounce any ownership.\n    /// @param _newOwner The address of the new owner of the contract\n    function transferOwnership(address _newOwner) external;\n}\n"},"src/modules/libraries/ModuleManagerLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Interfaces\nimport { IModule } from \"@modules/interfaces/IModule.sol\";\nimport { IAdapter } from \"@adapter/interfaces/IAdapter.sol\";\n\n/// @title Module Manager Library\n/// @notice A library for managing modules in an adapter contract, heavily inspired by the Diamond Proxy (ERC-2535)\n/// @author Laita Labs\nlibrary ModuleManagerLib {\n    /*//////////////////////////////////////////////////////////////\n                                 ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a selector from a module is already set\n    error SelectorAlreadySet(bytes4 selector, address oldModule);\n\n    /// @notice Emitted when trying to uninstall a module that is not installed\n    error ModuleNotInstalled(address module);\n\n    /// @notice Emitted when caller is not the owner\n    error UnauthorizedAccount(address account);\n\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a module is installed\n    event ModuleInstalled(address indexed module);\n\n    /// @notice Emitted when a module is uninstalled\n    event ModuleUninstalled(address indexed module);\n\n    /// @notice Emitted when the adapter ownership is transferred\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /*//////////////////////////////////////////////////////////////\n                                STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice keccak256(abi.encode(uint256(keccak256(\"ModuleManagerLib.modules\")) - 1)) & ~bytes32(uint256(0xff));\n    bytes32 internal constant MODULES_SLOT = 0xcd83f9e468adb540d21d5a132f84948f7344c9d0a65c67a05f93f89a07b57200;\n\n    /// @dev A struct to store a module's address data\n    /// @param moduleAddress The address of the module\n    /// @param functionSelectorPosition The position of the module's function selectors in the\n    ///        ModuleToSelectors.selectors array\n    struct ModuleToFacet {\n        address moduleAddress;\n        uint32 functionSelectorPosition;\n    }\n\n    /// @dev A struct to store a module's function selectors data\n    /// @param selectors The function selectors of the module\n    /// @param moduleAddressPosition The position of the module in the ModuleStorage.modules array\n    struct ModuleToSelectors {\n        bytes4[] selectors;\n        uint32 moduleAddressPosition;\n    }\n\n    /// @custom:storage-location erc7201:ModuleManagerLib.modules\n    /// @notice The structure that defines the storage layout containing all module data, storage collisions are avoided\n    ///         following the ERC-7201 standard\n    /// @param moduleToSelectors A mapping of module addresses to their function selectors\n    /// @param selectorToModule A mapping of function selectors to their module addresses\n    /// @param modules An array of all module addresses\n    /// @param owner The adapter owner\n    struct ModuleStorage {\n        mapping(address => ModuleToSelectors) moduleToSelectors;\n        mapping(bytes4 => ModuleToFacet) selectorToModule;\n        address[] modules;\n        address owner;\n    }\n\n    /// @notice Get the storage slot for the ModuleStorage struct\n    /// @return ms The ModuleStorage struct storage pointer\n    function modulesStorage() internal pure returns (ModuleStorage storage ms) {\n        bytes32 storagePointer = MODULES_SLOT;\n        assembly {\n            ms.slot := storagePointer\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                INSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Install a module in the adapter, adding all of its function selectors\n    /// @param module The address of the module to install\n    function install(address module) internal {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        // Get module function selectors\n        bytes4[] memory selectors = IModule(module).selectors();\n\n        // Add module to modules\n        ms.modules.push(module);\n\n        // Set selectors in moduleToSelectors\n        ms.moduleToSelectors[module].selectors = selectors;\n\n        // Set module address position in moduleToSelectors\n        ms.moduleToSelectors[module].moduleAddressPosition = uint32(ms.modules.length - 1);\n\n        // Set module in selectorToModule\n        for (uint32 i = 0; i < selectors.length; i++) {\n            address oldModule = ms.selectorToModule[selectors[i]].moduleAddress;\n            // If a selector is already set, revert as it would cause a conflict\n            if (oldModule != address(0)) {\n                // If a selector is already set the owner should uninstall the old module first\n                revert SelectorAlreadySet(selectors[i], oldModule);\n            }\n            ms.selectorToModule[selectors[i]].functionSelectorPosition = i;\n            ms.selectorToModule[selectors[i]].moduleAddress = module;\n        }\n        // emit the module installed event\n        emit ModuleInstalled(module);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               UNINSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Remove a module from the adapter, removing all of its function selectors\n    /// @param module The address of the module to uninstall\n    function uninstall(address module) internal {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        // Get module function selectors\n        bytes4[] memory selectors = ms.moduleToSelectors[module].selectors;\n\n        // Check if the module is actually installed\n        if (selectors.length == 0) {\n            revert ModuleNotInstalled(module);\n        }\n\n        // Get the module position in modules\n        uint32 modulePosition = ms.moduleToSelectors[module].moduleAddressPosition;\n        // Get the last module position in modules\n        uint32 lastModulePosition = uint32(ms.modules.length - 1);\n        // If the module is not the last module, swap the module with the last module\n        if (modulePosition != lastModulePosition) {\n            address lastModule = ms.modules[lastModulePosition];\n            ms.modules[modulePosition] = lastModule;\n            ms.moduleToSelectors[lastModule].moduleAddressPosition = modulePosition;\n        }\n        // Remove the last module\n        ms.modules.pop();\n\n        // Remove module from moduleToSelectors\n        delete ms.moduleToSelectors[module];\n\n        // Remove module from selectorToModule\n        for (uint256 i = 0; i < selectors.length; i++) {\n            delete ms.selectorToModule[selectors[i]];\n        }\n        // emit the module uninstalled event\n        emit ModuleUninstalled(module);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get all installed modules and their selectors\n    /// @return modules The installed modules and their selectors\n    function getModules() external view returns (IAdapter.Module[] memory modules) {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        uint256 length = ms.modules.length;\n        modules = new IAdapter.Module[](length);\n        for (uint256 i = 0; i < length; i++) {\n            address module = ms.modules[i];\n            bytes4[] memory selectors = ms.moduleToSelectors[module].selectors;\n            modules[i] = IAdapter.Module(module, selectors);\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                 OWNER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get the owner of the adapter\n    /// @return owner The owner of the adapter\n    function owner() internal view returns (address) {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        return ms.owner;\n    }\n\n    /// @notice Set the owner of the adapter\n    /// @param _owner The new owner of the adapter\n    function setOwner(address _owner) internal {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        // Cache the old owner\n        address oldOwner = ms.owner;\n        // Set the new owner\n        ms.owner = _owner;\n        // Emit the OwnershipTransferred event\n        emit OwnershipTransferred(oldOwner, _owner);\n    }\n\n    /// @notice Check if the caller is the owner of the adapter, revert if not\n    function isOwner() internal view {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        if (msg.sender != ms.owner) {\n            revert UnauthorizedAccount(msg.sender);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.20;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing a bytes32 `messageHash` with\n     * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n     * keccak256, although any bytes32 value can be safely used because the final digest will\n     * be re-hashed.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing an arbitrary `message` with\n     * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n        return\n            keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x00` (data with intended validator).\n     *\n     * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n     * `validator` address. Then hashing the result.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\n     *\n     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n     * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let ptr := mload(0x40)\n            mstore(ptr, hex\"19_01\")\n            mstore(add(ptr, 0x02), domainSeparator)\n            mstore(add(ptr, 0x22), structHash)\n            digest := keccak256(ptr, 0x42)\n        }\n    }\n}\n"},"src/interfaces/util/IEIP712.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @title IEIP712\n/// @notice Interface for the fetching the EIP-712 domain separator\ninterface IEIP712 {\n    /*//////////////////////////////////////////////////////////////\n                                EXTERNAL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Returns the domain separator for the EIP-712 signature\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"src/adapter/interfaces/IErrors.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @notice Interface for errors emitted by Portikus adapters\ninterface IErrors {\n    /*//////////////////////////////////////////////////////////////\n                                 ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a module is not found for the provided selector\n    error ModuleNotFound();\n\n    /// @notice Emitted when trying to install a module that is not registered in the Portikus registry\n    error ModuleNotRegistered();\n}\n"},"src/modules/interfaces/IModule.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @title IModule\n/// @notice Core interfaces that all modules must implement to be compatible with the Portikus protocol\ninterface IModule {\n    /*//////////////////////////////////////////////////////////////\n                                METADATA\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Returns the name of the module\n    function name() external view returns (string memory);\n\n    /// @notice Returns the version of the module\n    function version() external view returns (string memory);\n\n    /*//////////////////////////////////////////////////////////////\n                               SELECTORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Used by the executor to determine which functions should be installed\n    /// @dev The implementation should not include any of the function selectors defined in the IModule interface itself\n    /// @return moduleSelectors An array of function selectors that the module implements\n    function selectors() external pure returns (bytes4[] memory moduleSelectors);\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\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] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2²⁵⁶ + prod0.\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= prod1) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, expect 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\n        for (uint256 i = 0; i < byteArray.length; ++i) {\n            if (byteArray[i] != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 exp;\n        unchecked {\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\n            value >>= exp;\n            result += exp;\n\n            result += SafeCast.toUint(value > 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 isGt;\n        unchecked {\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= isGt * 128;\n            result += isGt * 16;\n\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= isGt * 64;\n            result += isGt * 8;\n\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= isGt * 32;\n            result += isGt * 4;\n\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= isGt * 16;\n            result += isGt * 2;\n\n            result += SafeCast.toUint(value > (1 << 8) - 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev An uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.25+commit.b61c2a91","compilerSettings":{"metadata":{"bytecodeHash":"none"},"libraries":{"src/modules/libraries/ModuleManagerLib.sol":{"ModuleManagerLib":"0xee217191e4bdf5e5bd7b9f8b17592baf33dc7715"}},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun","remappings":[":@adapter/=src/adapter/",":@admin/=src/admin/",":@executors/=src/executors/",":@factory/=src/factory/",":@forge-std/=lib/forge-std/src/",":@interfaces/=src/interfaces/",":@libraries/=src/libraries/",":@mocks/=test/mocks/",":@modules/=src/modules/",":@openzeppelin/=lib/openzeppelin-contracts/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":@prb-test/=lib/prb-test/src/",":@registry/=src/registry/",":@solady/=lib/solady/src/",":@test/=test/",":@types/=src/types/",":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/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":prb-test/=lib/prb-test/src/",":solady/=lib/solady/src/"]},"name":"Adapter","fullyQualifiedName":"src/adapter/Adapter.sol:Adapter"},"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ModuleNotFound","type":"error","inputs":[]},{"name":"ModuleNotInstalled","type":"error","inputs":[{"name":"module","type":"address","internalType":"address"}]},{"name":"ModuleNotRegistered","type":"error","inputs":[]},{"name":"SelectorAlreadySet","type":"error","inputs":[{"name":"selector","type":"bytes4","internalType":"bytes4"},{"name":"oldModule","type":"address","internalType":"address"}]},{"name":"UnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ModuleInstalled","type":"event","inputs":[{"name":"module","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ModuleUninstalled","type":"event","inputs":[{"name":"module","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"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"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getModules","type":"function","inputs":[],"outputs":[{"name":"","type":"tuple[]","components":[{"name":"module","type":"address","internalType":"address"},{"name":"selectors","type":"bytes4[]","internalType":"bytes4[]"}],"internalType":"struct IAdapter.Module[]"}],"stateMutability":"view"},{"name":"install","type":"function","inputs":[{"name":"module","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"_newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"uninstall","type":"function","inputs":[{"name":"module","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.25+commit.b61c2a91"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ModuleNotFound","type":"error"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"ModuleNotInstalled","type":"error"},{"inputs":[],"name":"ModuleNotRegistered","type":"error"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"},{"internalType":"address","name":"oldModule","type":"address"}],"name":"SelectorAlreadySet","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"UnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"module","type":"address"}],"name":"ModuleInstalled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"module","type":"address"}],"name":"ModuleUninstalled","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"},{"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"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getModules","outputs":[{"components":[{"internalType":"address","name":"module","type":"address"},{"internalType":"bytes4[]","name":"selectors","type":"bytes4[]"}],"internalType":"struct IAdapter.Module[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"install","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"module","type":"address"}],"name":"uninstall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"author":"Laita Labs","events":{"OwnershipTransferred(address,address)":{"details":"This emits when ownership of a contract changes."}},"kind":"dev","methods":{"constructor":{"params":{"_owner":"The owner of the adapter, an owner has the ability to install        and uninstall modules to the adapter contract"}},"getModules()":{"returns":{"_0":"The installed modules and their selectors"}},"install(address)":{"params":{"module":"The address of the module to install"}},"owner()":{"returns":{"_0":"The address of the owner."}},"transferOwnership(address)":{"details":"Set _newOwner to address(0) to renounce any ownership.","params":{"_newOwner":"The address of the new owner of the contract"}},"uninstall(address)":{"params":{"module":"The address of the module to uninstall"}}},"title":"Adapter","version":1},"userdoc":{"errors":{"ModuleNotFound()":[{"notice":"Emitted when a module is not found for the provided selector"}],"ModuleNotInstalled(address)":[{"notice":"Emitted when trying to uninstall a module that is not installed"}],"ModuleNotRegistered()":[{"notice":"Emitted when trying to install a module that is not registered in the Portikus registry"}],"SelectorAlreadySet(bytes4,address)":[{"notice":"Emitted when a selector from a module is already set"}],"UnauthorizedAccount(address)":[{"notice":"Emitted when caller is not the owner"}]},"events":{"ModuleInstalled(address)":{"notice":"Emitted when a module is installed"},"ModuleUninstalled(address)":{"notice":"Emitted when a module is uninstalled"}},"kind":"user","methods":{"DOMAIN_SEPARATOR()":{"notice":"Returns the domain separator for the EIP-712 signature"},"getModules()":{"notice":"Gets all installed modules and their selectors"},"install(address)":{"notice":"Add a new module to the adapter, the module must be registered in the Portikus registry"},"owner()":{"notice":"Get the address of the current contract owner"},"transferOwnership(address)":{"notice":"Set the address of the new owner of the contract"},"uninstall(address)":{"notice":"Remove a previously installed module from the adapter"}},"notice":"The base PortikusV2 adapter contract containing core functionality for managing modules,         executing module functions and implementing the EIP712 standard for typed structured data hashing","version":1}},"settings":{"compilationTarget":{"src/adapter/Adapter.sol":"Adapter"},"evmVersion":"cancun","libraries":{"src/modules/libraries/ModuleManagerLib.sol:ModuleManagerLib":"0xee217191e4bdf5e5bd7b9f8b17592baf33dc7715"},"metadata":{"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":1000000},"remappings":[":@adapter/=src/adapter/",":@admin/=src/admin/",":@executors/=src/executors/",":@factory/=src/factory/",":@forge-std/=lib/forge-std/src/",":@interfaces/=src/interfaces/",":@libraries/=src/libraries/",":@mocks/=test/mocks/",":@modules/=src/modules/",":@openzeppelin/=lib/openzeppelin-contracts/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":@prb-test/=lib/prb-test/src/",":@registry/=src/registry/",":@solady/=lib/solady/src/",":@test/=test/",":@types/=src/types/",":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/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":prb-test/=lib/prb-test/src/",":solady/=lib/solady/src/"]},"sources":{"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"keccak256":"0x29074fe5a74bb024c57b3570abf6c74d8bceed3438694d470fd0166a3ecd196a","license":"MIT","urls":["bzz-raw://f4f8435ccbc56e384f4cc9ac9ff491cf30a82f2beac00e33ccc2cf8af3f77cc3","dweb:/ipfs/QmUKJXxTe6nn1qfgnX8xbnboNNAPUuEmJyGqMZCKNiFBgn"]},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"keccak256":"0xcbfb2eaf0f78143e6cdfece5b3a9c1f34612157b56a8d5e07fb58bf0a25ae39f","license":"MIT","urls":["bzz-raw://cad650ec7924430f0f17a4626f8811b7f05b5cafe941de0c23a865fe7b4ae944","dweb:/ipfs/QmdhM7agKE6MYFZFEyeA38e5kB2qMMRHNSiDvYddbeuNWa"]},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"keccak256":"0x3f1998a2904792ff2a576827876638b4917573186537f878d30b23277a3b8d38","license":"MIT","urls":["bzz-raw://a8dfb08ed617c9d874de901e44ac8af7af7b13e7c84000a1da3cdaf6004593e8","dweb:/ipfs/QmPX2hZAvCZJCQNSXcWqhxh3xp6UitwESrw3K2u3aYNqiu"]},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"keccak256":"0x2be34e47fc07baed68c4878618a6e13c13243753c3f656ca1b6e05287c5df4ee","license":"MIT","urls":["bzz-raw://e0bc7f3ae934c76aae959cf061b9764a6dbb2313c4281944dde278cd418599da","dweb:/ipfs/QmYtYLrwC1nPJd86kVrQFQAGeS3XGmhXjCj25LQGfGkugi"]},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"keccak256":"0x8cd59334ed58b8884cd1f775afc9400db702e674e5d6a7a438c655b9de788d7e","license":"MIT","urls":["bzz-raw://99e62c7de7318f413b6352e3f2704ca23e7725ff144e43c8bd574d12dbf29047","dweb:/ipfs/QmSEXG2rBx1VxU2uFTWdiChjDvA4osEY2mesjmoVeVhHko"]},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"keccak256":"0x5c8d4114f077f6803bb89b8b07bfa26dfbf8f2001708e4e7fdf1e8d9ddd42f44","license":"MIT","urls":["bzz-raw://b66c74efa1f994e3ea467b4165da1575857b29d81bec36e94678fe494ce5c615","dweb:/ipfs/QmeXQFdzSJFmN8UdhxMqQwwUh1U2WEha5NoVLbSg3pCJc5"]},"src/adapter/Adapter.sol":{"keccak256":"0x596dc2a8fa8441a66bd832256811787cfd54af3531e37d21af42c5b109e4bcdb","license":"MIT","urls":["bzz-raw://c96a3638a95ea64f7eff34e34f0d170d20eef22a6c207f6fa036543378b4ed05","dweb:/ipfs/QmT73AJ8YDKfY1cCJpbLDD6z1VokF8WV66d6ic1qRDzL5T"]},"src/adapter/interfaces/IAdapter.sol":{"keccak256":"0x4a6ee362ebdea4d6e0991de435c66b4ebca0d9b37c4141fdcd9dda14d1ef0d15","license":"MIT","urls":["bzz-raw://d33b020e15b1caed1e9b0c61ebc027f7c151831ad39b8f4b11a638ae4805fb95","dweb:/ipfs/QmbxkSVFpGFW1a967LJt9GJFFFkn6iMMAD7aoYmDppohSM"]},"src/adapter/interfaces/IERC173.sol":{"keccak256":"0x48493db162654305da7d7fc772283a8a698c41f75c6da037b9345adc17d699b9","license":"MIT","urls":["bzz-raw://b08b5971ac67d9c904f4284804e635d45442cbe2a5c283ea3c9f1db848c17009","dweb:/ipfs/Qme6oEm13zh2WRhVyQ1hnAUrD8jDxnuqqPejhi8FuXHWwj"]},"src/adapter/interfaces/IErrors.sol":{"keccak256":"0x9f9862ce64c17495ee14a8857b6ee1d96ea4a0c8dff024eb1b048c6edce939f5","license":"MIT","urls":["bzz-raw://4c10db9455539e3a7ce160a40059178860bbde441955af4afde5cb3b5b309720","dweb:/ipfs/QmVkP8onLWKi89adAMnuN5sDUQx7jo4BfdGSieYfpa5WQf"]},"src/interfaces/portikus/IRegistry.sol":{"keccak256":"0xbc60d6a2039ab2936e214da84e72412e4c14bf66cf975ccc22abba6e9ebb2568","license":"MIT","urls":["bzz-raw://1c3258e3646e56a3f4415f68340be63632a7ae72728a16d3d0356aedf042204c","dweb:/ipfs/QmSC6DZz4L6SgrGyLHx7SC7KPZGPAyb3HoSi1G3rypieVn"]},"src/interfaces/util/IEIP712.sol":{"keccak256":"0x819e84e203c0696d30b16cfac2f13bfb78ebea7ce8276e3926d6609d7067c739","license":"MIT","urls":["bzz-raw://fed0b340aff3e5c9de9177ac736aef2f6262de035170463c2c759fcabdc366e0","dweb:/ipfs/QmRt8PbhnrbSKkLjdQ7ZnkRAX8WfekehqUpP6rGgFriVdP"]},"src/modules/interfaces/IModule.sol":{"keccak256":"0x45e193e332118e957412e8d28baf3bba58709b5a75b77c1be797f1a0e5108ed0","license":"MIT","urls":["bzz-raw://8855bbc4b849e812f518519c39b5682aec69cd8f46944bc822e22e128e190342","dweb:/ipfs/QmYqRvdXTD8nrTTDXxhj1PvTStZDmWazYJMKarDHxamkY1"]},"src/modules/libraries/ModuleManagerLib.sol":{"keccak256":"0x2775dc07c93f9cd55cda6250894e171f4152a61c01cdfcb4424f88a36c90dca9","license":"MIT","urls":["bzz-raw://6a81b6cb04f8d5088299e8a1dc3ade8aafb90c655413cdc9cdf48192ea5a2d8d","dweb:/ipfs/QmaRgTJiaGUxT8HtzZWW58DCG43V8wcFpWcmngbryJkTbc"]},"src/modules/util/EIP712.sol":{"keccak256":"0x007d56dd03d660c0545e39b20861cb458ab348c6198189d7e0021c5a32254bcb","license":"MIT","urls":["bzz-raw://3517e08708cbdcb03846f1fc7013bcaa24f2c7b996adb6e518823d85b75d2a92","dweb:/ipfs/QmbMRvZtJvjM4hRKx5ckMmruF6Xr82x4SouXLNT1g5tqmM"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"ModuleNotFound()":[{"notice":"Emitted when a module is not found for the provided selector"}],"ModuleNotRegistered()":[{"notice":"Emitted when trying to install a module that is not registered in the Portikus registry"}],"ModuleNotInstalled(address)":[{"notice":"Emitted when trying to uninstall a module that is not installed"}],"UnauthorizedAccount(address)":[{"notice":"Emitted when caller is not the owner"}],"SelectorAlreadySet(bytes4,address)":[{"notice":"Emitted when a selector from a module is already set"}]},"events":{"ModuleInstalled(address)":{"notice":"Emitted when a module is installed"},"ModuleUninstalled(address)":{"notice":"Emitted when a module is uninstalled"}},"notice":"The base PortikusV2 adapter contract containing core functionality for managing modules,         executing module functions and implementing the EIP712 standard for typed structured data hashing","methods":{"owner()":{"notice":"Get the address of the current contract owner"},"getModules()":{"notice":"Gets all installed modules and their selectors"},"install(address)":{"notice":"Add a new module to the adapter, the module must be registered in the Portikus registry"},"DOMAIN_SEPARATOR()":{"notice":"Returns the domain separator for the EIP-712 signature"},"uninstall(address)":{"notice":"Remove a previously installed module from the adapter"},"transferOwnership(address)":{"notice":"Set the address of the new owner of the contract"}},"version":1},"devdoc":{"kind":"dev","title":"Adapter","author":"Laita Labs","events":{"OwnershipTransferred(address,address)":{"details":"This emits when ownership of a contract changes."}},"methods":{"owner()":{"returns":{"_0":"The address of the owner."}},"constructor":{"params":{"_owner":"The owner of the adapter, an owner has the ability to install        and uninstall modules to the adapter contract"}},"getModules()":{"returns":{"_0":"The installed modules and their selectors"}},"install(address)":{"params":{"module":"The address of the module to install"}},"uninstall(address)":{"params":{"module":"The address of the module to uninstall"}},"transferOwnership(address)":{"params":{"_newOwner":"The address of the new owner of the contract"},"details":"Set _newOwner to address(0) to renounce any ownership."}},"version":1},"sourceIds":{"src/adapter/Adapter.sol":{"id":6},"src/modules/util/EIP712.sol":{"id":14},"src/interfaces/util/IEIP712.sol":{"id":11},"src/adapter/interfaces/IERC173.sol":{"id":8},"src/adapter/interfaces/IErrors.sol":{"id":9},"src/modules/interfaces/IModule.sol":{"id":12},"src/adapter/interfaces/IAdapter.sol":{"id":7},"src/interfaces/portikus/IRegistry.sol":{"id":10},"src/modules/libraries/ModuleManagerLib.sol":{"id":13},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"id":0},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"id":1},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"id":3},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"id":4},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"id":2}},"additionalInput":null,"stdJsonInput":{"sources":{"src/adapter/Adapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Contracts\nimport { EIP712 } from \"@modules/util/EIP712.sol\";\n\n// Interfaces\nimport { IRegistry } from \"@interfaces/portikus/IRegistry.sol\";\nimport { IAdapter } from \"@adapter/interfaces/IAdapter.sol\";\nimport { IERC173 } from \"@adapter/interfaces/IERC173.sol\";\n\n// Libraries\nimport { ModuleManagerLib } from \"@modules/libraries/ModuleManagerLib.sol\";\n\n//\n//      ____  ____  ____  ____________ ____  _______    ___    ____  ___    ____  ________________\n//     / __ \\/ __ \\/ __ \\/_  __/  _/ //_/ / / / ___/   /   |  / __ \\/   |  / __ \\/_  __/ ____/ __ \\\n//    / /_/ / / / / /_/ / / /  / // ,< / / / /\\__ \\   / /| | / / / / /| | / /_/ / / / / __/ / /_/ /\n//   / ____/ /_/ / _, _/ / / _/ // /| / /_/ /___/ /  / ___ |/ /_/ / ___ |/ ____/ / / / /___/ _, _/\n//  /_/    \\____/_/ |_| /_/ /___/_/ |_\\____//____/  /_/  |_/_____/_/  |_/_/     /_/ /_____/_/ |_|\n//\n//\n/// @title Adapter\n/// @notice The base PortikusV2 adapter contract containing core functionality for managing modules,\n///         executing module functions and implementing the EIP712 standard for typed structured data hashing\n/// @author Laita Labs\ncontract Adapter is IAdapter, EIP712 {\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using ModuleManagerLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice The address of the PortikusV2 contract\n    address internal immutable PORTIKUS_V2;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    /// @param _owner The owner of the adapter, an owner has the ability to install\n    ///        and uninstall modules to the adapter contract\n    constructor(address _owner) {\n        /// The PortikusV2 address is the factory contract that deploys this adapter\n        PORTIKUS_V2 = msg.sender;\n        /// Set the owner of the adapter\n        _owner.setOwner();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               MODIFIERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Verifies that the caller is the owner of the adapter,\n    ///         reverts if the caller is not the owner with UnauthorizedAccount(msg.sender)\n    modifier onlyOwner() {\n        ModuleManagerLib.isOwner();\n        _;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               OWNERSHIP\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IERC173\n    function owner() external view override returns (address) {\n        return ModuleManagerLib.owner();\n    }\n\n    /// @inheritdoc IERC173\n    function transferOwnership(address _newOwner) external override onlyOwner {\n        // Transfer ownership of the adapter\n        _newOwner.setOwner();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                            INSTALL MODULES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IAdapter\n    function install(address module) external onlyOwner {\n        // Make sure the module is registered in the Portikus V2 registry\n        if (!IRegistry(PORTIKUS_V2).isModuleRegistered(address(module))) {\n            revert ModuleNotRegistered();\n        }\n        // Add the module and all of its function selectors to the adapter\n        module.install();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                           UNINSTALL MODULES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IAdapter\n    function uninstall(address module) external onlyOwner {\n        // Remove the module and all of its function selectors from the adapter\n        module.uninstall();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                         GET INSTALLED MODULES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IAdapter\n    function getModules() external view returns (Module[] memory) {\n        return ModuleManagerLib.getModules();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                FALLBACK\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Loads a module for the given function selector:\n    ///         1. Load the module address from the ModuleManagerLib storage\n    ///         2. If the module address is not set, revert\n    ///         3. If the module is not registered, revert\n    ///         4. If the module address is set and registered, delegatecall the module address with the given calldata\n    fallback() external payable {\n        ModuleManagerLib.ModuleStorage storage ms = ModuleManagerLib.modulesStorage();\n        // Get the module address from the selector\n        address module = ms.selectorToModule[msg.sig].moduleAddress;\n        address portikus = PORTIKUS_V2; // inline assembly cannot access immutable constants\n        assembly {\n            // If the module address is not set, revert\n            if iszero(module) {\n                mstore(0, 0x7252c08c) // error ModuleNotFound()\n                revert(0x1c, 0x04)\n            }\n            // Load free memory pointer\n            let x := mload(0x40)\n            // Copy signature\n            mstore(x, 0x1c5ebe2f) // `isModuleRegistered(address)`\n            // Copy module address\n            mstore(add(x, 0x20), module)\n            // Read the registry, reverting upon module being not registered\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left\n                    eq(mload(x), 0x01), // Returned `true`\n                    staticcall(gas(), portikus, add(x, 0x1c), 0x24, x, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x9c4aee9e) // `ModuleNotRegistered()`\n                revert(0x1c, 0x04)\n            }\n            // Copy calldata to free memory\n            calldatacopy(x, 0x00, calldatasize())\n            // Delegatecall to the module address with the given calldata\n            let result := delegatecall(gas(), module, x, calldatasize(), 0x00, 0x00)\n            // Get the size of the returned data\n            let size := returndatasize()\n            // Copy the returned data to free memory\n            returndatacopy(x, 0x00, size)\n            // If the delegatecall was not successful, revert with the returned data\n            if iszero(result) { revert(x, size) }\n            // Return the returned data\n            return(x, size)\n        }\n    }\n\n    /// @notice Allows the adapter to receive ether\n    receive() external payable { }\n}\n"},"src/modules/util/EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Dependencies\nimport { MessageHashUtils } from \"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol\";\n\n// Interfaces\nimport { IEIP712 } from \"@interfaces/util/IEIP712.sol\";\n\n/// @title EIP712\n/// @notice Implements EIP712 domain separator and hashing functionality\n/// @dev This contract is a modified version of the OpenZeppelin EIP712 contract\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/EIP712.sol\ncontract EIP712 is IEIP712 {\n    /*//////////////////////////////////////////////////////////////\n                                CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    // The raw EIP712 domain separator type string\n    bytes private constant TYPE_HASH_RAW =\n        \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\";\n\n    // Raw name\n    string private constant NAME_RAW = \"Portikus\";\n\n    // Raw version\n    string private constant VERSION_RAW = \"2.0.0\";\n\n    /*//////////////////////////////////////////////////////////////\n                               IMMUTABLE\n    //////////////////////////////////////////////////////////////*/\n\n    // Hash of the EIP712 Domain Separator data\n    bytes32 private immutable HASHED_NAME;\n    bytes32 private immutable HASHED_VERSION;\n    bytes32 private immutable TYPE_HASH;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Initializes the EIP712 domain separator fields\n    constructor() {\n        HASHED_NAME = keccak256(bytes(NAME_RAW));\n        HASHED_VERSION = keccak256(bytes(VERSION_RAW));\n        TYPE_HASH = keccak256(abi.encodePacked(TYPE_HASH_RAW));\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                INTERNAL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Returns the domain separator for the current chain\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        // Uses address(this) as the verifyingContract is the adapter that installed a module\n        return keccak256(abi.encode(TYPE_HASH, HASHED_NAME, HASHED_VERSION, block.chainid, address(this)));\n    }\n\n    /// @notice Hashes the EIP712 Domain Separator and the struct hash\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                EXTERNAL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @inheritdoc IEIP712\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n}\n"},"src/interfaces/util/IEIP712.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @title IEIP712\n/// @notice Interface for the fetching the EIP-712 domain separator\ninterface IEIP712 {\n    /*//////////////////////////////////////////////////////////////\n                                EXTERNAL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Returns the domain separator for the EIP-712 signature\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"src/adapter/interfaces/IERC173.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\n/// @title ERC-173 Contract Ownership Standard\ninterface IERC173 {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev This emits when ownership of a contract changes.\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get the address of the current contract owner\n    /// @return owner_ The address of the owner.\n    function owner() external view returns (address owner_);\n\n    /*//////////////////////////////////////////////////////////////\n                                SETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Set the address of the new owner of the contract\n    /// @dev Set _newOwner to address(0) to renounce any ownership.\n    /// @param _newOwner The address of the new owner of the contract\n    function transferOwnership(address _newOwner) external;\n}\n"},"src/adapter/interfaces/IErrors.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @notice Interface for errors emitted by Portikus adapters\ninterface IErrors {\n    /*//////////////////////////////////////////////////////////////\n                                 ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a module is not found for the provided selector\n    error ModuleNotFound();\n\n    /// @notice Emitted when trying to install a module that is not registered in the Portikus registry\n    error ModuleNotRegistered();\n}\n"},"src/modules/interfaces/IModule.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @title IModule\n/// @notice Core interfaces that all modules must implement to be compatible with the Portikus protocol\ninterface IModule {\n    /*//////////////////////////////////////////////////////////////\n                                METADATA\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Returns the name of the module\n    function name() external view returns (string memory);\n\n    /// @notice Returns the version of the module\n    function version() external view returns (string memory);\n\n    /*//////////////////////////////////////////////////////////////\n                               SELECTORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Used by the executor to determine which functions should be installed\n    /// @dev The implementation should not include any of the function selectors defined in the IModule interface itself\n    /// @return moduleSelectors An array of function selectors that the module implements\n    function selectors() external pure returns (bytes4[] memory moduleSelectors);\n}\n"},"src/adapter/interfaces/IAdapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Interfaces\nimport { IErrors } from \"./IErrors.sol\";\nimport { IERC173 } from \"./IERC173.sol\";\n\n/// @notice Interface for Portikus V2 adapters\ninterface IAdapter is IErrors, IERC173 {\n    /*//////////////////////////////////////////////////////////////\n                                STRUCTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice The module struct contains the address of the module and its selectors\n    struct Module {\n        address module;\n        bytes4[] selectors;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                INSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Add a new module to the adapter, the module must be registered in the Portikus registry\n    /// @param module The address of the module to install\n    function install(address module) external;\n\n    /*//////////////////////////////////////////////////////////////\n                               UNINSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Remove a previously installed module from the adapter\n    /// @param module The address of the module to uninstall\n    function uninstall(address module) external;\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Gets all installed modules and their selectors\n    /// @return modules The installed modules and their selectors\n    function getModules() external view returns (Module[] memory modules);\n}\n"},"src/interfaces/portikus/IRegistry.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n/// @notice Interface for the Portikus V2 registry\ninterface IRegistry {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a new agent is registered\n    event AgentRegistered(address agent);\n\n    /// @notice Emitted when a new module is registered\n    event ModuleRegistered(address module);\n\n    /// @notice Emitted when an agent is unregistered\n    event AgentUnregistered(address agent);\n\n    /// @notice Emitted when a module is unregistered\n    event ModuleUnregistered(address module);\n\n    /*//////////////////////////////////////////////////////////////\n                                REGISTER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Register new agents\n    /// @param _agents The list of agents to register\n    function registerAgent(address[] calldata _agents) external;\n\n    /// @notice Register new modules\n    /// @param _modules The list of modules to register\n    function registerModule(address[] calldata _modules) external;\n\n    /*//////////////////////////////////////////////////////////////\n                                UNREGISTER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Unregister agents\n    /// @param _agents The list of agents to unregister\n    function unregisterAgent(address[] calldata _agents) external;\n\n    /// @notice Unregister modules\n    /// @param _modules The list of modules to unregister\n    function unregisterModule(address[] calldata _modules) external;\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get the list of registered agents\n    function getAgents() external returns (address[] memory);\n\n    /// @notice Get the list of registered modules\n    function getModules() external returns (address[] memory);\n\n    /// @notice Check if an agent is registered\n    function isAgentRegistered(address agent) external returns (bool);\n\n    /// @notice Check if a module is registered\n    function isModuleRegistered(address module) external returns (bool);\n}\n"},"src/modules/libraries/ModuleManagerLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Interfaces\nimport { IModule } from \"@modules/interfaces/IModule.sol\";\nimport { IAdapter } from \"@adapter/interfaces/IAdapter.sol\";\n\n/// @title Module Manager Library\n/// @notice A library for managing modules in an adapter contract, heavily inspired by the Diamond Proxy (ERC-2535)\n/// @author Laita Labs\nlibrary ModuleManagerLib {\n    /*//////////////////////////////////////////////////////////////\n                                 ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a selector from a module is already set\n    error SelectorAlreadySet(bytes4 selector, address oldModule);\n\n    /// @notice Emitted when trying to uninstall a module that is not installed\n    error ModuleNotInstalled(address module);\n\n    /// @notice Emitted when caller is not the owner\n    error UnauthorizedAccount(address account);\n\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when a module is installed\n    event ModuleInstalled(address indexed module);\n\n    /// @notice Emitted when a module is uninstalled\n    event ModuleUninstalled(address indexed module);\n\n    /// @notice Emitted when the adapter ownership is transferred\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /*//////////////////////////////////////////////////////////////\n                                STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice keccak256(abi.encode(uint256(keccak256(\"ModuleManagerLib.modules\")) - 1)) & ~bytes32(uint256(0xff));\n    bytes32 internal constant MODULES_SLOT = 0xcd83f9e468adb540d21d5a132f84948f7344c9d0a65c67a05f93f89a07b57200;\n\n    /// @dev A struct to store a module's address data\n    /// @param moduleAddress The address of the module\n    /// @param functionSelectorPosition The position of the module's function selectors in the\n    ///        ModuleToSelectors.selectors array\n    struct ModuleToFacet {\n        address moduleAddress;\n        uint32 functionSelectorPosition;\n    }\n\n    /// @dev A struct to store a module's function selectors data\n    /// @param selectors The function selectors of the module\n    /// @param moduleAddressPosition The position of the module in the ModuleStorage.modules array\n    struct ModuleToSelectors {\n        bytes4[] selectors;\n        uint32 moduleAddressPosition;\n    }\n\n    /// @custom:storage-location erc7201:ModuleManagerLib.modules\n    /// @notice The structure that defines the storage layout containing all module data, storage collisions are avoided\n    ///         following the ERC-7201 standard\n    /// @param moduleToSelectors A mapping of module addresses to their function selectors\n    /// @param selectorToModule A mapping of function selectors to their module addresses\n    /// @param modules An array of all module addresses\n    /// @param owner The adapter owner\n    struct ModuleStorage {\n        mapping(address => ModuleToSelectors) moduleToSelectors;\n        mapping(bytes4 => ModuleToFacet) selectorToModule;\n        address[] modules;\n        address owner;\n    }\n\n    /// @notice Get the storage slot for the ModuleStorage struct\n    /// @return ms The ModuleStorage struct storage pointer\n    function modulesStorage() internal pure returns (ModuleStorage storage ms) {\n        bytes32 storagePointer = MODULES_SLOT;\n        assembly {\n            ms.slot := storagePointer\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                INSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Install a module in the adapter, adding all of its function selectors\n    /// @param module The address of the module to install\n    function install(address module) internal {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        // Get module function selectors\n        bytes4[] memory selectors = IModule(module).selectors();\n\n        // Add module to modules\n        ms.modules.push(module);\n\n        // Set selectors in moduleToSelectors\n        ms.moduleToSelectors[module].selectors = selectors;\n\n        // Set module address position in moduleToSelectors\n        ms.moduleToSelectors[module].moduleAddressPosition = uint32(ms.modules.length - 1);\n\n        // Set module in selectorToModule\n        for (uint32 i = 0; i < selectors.length; i++) {\n            address oldModule = ms.selectorToModule[selectors[i]].moduleAddress;\n            // If a selector is already set, revert as it would cause a conflict\n            if (oldModule != address(0)) {\n                // If a selector is already set the owner should uninstall the old module first\n                revert SelectorAlreadySet(selectors[i], oldModule);\n            }\n            ms.selectorToModule[selectors[i]].functionSelectorPosition = i;\n            ms.selectorToModule[selectors[i]].moduleAddress = module;\n        }\n        // emit the module installed event\n        emit ModuleInstalled(module);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               UNINSTALL\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Remove a module from the adapter, removing all of its function selectors\n    /// @param module The address of the module to uninstall\n    function uninstall(address module) internal {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        // Get module function selectors\n        bytes4[] memory selectors = ms.moduleToSelectors[module].selectors;\n\n        // Check if the module is actually installed\n        if (selectors.length == 0) {\n            revert ModuleNotInstalled(module);\n        }\n\n        // Get the module position in modules\n        uint32 modulePosition = ms.moduleToSelectors[module].moduleAddressPosition;\n        // Get the last module position in modules\n        uint32 lastModulePosition = uint32(ms.modules.length - 1);\n        // If the module is not the last module, swap the module with the last module\n        if (modulePosition != lastModulePosition) {\n            address lastModule = ms.modules[lastModulePosition];\n            ms.modules[modulePosition] = lastModule;\n            ms.moduleToSelectors[lastModule].moduleAddressPosition = modulePosition;\n        }\n        // Remove the last module\n        ms.modules.pop();\n\n        // Remove module from moduleToSelectors\n        delete ms.moduleToSelectors[module];\n\n        // Remove module from selectorToModule\n        for (uint256 i = 0; i < selectors.length; i++) {\n            delete ms.selectorToModule[selectors[i]];\n        }\n        // emit the module uninstalled event\n        emit ModuleUninstalled(module);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                GETTERS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get all installed modules and their selectors\n    /// @return modules The installed modules and their selectors\n    function getModules() external view returns (IAdapter.Module[] memory modules) {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        uint256 length = ms.modules.length;\n        modules = new IAdapter.Module[](length);\n        for (uint256 i = 0; i < length; i++) {\n            address module = ms.modules[i];\n            bytes4[] memory selectors = ms.moduleToSelectors[module].selectors;\n            modules[i] = IAdapter.Module(module, selectors);\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                 OWNER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Get the owner of the adapter\n    /// @return owner The owner of the adapter\n    function owner() internal view returns (address) {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        return ms.owner;\n    }\n\n    /// @notice Set the owner of the adapter\n    /// @param _owner The new owner of the adapter\n    function setOwner(address _owner) internal {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        // Cache the old owner\n        address oldOwner = ms.owner;\n        // Set the new owner\n        ms.owner = _owner;\n        // Emit the OwnershipTransferred event\n        emit OwnershipTransferred(oldOwner, _owner);\n    }\n\n    /// @notice Check if the caller is the owner of the adapter, revert if not\n    function isOwner() internal view {\n        // Get adapter module storage\n        ModuleStorage storage ms = modulesStorage();\n        if (msg.sender != ms.owner) {\n            revert UnauthorizedAccount(msg.sender);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\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] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2²⁵⁶ + prod0.\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= prod1) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, expect 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        /// @solidity memory-safe-assembly\n        assembly {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\n        for (uint256 i = 0; i < byteArray.length; ++i) {\n            if (byteArray[i] != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 exp;\n        unchecked {\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\n            value >>= exp;\n            result += exp;\n\n            result += SafeCast.toUint(value > 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 isGt;\n        unchecked {\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= isGt * 128;\n            result += isGt * 16;\n\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= isGt * 64;\n            result += isGt * 8;\n\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= isGt * 32;\n            result += isGt * 4;\n\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= isGt * 16;\n            result += isGt * 2;\n\n            result += SafeCast.toUint(value > (1 << 8) - 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev An uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.20;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing a bytes32 `messageHash` with\n     * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n     * keccak256, although any bytes32 value can be safely used because the final digest will\n     * be re-hashed.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing an arbitrary `message` with\n     * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n        return\n            keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x00` (data with intended validator).\n     *\n     * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n     * `validator` address. Then hashing the result.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\n     *\n     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n     * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let ptr := mload(0x40)\n            mstore(ptr, hex\"19_01\")\n            mstore(add(ptr, 0x02), domainSeparator)\n            mstore(add(ptr, 0x22), structHash)\n            digest := keccak256(ptr, 0x42)\n        }\n    }\n}\n"}},"language":"Solidity","settings":{"metadata":{"bytecodeHash":"none"},"libraries":{"src/modules/libraries/ModuleManagerLib.sol":{"ModuleManagerLib":"0xee217191e4bdf5e5bd7b9f8b17592baf33dc7715"}},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun","remappings":[":@adapter/=src/adapter/",":@admin/=src/admin/",":@executors/=src/executors/",":@factory/=src/factory/",":@forge-std/=lib/forge-std/src/",":@interfaces/=src/interfaces/",":@libraries/=src/libraries/",":@mocks/=test/mocks/",":@modules/=src/modules/",":@openzeppelin/=lib/openzeppelin-contracts/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":@prb-test/=lib/prb-test/src/",":@registry/=src/registry/",":@solady/=lib/solady/src/",":@test/=test/",":@types/=src/types/",":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/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":prb-test/=lib/prb-test/src/",":solady/=lib/solady/src/"]}},"stdJsonOutput":{"sources":{"src/adapter/Adapter.sol":{"id":6},"src/modules/util/EIP712.sol":{"id":14},"src/interfaces/util/IEIP712.sol":{"id":11},"src/adapter/interfaces/IERC173.sol":{"id":8},"src/adapter/interfaces/IErrors.sol":{"id":9},"src/modules/interfaces/IModule.sol":{"id":12},"src/adapter/interfaces/IAdapter.sol":{"id":7},"src/interfaces/portikus/IRegistry.sol":{"id":10},"src/modules/libraries/ModuleManagerLib.sol":{"id":13},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"id":0},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"id":1},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"id":3},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"id":4},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"id":2}},"contracts":{"src/adapter/Adapter.sol":{"Adapter":{"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ModuleNotFound","type":"error","inputs":[]},{"name":"ModuleNotInstalled","type":"error","inputs":[{"name":"module","type":"address","internalType":"address"}]},{"name":"ModuleNotRegistered","type":"error","inputs":[]},{"name":"SelectorAlreadySet","type":"error","inputs":[{"name":"selector","type":"bytes4","internalType":"bytes4"},{"name":"oldModule","type":"address","internalType":"address"}]},{"name":"UnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ModuleInstalled","type":"event","inputs":[{"name":"module","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ModuleUninstalled","type":"event","inputs":[{"name":"module","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"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"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getModules","type":"function","inputs":[],"outputs":[{"name":"","type":"tuple[]","components":[{"name":"module","type":"address","internalType":"address"},{"name":"selectors","type":"bytes4[]","internalType":"bytes4[]"}],"internalType":"struct IAdapter.Module[]"}],"stateMutability":"view"},{"name":"install","type":"function","inputs":[{"name":"module","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"_newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"uninstall","type":"function","inputs":[{"name":"module","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ModuleNotFound\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"module\",\"type\":\"address\"}],\"name\":\"ModuleNotInstalled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ModuleNotRegistered\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"},{\"internalType\":\"address\",\"name\":\"oldModule\",\"type\":\"address\"}],\"name\":\"SelectorAlreadySet\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"UnauthorizedAccount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"module\",\"type\":\"address\"}],\"name\":\"ModuleInstalled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"module\",\"type\":\"address\"}],\"name\":\"ModuleUninstalled\",\"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\"},{\"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\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getModules\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"module\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"struct IAdapter.Module[]\",\"name\":\"\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"module\",\"type\":\"address\"}],\"name\":\"install\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"module\",\"type\":\"address\"}],\"name\":\"uninstall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"author\":\"Laita Labs\",\"events\":{\"OwnershipTransferred(address,address)\":{\"details\":\"This emits when ownership of a contract changes.\"}},\"kind\":\"dev\",\"methods\":{\"constructor\":{\"params\":{\"_owner\":\"The owner of the adapter, an owner has the ability to install        and uninstall modules to the adapter contract\"}},\"getModules()\":{\"returns\":{\"_0\":\"The installed modules and their selectors\"}},\"install(address)\":{\"params\":{\"module\":\"The address of the module to install\"}},\"owner()\":{\"returns\":{\"_0\":\"The address of the owner.\"}},\"transferOwnership(address)\":{\"details\":\"Set _newOwner to address(0) to renounce any ownership.\",\"params\":{\"_newOwner\":\"The address of the new owner of the contract\"}},\"uninstall(address)\":{\"params\":{\"module\":\"The address of the module to uninstall\"}}},\"title\":\"Adapter\",\"version\":1},\"userdoc\":{\"errors\":{\"ModuleNotFound()\":[{\"notice\":\"Emitted when a module is not found for the provided selector\"}],\"ModuleNotInstalled(address)\":[{\"notice\":\"Emitted when trying to uninstall a module that is not installed\"}],\"ModuleNotRegistered()\":[{\"notice\":\"Emitted when trying to install a module that is not registered in the Portikus registry\"}],\"SelectorAlreadySet(bytes4,address)\":[{\"notice\":\"Emitted when a selector from a module is already set\"}],\"UnauthorizedAccount(address)\":[{\"notice\":\"Emitted when caller is not the owner\"}]},\"events\":{\"ModuleInstalled(address)\":{\"notice\":\"Emitted when a module is installed\"},\"ModuleUninstalled(address)\":{\"notice\":\"Emitted when a module is uninstalled\"}},\"kind\":\"user\",\"methods\":{\"DOMAIN_SEPARATOR()\":{\"notice\":\"Returns the domain separator for the EIP-712 signature\"},\"getModules()\":{\"notice\":\"Gets all installed modules and their selectors\"},\"install(address)\":{\"notice\":\"Add a new module to the adapter, the module must be registered in the Portikus registry\"},\"owner()\":{\"notice\":\"Get the address of the current contract owner\"},\"transferOwnership(address)\":{\"notice\":\"Set the address of the new owner of the contract\"},\"uninstall(address)\":{\"notice\":\"Remove a previously installed module from the adapter\"}},\"notice\":\"The base PortikusV2 adapter contract containing core functionality for managing modules,         executing module functions and implementing the EIP712 standard for typed structured data hashing\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/adapter/Adapter.sol\":\"Adapter\"},\"evmVersion\":\"cancun\",\"libraries\":{\"src/modules/libraries/ModuleManagerLib.sol:ModuleManagerLib\":\"0xee217191e4bdf5e5bd7b9f8b17592baf33dc7715\"},\"metadata\":{\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[\":@adapter/=src/adapter/\",\":@admin/=src/admin/\",\":@executors/=src/executors/\",\":@factory/=src/factory/\",\":@forge-std/=lib/forge-std/src/\",\":@interfaces/=src/interfaces/\",\":@libraries/=src/libraries/\",\":@mocks/=test/mocks/\",\":@modules/=src/modules/\",\":@openzeppelin/=lib/openzeppelin-contracts/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":@prb-test/=lib/prb-test/src/\",\":@registry/=src/registry/\",\":@solady/=lib/solady/src/\",\":@test/=test/\",\":@types/=src/types/\",\":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/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":prb-test/=lib/prb-test/src/\",\":solady/=lib/solady/src/\"]},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/Panic.sol\":{\"keccak256\":\"0x29074fe5a74bb024c57b3570abf6c74d8bceed3438694d470fd0166a3ecd196a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f4f8435ccbc56e384f4cc9ac9ff491cf30a82f2beac00e33ccc2cf8af3f77cc3\",\"dweb:/ipfs/QmUKJXxTe6nn1qfgnX8xbnboNNAPUuEmJyGqMZCKNiFBgn\"]},\"lib/openzeppelin-contracts/contracts/utils/Strings.sol\":{\"keccak256\":\"0xcbfb2eaf0f78143e6cdfece5b3a9c1f34612157b56a8d5e07fb58bf0a25ae39f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cad650ec7924430f0f17a4626f8811b7f05b5cafe941de0c23a865fe7b4ae944\",\"dweb:/ipfs/QmdhM7agKE6MYFZFEyeA38e5kB2qMMRHNSiDvYddbeuNWa\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol\":{\"keccak256\":\"0x3f1998a2904792ff2a576827876638b4917573186537f878d30b23277a3b8d38\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a8dfb08ed617c9d874de901e44ac8af7af7b13e7c84000a1da3cdaf6004593e8\",\"dweb:/ipfs/QmPX2hZAvCZJCQNSXcWqhxh3xp6UitwESrw3K2u3aYNqiu\"]},\"lib/openzeppelin-contracts/contracts/utils/math/Math.sol\":{\"keccak256\":\"0x2be34e47fc07baed68c4878618a6e13c13243753c3f656ca1b6e05287c5df4ee\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e0bc7f3ae934c76aae959cf061b9764a6dbb2313c4281944dde278cd418599da\",\"dweb:/ipfs/QmYtYLrwC1nPJd86kVrQFQAGeS3XGmhXjCj25LQGfGkugi\"]},\"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol\":{\"keccak256\":\"0x8cd59334ed58b8884cd1f775afc9400db702e674e5d6a7a438c655b9de788d7e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://99e62c7de7318f413b6352e3f2704ca23e7725ff144e43c8bd574d12dbf29047\",\"dweb:/ipfs/QmSEXG2rBx1VxU2uFTWdiChjDvA4osEY2mesjmoVeVhHko\"]},\"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0x5c8d4114f077f6803bb89b8b07bfa26dfbf8f2001708e4e7fdf1e8d9ddd42f44\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b66c74efa1f994e3ea467b4165da1575857b29d81bec36e94678fe494ce5c615\",\"dweb:/ipfs/QmeXQFdzSJFmN8UdhxMqQwwUh1U2WEha5NoVLbSg3pCJc5\"]},\"src/adapter/Adapter.sol\":{\"keccak256\":\"0x596dc2a8fa8441a66bd832256811787cfd54af3531e37d21af42c5b109e4bcdb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c96a3638a95ea64f7eff34e34f0d170d20eef22a6c207f6fa036543378b4ed05\",\"dweb:/ipfs/QmT73AJ8YDKfY1cCJpbLDD6z1VokF8WV66d6ic1qRDzL5T\"]},\"src/adapter/interfaces/IAdapter.sol\":{\"keccak256\":\"0x4a6ee362ebdea4d6e0991de435c66b4ebca0d9b37c4141fdcd9dda14d1ef0d15\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d33b020e15b1caed1e9b0c61ebc027f7c151831ad39b8f4b11a638ae4805fb95\",\"dweb:/ipfs/QmbxkSVFpGFW1a967LJt9GJFFFkn6iMMAD7aoYmDppohSM\"]},\"src/adapter/interfaces/IERC173.sol\":{\"keccak256\":\"0x48493db162654305da7d7fc772283a8a698c41f75c6da037b9345adc17d699b9\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b08b5971ac67d9c904f4284804e635d45442cbe2a5c283ea3c9f1db848c17009\",\"dweb:/ipfs/Qme6oEm13zh2WRhVyQ1hnAUrD8jDxnuqqPejhi8FuXHWwj\"]},\"src/adapter/interfaces/IErrors.sol\":{\"keccak256\":\"0x9f9862ce64c17495ee14a8857b6ee1d96ea4a0c8dff024eb1b048c6edce939f5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4c10db9455539e3a7ce160a40059178860bbde441955af4afde5cb3b5b309720\",\"dweb:/ipfs/QmVkP8onLWKi89adAMnuN5sDUQx7jo4BfdGSieYfpa5WQf\"]},\"src/interfaces/portikus/IRegistry.sol\":{\"keccak256\":\"0xbc60d6a2039ab2936e214da84e72412e4c14bf66cf975ccc22abba6e9ebb2568\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1c3258e3646e56a3f4415f68340be63632a7ae72728a16d3d0356aedf042204c\",\"dweb:/ipfs/QmSC6DZz4L6SgrGyLHx7SC7KPZGPAyb3HoSi1G3rypieVn\"]},\"src/interfaces/util/IEIP712.sol\":{\"keccak256\":\"0x819e84e203c0696d30b16cfac2f13bfb78ebea7ce8276e3926d6609d7067c739\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://fed0b340aff3e5c9de9177ac736aef2f6262de035170463c2c759fcabdc366e0\",\"dweb:/ipfs/QmRt8PbhnrbSKkLjdQ7ZnkRAX8WfekehqUpP6rGgFriVdP\"]},\"src/modules/interfaces/IModule.sol\":{\"keccak256\":\"0x45e193e332118e957412e8d28baf3bba58709b5a75b77c1be797f1a0e5108ed0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8855bbc4b849e812f518519c39b5682aec69cd8f46944bc822e22e128e190342\",\"dweb:/ipfs/QmYqRvdXTD8nrTTDXxhj1PvTStZDmWazYJMKarDHxamkY1\"]},\"src/modules/libraries/ModuleManagerLib.sol\":{\"keccak256\":\"0x2775dc07c93f9cd55cda6250894e171f4152a61c01cdfcb4424f88a36c90dca9\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a81b6cb04f8d5088299e8a1dc3ade8aafb90c655413cdc9cdf48192ea5a2d8d\",\"dweb:/ipfs/QmaRgTJiaGUxT8HtzZWW58DCG43V8wcFpWcmngbryJkTbc\"]},\"src/modules/util/EIP712.sol\":{\"keccak256\":\"0x007d56dd03d660c0545e39b20861cb458ab348c6198189d7e0021c5a32254bcb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3517e08708cbdcb03846f1fc7013bcaa24f2c7b996adb6e518823d85b75d2a92\",\"dweb:/ipfs/QmbMRvZtJvjM4hRKx5ckMmruF6Xr82x4SouXLNT1g5tqmM\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"ModuleNotFound()":[{"notice":"Emitted when a module is not found for the provided selector"}],"ModuleNotRegistered()":[{"notice":"Emitted when trying to install a module that is not registered in the Portikus registry"}],"ModuleNotInstalled(address)":[{"notice":"Emitted when trying to uninstall a module that is not installed"}],"UnauthorizedAccount(address)":[{"notice":"Emitted when caller is not the owner"}],"SelectorAlreadySet(bytes4,address)":[{"notice":"Emitted when a selector from a module is already set"}]},"events":{"ModuleInstalled(address)":{"notice":"Emitted when a module is installed"},"ModuleUninstalled(address)":{"notice":"Emitted when a module is uninstalled"}},"notice":"The base PortikusV2 adapter contract containing core functionality for managing modules,         executing module functions and implementing the EIP712 standard for typed structured data hashing","methods":{"owner()":{"notice":"Get the address of the current contract owner"},"getModules()":{"notice":"Gets all installed modules and their selectors"},"install(address)":{"notice":"Add a new module to the adapter, the module must be registered in the Portikus registry"},"DOMAIN_SEPARATOR()":{"notice":"Returns the domain separator for the EIP-712 signature"},"uninstall(address)":{"notice":"Remove a previously installed module from the adapter"},"transferOwnership(address)":{"notice":"Set the address of the new owner of the contract"}},"version":1},"devdoc":{"kind":"dev","title":"Adapter","author":"Laita Labs","events":{"OwnershipTransferred(address,address)":{"details":"This emits when ownership of a contract changes."}},"methods":{"owner()":{"returns":{"_0":"The address of the owner."}},"constructor":{"params":{"_owner":"The owner of the adapter, an owner has the ability to install        and uninstall modules to the adapter contract"}},"getModules()":{"returns":{"_0":"The installed modules and their selectors"}},"install(address)":{"params":{"module":"The address of the module to install"}},"uninstall(address)":{"params":{"module":"The address of the module to uninstall"}},"transferOwnership(address)":{"params":{"_newOwner":"The address of the new owner of the contract"},"details":"Set _newOwner to address(0) to renounce any ownership."}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"1169:5905:6:-:0;;;2040:222;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1728:8:14;;;;;;;;;;;-1:-1:-1;;;1728:8:14;;;;;1712:26;1698:40;;;;1781:11;;;;;;;;;;-1:-1:-1;;;1781:11:14;;;;1765:29;1748:46;;1843:13;;;;;;;;;;;;;;;;;;1826:31;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1826:31:14;;;;;;;;;1816:42;;1826:31;1816:42;;;;1804:54;;2177:10:6;2163:24;;2238:17;-1:-1:-1;;;;;2238:15:6;;;:17::i;:::-;2040:222;1169:5905;;8375:365:13;8569:8;;;-1:-1:-1;;;;;;8616:17:13;;-1:-1:-1;;;;;8616:17:13;;;;;;;;;8695:38;;1822:66;;8569:8;;;;;;8695:38;;8466:24;;8695:38;8418:322;;8375:365;:::o;14:290:15:-;84:6;137:2;125:9;116:7;112:23;108:32;105:52;;;153:1;150;143:12;105:52;179:16;;-1:-1:-1;;;;;224:31:15;;214:42;;204:70;;270:1;267;260:12;204:70;293:5;14:290;-1:-1:-1;;;14:290:15:o;309:301::-;438:3;476:6;470:13;522:6;515:4;507:6;503:17;498:3;492:37;584:1;548:16;;573:13;;;-1:-1:-1;548:16:15;309:301;-1:-1:-1;309:301:15:o;:::-;1169:5905:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1169:5905:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5102:41;5278:7;;;;5258:28;;:19;:28;;;;;:42;1822:66:13;;5258:42:6;;5329:11;5258:42;5482:132;;5528:10;5525:1;5518:21;5595:4;5589;5582:18;5482:132;5682:4;5676:11;5740:10;5737:1;5730:21;5853:6;5846:4;5843:1;5839:12;5832:28;6171:4;6168:1;6162:4;6155;6152:1;6148:12;6138:8;6131:5;6120:56;6074:4;6070:1;6064:8;6061:18;5977:217;5950:377;;6240:10;6234:4;6227:24;6308:4;6302;6295:18;5950:377;6406:14;6400:4;6397:1;6384:37;6575:4;6569;6553:14;6550:1;6542:6;6535:5;6522:58;6654:16;6760:4;6754;6751:1;6736:29;6873:6;6863:37;;6893:4;6890:1;6883:15;6863:37;6963:4;6960:1;6953:15;3413:361;;;;;;;;;;-1:-1:-1;3413:361:6;;;;;:::i;:::-;;:::i;:::-;;2856:113:14;;;;;;;;;;;;;:::i;:::-;;;571:25:15;;;559:2;544:18;2856:113:14;;;;;;;;3993:169:6;;;;;;;;;;-1:-1:-1;3993:169:6;;;;;:::i;:::-;;:::i;2899:106::-;;;;;;;;;;;;;:::i;:::-;;;783:42:15;771:55;;;753:74;;741:2;726:18;2899:106:6;607:226:15;4383:115:6;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3039:156::-;;;;;;;;;;-1:-1:-1;3039:156:6;;;;;:::i;:::-;;:::i;3413:361::-;2641:26;:24;:26::i;:::-;3554:58:::1;::::0;;;;:41:::1;771:55:15::0;;;3554:58:6::1;::::0;::::1;753:74:15::0;3564:11:6::1;3554:41;::::0;::::1;::::0;726:18:15;;3554:58:6::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3549:118;;3635:21;;;;;;;;;;;;;;3549:118;3751:16;:6;:14;;;:16::i;:::-;3413:361:::0;:::o;2856:113:14:-;2916:7;2942:20;2301:80;;;2312:9;2301:80;;;7926:25:15;2323:11:14;7967:18:15;;;7960:34;;;;2336:14:14;8010:18:15;;;8003:34;2352:13:14;8053:18:15;;;8046:34;2375:4:14;8096:19:15;;;8089:84;2171:7:14;;7898:19:15;;2301:80:14;;;;;;;;;;;;2291:91;;;;;;2284:98;;2118:271;;2942:20;2935:27;;2856:113;:::o;3993:169:6:-;2641:26;:24;:26::i;:::-;4137:18:::1;:6;:16;;;:18::i;2899:106::-:0;2948:7;2974:24;8258:8:13;;;;;8101:172;4383:115:6;4428:15;4462:16;:27;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;3039:156::-;2641:26;:24;:26::i;:::-;3168:20:::1;:9;:18;;;:20::i;8825:231:13:-:0;8977:8;;1822:66;;8977:8;;8963:10;:22;8959:91;;9008:31;;;;;9028:10;9008:31;;;753:74:15;726:18;;9008:31:13;;;;;;;;3957:1292;4047:24;1822:66;4047:43;;4141:25;4177:6;4169:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4240:10;;;:23;;;;;;;-1:-1:-1;4240:23:13;;;;;;;;;;;;;;;;;;;;;;;4320:28;;;;;;;;;:50;;;;-1:-1:-1;4320:50:13;;:28;;:50;;;;:::i;:::-;-1:-1:-1;4501:10:13;;;:17;:21;;4521:1;;4501:21;:::i;:::-;4441:28;;;:20;:28;;;;;;;;;;:50;;:82;;;;;;;;;;;;;;;;4576:586;4599:9;:16;4595:1;:20;;;4576:586;;;4636:17;4656:2;:19;;:33;4676:9;4686:1;4676:12;;;;;;;;;;:::i;:::-;;;;;;;;;;;;4656:33;;;;;;;;;;;;-1:-1:-1;4656:33:13;:47;;;;-1:-1:-1;4802:23:13;;4798:208;;4967:9;4977:1;4967:12;;;;;;;;;;:::i;:::-;;;;;;;;;;;4948:43;;;;;7290:66:15;7278:79;;;4948:43:13;;;7260:98:15;7406:42;7394:55;;7374:18;;;7367:83;7233:18;;4948:43:13;7088:368:15;4798:208:13;5080:1;5019:2;:19;;:33;5039:9;5049:1;5039:12;;;;;;;;;;:::i;:::-;;;;;;;5019:33;;;;;;;;;;;;;;;;;:58;;;:62;;;;;;;;;;;;;;;;;;5145:6;5095:2;:19;;:33;5115:9;5125:1;5115:12;;;;;;;;;;:::i;:::-;;;;;;;;;;;;5095:33;;;;;;;;;;;;-1:-1:-1;5095:33:13;:56;;;;;;;;;;;;;;;-1:-1:-1;4617:3:13;;;;:::i;:::-;;;;4576:586;;;-1:-1:-1;5219:23:13;;;;;;;;;;;3999:1250;;3957:1292;:::o;5585:1415::-;5799:28;;;5677:24;5799:28;;;1822:66;5799:28;;;;;;;;5771:66;;;;;;;;;;;;;;;;;1822;;5677:24;5771:66;;5799:28;;5771:66;;;5799:28;5771:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5905:9;:16;5925:1;5905:21;5901:85;;5949:26;;;;;783:42:15;771:55;;5949:26:13;;;753:74:15;726:18;;5949:26:13;607:226:15;5901:85:13;6066:28;;;6042:21;6066:28;;;;;;;;;;:50;;;;;6212:10;;;:17;6066:50;;;;;6042:21;6212;;;:::i;:::-;6177:57;;6352:18;6334:36;;:14;:36;;;6330:256;;6386:18;6407:2;:10;;6418:18;6407:30;;;;;;;;;;:::i;:::-;;;;;;;;;;;6451:10;;;:26;;6407:30;;;;;-1:-1:-1;6407:30:13;;6451:26;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:39;;;;;;;;;;;6504:32;;;;;;;;;;;;;-1:-1:-1;6504:54:13;:71;;;;;;;;;;6330:256;6629:2;:10;;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;6711:28;;;;;;;;;;;6704:35;6711:28;6629:16;6704:35;:::i;:::-;-1:-1:-1;6704:35:13;;;;;;;;;6797:112;6821:9;:16;6817:1;:20;6797:112;;;6865:2;:19;;:33;6885:9;6895:1;6885:12;;;;;;;;:::i;:::-;;;;;;;;;;;;6865:33;;;;;;;;;;;;-1:-1:-1;6865:33:13;6858:40;;;;;;;6839:3;6797:112;;;-1:-1:-1;6968:25:13;;;;;;;;;;;5629:1371;;;;5585:1415;:::o;8375:365::-;8569:8;;;8616:17;;;8569:8;8616:17;;;;;;;;;8695:38;;1822:66;;8569:8;;;;;;8695:38;;8466:24;;8695:38;8418:322;;8375:365;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:154:15;100:42;93:5;89:54;82:5;79:65;69:93;;158:1;155;148:12;173:247;232:6;285:2;273:9;264:7;260:23;256:32;253:52;;;301:1;298;291:12;253:52;340:9;327:23;359:31;384:5;359:31;:::i;:::-;409:5;173:247;-1:-1:-1;;;173:247:15:o;838:1656::-;1028:4;1057:2;1097;1086:9;1082:18;1127:2;1116:9;1109:21;1150:6;1185;1179:13;1216:6;1208;1201:22;1242:2;1232:12;;1275:2;1264:9;1260:18;1253:25;;1337:2;1327:6;1324:1;1320:14;1309:9;1305:30;1301:39;1375:2;1367:6;1363:15;1396:1;1406:1059;1420:6;1417:1;1414:13;1406:1059;;;1485:22;;;1509:66;1481:95;1469:108;;1600:13;;1687:9;;1698:42;1683:58;1668:74;;1781:11;;1775:18;1813:15;;;1806:27;;;1894:19;;1640:15;;;1926:24;;;2016:21;;;;2061:1;;1984:2;1972:15;;;2075:282;2091:8;2086:3;2083:17;2075:282;;;2172:15;;2189:66;2168:88;2154:103;;2326:17;;;;2119:1;2110:11;;;;;2283:14;;;;2075:282;;;-1:-1:-1;2443:12:15;;;;2380:5;-1:-1:-1;;;2408:15:15;;;;1442:1;1435:9;1406:1059;;;-1:-1:-1;2482:6:15;;838:1656;-1:-1:-1;;;;;;;;838:1656:15:o;2499:277::-;2566:6;2619:2;2607:9;2598:7;2594:23;2590:32;2587:52;;;2635:1;2632;2625:12;2587:52;2667:9;2661:16;2720:5;2713:13;2706:21;2699:5;2696:32;2686:60;;2742:1;2739;2732:12;2781:184;2833:77;2830:1;2823:88;2930:4;2927:1;2920:15;2954:4;2951:1;2944:15;2970:257;3042:4;3036:11;;;3074:17;;3121:18;3106:34;;3142:22;;;3103:62;3100:88;;;3168:18;;:::i;:::-;3204:4;3197:24;2970:257;:::o;3232:334::-;3303:2;3297:9;3359:2;3349:13;;3364:66;3345:86;3333:99;;3462:18;3447:34;;3483:22;;;3444:62;3441:88;;;3509:18;;:::i;:::-;3545:2;3538:22;3232:334;;-1:-1:-1;3232:334:15:o;3571:189::-;3637:4;3670:18;3662:6;3659:30;3656:56;;;3692:18;;:::i;:::-;-1:-1:-1;3737:1:15;3733:14;3749:4;3729:25;;3571:189::o;3765:831::-;3829:5;3882:3;3875:4;3867:6;3863:17;3859:27;3849:55;;3900:1;3897;3890:12;3849:55;3929:6;3923:13;3955:4;3979:66;3995:49;4041:2;3995:49;:::i;:::-;3979:66;:::i;:::-;4067:3;4091:2;4086:3;4079:15;4119:4;4114:3;4110:14;4103:21;;4176:4;4170:2;4167:1;4163:10;4155:6;4151:23;4147:34;4133:48;;4204:3;4196:6;4193:15;4190:35;;;4221:1;4218;4211:12;4190:35;4257:4;4249:6;4245:17;4271:296;4287:6;4282:3;4279:15;4271:296;;;4360:3;4354:10;4408:66;4401:5;4397:78;4390:5;4387:89;4377:117;;4490:1;4487;4480:12;4377:117;4507:18;;4545:12;;;;4304;;4271:296;;;-1:-1:-1;4585:5:15;3765:831;-1:-1:-1;;;;;;3765:831:15:o;4601:1605::-;4720:6;4751:2;4794;4782:9;4773:7;4769:23;4765:32;4762:52;;;4810:1;4807;4800:12;4762:52;4843:9;4837:16;4872:18;4913:2;4905:6;4902:14;4899:34;;;4929:1;4926;4919:12;4899:34;4967:6;4956:9;4952:22;4942:32;;5012:7;5005:4;5001:2;4997:13;4993:27;4983:55;;5034:1;5031;5024:12;4983:55;5063:2;5057:9;5086:66;5102:49;5148:2;5102:49;:::i;5086:66::-;5186:15;;;5268:1;5264:10;;;;5256:19;;5252:28;;;5217:12;;;;5292:19;;;5289:39;;;5324:1;5321;5314:12;5289:39;5356:2;5352;5348:11;5368:808;5384:6;5379:3;5376:15;5368:808;;;5463:3;5457:10;5499:2;5486:11;5483:19;5480:39;;;5515:1;5512;5505:12;5480:39;5542:20;;5585:4;5613:16;;;5631:66;5609:89;5605:98;-1:-1:-1;5602:118:15;;;5716:1;5713;5706:12;5602:118;5746:22;;:::i;:::-;5810:2;5806;5802:11;5796:18;5827:33;5852:7;5827:33;:::i;:::-;5873:22;;5930:11;;;5924:18;;5958:16;;;5955:36;;;5987:1;5984;5977:12;5955:36;6027:75;6094:7;6089:2;6078:8;6074:2;6070:17;6066:26;6027:75;:::i;:::-;6011:14;;;6004:99;6116:18;;-1:-1:-1;;6154:12:15;;;;5401;;5368:808;;;-1:-1:-1;6195:5:15;4601:1605;-1:-1:-1;;;;;;;;4601:1605:15:o;6211:361::-;6305:6;6358:2;6346:9;6337:7;6333:23;6329:32;6326:52;;;6374:1;6371;6364:12;6326:52;6407:9;6401:16;6440:18;6432:6;6429:30;6426:50;;;6472:1;6469;6462:12;6426:50;6495:71;6558:7;6549:6;6538:9;6534:22;6495:71;:::i;:::-;6485:81;6211:361;-1:-1:-1;;;;6211:361:15:o;6577:184::-;6629:77;6626:1;6619:88;6726:4;6723:1;6716:15;6750:4;6747:1;6740:15;6766:128;6833:9;;;6854:11;;;6851:37;;;6868:18;;:::i;:::-;6766:128;;;;:::o;6899:184::-;6951:77;6948:1;6941:88;7048:4;7045:1;7038:15;7072:4;7069:1;7062:15;7461:201;7499:3;7527:10;7572:2;7565:5;7561:14;7599:2;7590:7;7587:15;7584:41;;7605:18;;:::i;:::-;7654:1;7641:15;;7461:201;-1:-1:-1;;;7461:201:15:o;8184:184::-;8236:77;8233:1;8226:88;8333:4;8330:1;8323:15;8357:4;8354:1;8347:15","linkReferences":{},"immutableReferences":{"3983":[{"start":249,"length":32},{"start":679,"length":32}],"4802":[{"start":921,"length":32}],"4804":[{"start":961,"length":32}],"4806":[{"start":883,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"DOMAIN_SEPARATOR()","signatureHash4":"0x3644e515","signatureHash32":"0x3644e5157256d68e3eeedd2ead302507a9c4ffaff665547d2c3623a1e9e7edf4"},{"signature":"getModules()","signatureHash4":"0xb2494df3","signatureHash32":"0xb2494df318768c15fa121cb236659ba2daa9eb2158a808d084df4cdb3bd14b1b"},{"signature":"install(address)","signatureHash4":"0x2a1b8f9b","signatureHash32":"0x2a1b8f9b72f692b2faff59d909f33290c2737c645c93359b014ce32b04cf139d"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"uninstall(address)","signatureHash4":"0x59bc2249","signatureHash32":"0x59bc224987bacd24cc52a2e6407f1e29622b63e762e3d71c925c546a0cbcb41f"}],"event":[{"signature":"ModuleInstalled(address)","signatureHash4":"0xb4a43748","signatureHash32":"0xb4a437488482177b2d124ce7c50e57d8f8d42a9896b525c9c497ee0d533a95de"},{"signature":"ModuleUninstalled(address)","signatureHash4":"0x8542f07e","signatureHash32":"0x8542f07efccd0c3cda31b784e4230bb229a0fd4c566cc725db514300e2f6df88"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"}],"error":[{"signature":"ModuleNotFound()","signatureHash4":"0x7252c08c","signatureHash32":"0x7252c08c18a407a6560300b83c3d3c6a8841772180150aae2e57cd493cc9d887"},{"signature":"ModuleNotInstalled(address)","signatureHash4":"0x026d9639","signatureHash32":"0x026d96395a8a1cf9545e0a148bc036f534a73d245c915144cb918128e1264a8e"},{"signature":"ModuleNotRegistered()","signatureHash4":"0x9c4aee9e","signatureHash32":"0x9c4aee9ec8fb3c383181d278c122c340a577e77d0cc01f828eed4957ec6be431"},{"signature":"SelectorAlreadySet(bytes4,address)","signatureHash4":"0x184fc20d","signatureHash32":"0x184fc20d2e6ae496fcdea54917586a59be96802da8e3191c76d571c21867c9d8"},{"signature":"UnauthorizedAccount(address)","signatureHash4":"0x32b2baa3","signatureHash32":"0x32b2baa33ecee8810f338b53967a81e08a36f7d812c6018b75f180bc02143720"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0x0000000000bbF5c5Fd284e657F01Bd000933C96D"}