{"matchId":"14221446","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-01-20T13:19:00Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"502:4886:14:-:0;;;1171:4:4;1128:48;;2134:53:14;;;;;;;;;-1:-1:-1;2158:22:14;:20;:22::i;:::-;502:4886;;7711:422:3;8870:21;7900:15;;;;;;;7896:76;;;7938:23;;-1:-1:-1;;;7938:23:3;;;;;;;;;;;7896:76;7985:14;;-1:-1:-1;;;;;7985:14:3;;;:34;7981:146;;8035:33;;-1:-1:-1;;;;;;8035:33:3;-1:-1:-1;;;;;8035:33:3;;;;;8087:29;;158:50:16;;;8087:29:3;;146:2:16;131:18;8087:29:3;;;;;;;7981:146;7760:373;7711:422::o;14:200:16:-;502:4886:14;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220cff5703b2f5209d6469b3edd4711ce86ee6265cdd9b90d660a0fcb3a1f719f6064736f6c63430008140033","offset":5224}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"502:4886:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3443:202:0;;;;;;;;;;-1:-1:-1;3443:202:0;;;;;:::i;:::-;;:::i;:::-;;;470:14:16;;463:22;445:41;;433:2;418:18;3443:202:0;;;;;;;;4759:191;;;;;;;;;;-1:-1:-1;4759:191:0;;;;;:::i;:::-;;:::i;:::-;;;828:25:16;;;816:2;801:18;4759:191:0;682:177:16;5246:136:0;;;;;;;;;;-1:-1:-1;5246:136:0;;;;;:::i;:::-;;:::i;:::-;;3777:184:14;;;;;;;;;;-1:-1:-1;3777:184:14;;;;;:::i;:::-;-1:-1:-1;;;;;3934:20:14;3832:4;3934:20;;;-1:-1:-1;;;;;;;;;;;3934:20:14;;;;;;;;;3777:184;4738:120;;;;;;;;;;-1:-1:-1;4738:120:14;;;;;:::i;:::-;;:::i;6348:245:0:-;;;;;;;;;;-1:-1:-1;6348:245:0;;;;;:::i;:::-;;:::i;2874:79:14:-;;;;;;;;;;-1:-1:-1;799:66:14;2874:79;;4158:214:4;;;;;;:::i;:::-;;:::i;4961:156:14:-;;;;;;;;;;-1:-1:-1;4961:156:14;;;;;:::i;:::-;;:::i;3705:134:4:-;;;;;;;;;;;;;:::i;5223:162:14:-;;;;;;;;;;-1:-1:-1;5223:162:14;;;;;:::i;:::-;;:::i;3155:101:2:-;;;;;;;;;;;;;:::i;664:60:14:-;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;664:60:14;;2774:229:1;;;;;;;;;;;;;:::i;2248:149:14:-;;;;;;;;;;;;;:::i;2441:144:2:-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;2788:32:16;;;2770:51;;2758:2;2743:18;2441:144:2;2624:203:16;3732:207:0;;;;;;;;;;-1:-1:-1;3732:207:0;;;;;:::i;:::-;;:::i;3061:222:14:-;;;;;;;;;;-1:-1:-1;3061:222:14;;;;;:::i;:::-;;:::i;2317:49:0:-;;;;;;;;;;-1:-1:-1;2317:49:0;2362:4;2317:49;;4061:292:14;;;;;;;;;;-1:-1:-1;4061:292:14;;;;;:::i;:::-;;:::i;1819:58:4:-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1819:58:4;;;;;;;;;;;;:::i;3396:209:14:-;;;;;;;;;;-1:-1:-1;3396:209:14;;;;;:::i;:::-;;:::i;5662:138:0:-;;;;;;;;;;-1:-1:-1;5662:138:0;;;;;:::i;:::-;;:::i;1680:168:1:-;;;;;;;;;;;;;:::i;2041:247::-;;;;;;;;;;-1:-1:-1;2041:247:1;;;;;:::i;:::-;;:::i;3443:202:0:-;3528:4;-1:-1:-1;;;;;;3551:47:0;;-1:-1:-1;;;3551:47:0;;:87;;-1:-1:-1;;;;;;;;;;1133:40:6;;;3602:36:0;3544:94;3443:202;-1:-1:-1;;3443:202:0:o;4759:191::-;4824:7;4919:14;;;-1:-1:-1;;;;;;;;;;;4919:14:0;;;;;:24;;;;4759:191::o;5246:136::-;5320:18;5333:4;5320:12;:18::i;:::-;3191:16;3202:4;3191:10;:16::i;:::-;5350:25:::1;5361:4;5367:7;5350:10;:25::i;:::-;;5246:136:::0;;;:::o;4738:120:14:-;4800:4;4823:28;-1:-1:-1;;;;;;;;;;;4843:7:14;4823;:28::i;6348:245:0:-;-1:-1:-1;;;;;6441:34:0;;966:10:5;6441:34:0;6437:102;;6498:30;;-1:-1:-1;;;6498:30:0;;;;;;;;;;;6437:102;6549:37;6561:4;6567:18;6549:11;:37::i;:::-;;6348:245;;:::o;4158:214:4:-;2653:13;:11;:13::i;:::-;4273:36:::1;4291:17;4273;:36::i;:::-;4319:46;4341:17;4360:4;4319:21;:46::i;:::-;4158:214:::0;;:::o;4961:156:14:-;2334:13:2;:11;:13::i;:::-;5038:31:14::1;-1:-1:-1::0;;;;;;;;;;;5061:7:14::1;5038:10;:31::i;:::-;-1:-1:-1::0;5084:26:14::1;::::0;-1:-1:-1;;;;;5084:26:14;::::1;::::0;::::1;::::0;;;::::1;4961:156:::0;:::o;3705:134:4:-;3774:7;2924:20;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;;3705:134:4;:::o;5223:162:14:-;2334:13:2;:11;:13::i;:::-;5303:32:14::1;-1:-1:-1::0;;;;;;;;;;;5327:7:14::1;5303:11;:32::i;:::-;-1:-1:-1::0;5350:28:14::1;::::0;-1:-1:-1;;;;;5350:28:14;::::1;::::0;::::1;::::0;;;::::1;5223:162:::0;:::o;3155:101:2:-;2334:13;:11;:13::i;:::-;3219:30:::1;3246:1;3219:18;:30::i;:::-;3155:101::o:0;2774:229:1:-;966:10:5;;2869:14:1;:12;:14::i;:::-;-1:-1:-1;;;;;2869:24:1;;2865:96;;2916:34;;-1:-1:-1;;;2916:34:1;;-1:-1:-1;;;;;2788:32:16;;2916:34:1;;;2770:51:16;2743:18;;2916:34:1;;;;;;;;2865:96;2970:26;2989:6;2970:18;:26::i;:::-;2816:187;2774:229::o;2248:149:14:-;8870:21:3;4302:15;;-1:-1:-1;;;4302:15:3;;;;4301:16;;4348:14;;4158:30;4726:16;;:34;;;;;4746:14;4726:34;4706:54;;4770:17;4790:11;:16;;4805:1;4790:16;:50;;;;-1:-1:-1;4818:4:3;4810:25;:30;4790:50;4770:70;;4856:12;4855:13;:30;;;;;4873:12;4872:13;4855:30;4851:91;;;4908:23;;-1:-1:-1;;;4908:23:3;;;;;;;;;;;4851:91;4951:18;;-1:-1:-1;;4951:18:3;4968:1;4951:18;;;4979:67;;;;5013:22;;-1:-1:-1;;;;5013:22:3;-1:-1:-1;;;5013:22:3;;;4979:67;2299:21:14::1;:19;:21::i;:::-;2330:28;966:10:5::0;2330:14:14::1;:28::i;:::-;2368:22;:20;:22::i;:::-;5070:14:3::0;5066:101;;;5100:23;;-1:-1:-1;;;;5100:23:3;;;5142:14;;-1:-1:-1;3974:50:16;;5142:14:3;;3962:2:16;3947:18;5142:14:3;;;;;;;5066:101;4092:1081;;;;;2248:149:14:o;2441:144:2:-;2487:7;;1313:22;2533:20;2570:8;-1:-1:-1;;;;;2570:8:2;;2441:144;-1:-1:-1;;2441:144:2:o;3732:207:0:-;3809:4;3901:14;;;-1:-1:-1;;;;;;;;;;;3901:14:0;;;;;;;;-1:-1:-1;;;;;3901:31:0;;;;;;;;;;;;;;;3732:207::o;3061:222:14:-;4478:28;966:10:5;4738:120:14;:::i;4478:28::-;4473:81;;4529:14;;-1:-1:-1;;;4529:14:14;;;;;;;;;;;4473:81;-1:-1:-1;;;;;3218:22:14;::::1;3130:35;3218:22:::0;;;-1:-1:-1;;;;;;;;;;;3218:22:14::1;::::0;;;;;;;:29;;-1:-1:-1;;3218:29:14::1;3243:4;3218:29;::::0;;3262:14;1330:33;;3218:22;3262:14:::1;::::0;::::1;3120:163;3061:222:::0;:::o;4061:292::-;-1:-1:-1;;;;;4280:17:14;;;4169:10;4280:17;;;-1:-1:-1;;;;;;;;;;;4280:17:14;;;;;;;;;;4313:33;;4203:25:16;;;4280:17:14;;;;4278:20;4244:18:16;;;4237:50;;;4313:33:14;;4278:20;;1330:33;;4313;;;;;;;;;;;;;4181:172;4061:292;;;;;:::o;3396:209::-;4478:28;966:10:5;4738:120:14;:::i;4478:28::-;4473:81;;4529:14;;-1:-1:-1;;;4529:14:14;;;;;;;;;;;4473:81;-1:-1:-1;;;;;3543:19:14;::::1;3464:35;3543:19:::0;;;-1:-1:-1;;;;;;;;;;;3543:19:14::1;::::0;;;;;;;:27;;-1:-1:-1;;3543:27:14::1;::::0;;3585:13;1330:33;;3543:19;3585:13:::1;::::0;::::1;3454:151;3396:209:::0;:::o;5662:138:0:-;5737:18;5750:4;5737:12;:18::i;:::-;3191:16;3202:4;3191:10;:16::i;:::-;5767:26:::1;5779:4;5785:7;5767:11;:26::i;1680:168:1:-:0;1733:7;;1318:27;1784:25;1187:174;2041:247;2334:13:2;:11;:13::i;:::-;1318:27:1;2197:26;;-1:-1:-1;;;;;;2197:26:1::1;-1:-1:-1::0;;;;;2197:26:1;::::1;::::0;;::::1;::::0;;2263:7:::1;:5;:7::i;:::-;-1:-1:-1::0;;;;;2238:43:1::1;;;;;;;;;;;2120:168;2041:247:::0;:::o;4148:103:0:-;4214:30;4225:4;966:10:5;4214::0;:30::i;7270:387::-;7347:4;-1:-1:-1;;;;;;;;;;;7437:22:0;7445:4;7451:7;7437;:22::i;:::-;7432:219;;7475:8;:14;;;;;;;;;;;-1:-1:-1;;;;;7475:31:0;;;;;;;;;:38;;-1:-1:-1;;7475:38:0;7509:4;7475:38;;;7559:12;966:10:5;;887:96;7559:12:0;-1:-1:-1;;;;;7532:40:0;7550:7;-1:-1:-1;;;;;7532:40:0;7544:4;7532:40;;;;;;;;;;7593:4;7586:11;;;;;7432:219;7635:5;7628:12;;;;;7892:388;7970:4;-1:-1:-1;;;;;;;;;;;8059:22:0;8067:4;8073:7;8059;:22::i;:::-;8055:219;;;8131:5;8097:14;;;;;;;;;;;-1:-1:-1;;;;;8097:31:0;;;;;;;;;;:39;;-1:-1:-1;;8097:39:0;;;8155:40;966:10:5;;8097:14:0;;8155:40;;8131:5;8155:40;8216:4;8209:11;;;;;4599:312:4;4679:4;-1:-1:-1;;;;;4688:6:4;4671:23;;;:120;;;4785:6;-1:-1:-1;;;;;4749:42:4;:32;-1:-1:-1;;;;;;;;;;;2035:53:9;-1:-1:-1;;;;;2035:53:9;;1957:138;4749:32:4;-1:-1:-1;;;;;4749:42:4;;;4671:120;4654:251;;;4865:29;;-1:-1:-1;;;4865:29:4;;;;;;;;;;;2718:98:14;2334:13:2;:11;:13::i;6052:538:4:-;6169:17;-1:-1:-1;;;;;6151:50:4;;:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6151:52:4;;;;;;;;-1:-1:-1;;6151:52:4;;;;;;;;;;;;:::i;:::-;;;6147:437;;6513:60;;-1:-1:-1;;;6513:60:4;;-1:-1:-1;;;;;2788:32:16;;6513:60:4;;;2770:51:16;2743:18;;6513:60:4;2624:203:16;6147:437:4;-1:-1:-1;;;;;;;;;;;6245:40:4;;6241:120;;6312:34;;-1:-1:-1;;;6312:34:4;;;;;828:25:16;;;801:18;;6312:34:4;682:177:16;6241:120:4;6374:54;6404:17;6423:4;6374:29;:54::i;2658:162:2:-;966:10:5;2717:7:2;:5;:7::i;:::-;-1:-1:-1;;;;;2717:23:2;;2713:101;;2763:40;;-1:-1:-1;;;2763:40:2;;966:10:5;2763:40:2;;;2770:51:16;2743:18;;2763:40:2;2624:203:16;5028:213:4;5102:4;-1:-1:-1;;;;;5111:6:4;5094:23;;5090:145;;5195:29;;-1:-1:-1;;;5195:29:4;;;;;;;;;;;2472:222:1;1318:27;2621:22;;-1:-1:-1;;;;;;2621:22:1;;;2653:34;2678:8;2653:24;:34::i;1461:64::-;6931:20:3;:18;:20::i;1847:127:2:-;6931:20:3;:18;:20::i;:::-;1929:38:2::1;1954:12;1929:24;:38::i;4381:197:0:-:0;4469:22;4477:4;4483:7;4469;:22::i;:::-;4464:108;;4514:47;;-1:-1:-1;;;4514:47:0;;-1:-1:-1;;;;;4679:32:16;;4514:47:0;;;4661:51:16;4728:18;;;4721:34;;;4634:18;;4514:47:0;4487:274:16;2779:335:9;2870:37;2889:17;2870:18;:37::i;:::-;2922:27;;-1:-1:-1;;;;;2922:27:9;;;;;;;;2964:11;;:15;2960:148;;2995:53;3024:17;3043:4;2995:28;:53::i;2960:148::-;3079:18;:16;:18::i;3774:248:2:-;1313:22;3923:8;;-1:-1:-1;;;;;;3941:19:2;;-1:-1:-1;;;;;3941:19:2;;;;;;;;3975:40;;3923:8;;;;;3975:40;;3847:24;;3975:40;3837:185;;3774:248;:::o;7084:141:3:-;8870:21;8560:40;-1:-1:-1;;;8560:40:3;;;;7146:73;;7191:17;;-1:-1:-1;;;7191:17:3;;;;;;;;;;;1980:235:2;6931:20:3;:18;:20::i;:::-;-1:-1:-1;;;;;2076:26:2;::::1;2072:95;;2125:31;::::0;-1:-1:-1;;;2125:31:2;;2153:1:::1;2125:31;::::0;::::1;2770:51:16::0;2743:18;;2125:31:2::1;2624:203:16::0;2186:281:9;2263:17;-1:-1:-1;;;;;2263:29:9;;2296:1;2263:34;2259:119;;2320:47;;-1:-1:-1;;;2320:47:9;;-1:-1:-1;;;;;2788:32:16;;2320:47:9;;;2770:51:16;2743:18;;2320:47:9;2624:203:16;2259:119:9;-1:-1:-1;;;;;;;;;;;2387:73:9;;-1:-1:-1;;;;;;2387:73:9;-1:-1:-1;;;;;2387:73:9;;;;;;;;;;2186:281::o;4106:253:11:-;4189:12;4214;4228:23;4255:6;-1:-1:-1;;;;;4255:19:11;4275:4;4255:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4213:67;;;;4297:55;4324:6;4332:7;4341:10;4297:26;:55::i;:::-;4290:62;4106:253;-1:-1:-1;;;;;4106:253:11:o;6598:122:9:-;6648:9;:13;6644:70;;6684:19;;-1:-1:-1;;;6684:19:9;;;;;;;;;;;4625:582:11;4769:12;4798:7;4793:408;;4821:19;4829:10;4821:7;:19::i;:::-;4793:408;;;5045:17;;:22;:49;;;;-1:-1:-1;;;;;;5071:18:11;;;:23;5045:49;5041:119;;;5121:24;;-1:-1:-1;;;5121:24:11;;-1:-1:-1;;;;;2788:32:16;;5121:24:11;;;2770:51:16;2743:18;;5121:24:11;2624:203:16;5041:119:11;-1:-1:-1;5180:10:11;4793:408;4625:582;;;;;:::o;5743:516::-;5874:17;;:21;5870:383;;6102:10;6096:17;6158:15;6145:10;6141:2;6137:19;6130:44;5870:383;6225:17;;-1:-1:-1;;;6225:17:11;;;;;;;;;;;14:286:16;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:16;;209:43;;199:71;;266:1;263;256:12;497:180;556:6;609:2;597:9;588:7;584:23;580:32;577:52;;;625:1;622;615:12;577:52;-1:-1:-1;648:23:16;;497:180;-1:-1:-1;497:180:16:o;864:173::-;932:20;;-1:-1:-1;;;;;981:31:16;;971:42;;961:70;;1027:1;1024;1017:12;961:70;864:173;;;:::o;1042:254::-;1110:6;1118;1171:2;1159:9;1150:7;1146:23;1142:32;1139:52;;;1187:1;1184;1177:12;1139:52;1223:9;1210:23;1200:33;;1252:38;1286:2;1275:9;1271:18;1252:38;:::i;:::-;1242:48;;1042:254;;;;;:::o;1301:186::-;1360:6;1413:2;1401:9;1392:7;1388:23;1384:32;1381:52;;;1429:1;1426;1419:12;1381:52;1452:29;1471:9;1452:29;:::i;1492:127::-;1553:10;1548:3;1544:20;1541:1;1534:31;1584:4;1581:1;1574:15;1608:4;1605:1;1598:15;1624:995;1701:6;1709;1762:2;1750:9;1741:7;1737:23;1733:32;1730:52;;;1778:1;1775;1768:12;1730:52;1801:29;1820:9;1801:29;:::i;:::-;1791:39;;1881:2;1870:9;1866:18;1853:32;1904:18;1945:2;1937:6;1934:14;1931:34;;;1961:1;1958;1951:12;1931:34;1999:6;1988:9;1984:22;1974:32;;2044:7;2037:4;2033:2;2029:13;2025:27;2015:55;;2066:1;2063;2056:12;2015:55;2102:2;2089:16;2124:2;2120;2117:10;2114:36;;;2130:18;;:::i;:::-;2205:2;2199:9;2173:2;2259:13;;-1:-1:-1;;2255:22:16;;;2279:2;2251:31;2247:40;2235:53;;;2303:18;;;2323:22;;;2300:46;2297:72;;;2349:18;;:::i;:::-;2389:10;2385:2;2378:22;2424:2;2416:6;2409:18;2464:7;2459:2;2454;2450;2446:11;2442:20;2439:33;2436:53;;;2485:1;2482;2475:12;2436:53;2541:2;2536;2532;2528:11;2523:2;2515:6;2511:15;2498:46;2586:1;2581:2;2576;2568:6;2564:15;2560:24;2553:35;2607:6;2597:16;;;;;;;1624:995;;;;;:::o;2832:328::-;2909:6;2917;2925;2978:2;2966:9;2957:7;2953:23;2949:32;2946:52;;;2994:1;2991;2984:12;2946:52;3017:29;3036:9;3017:29;:::i;:::-;3007:39;;3065:38;3099:2;3088:9;3084:18;3065:38;:::i;:::-;3055:48;;3150:2;3139:9;3135:18;3122:32;3112:42;;2832:328;;;;;:::o;3165:250::-;3250:1;3260:113;3274:6;3271:1;3268:13;3260:113;;;3350:11;;;3344:18;3331:11;;;3324:39;3296:2;3289:10;3260:113;;;-1:-1:-1;;3407:1:16;3389:16;;3382:27;3165:250::o;3420:396::-;3569:2;3558:9;3551:21;3532:4;3601:6;3595:13;3644:6;3639:2;3628:9;3624:18;3617:34;3660:79;3732:6;3727:2;3716:9;3712:18;3707:2;3699:6;3695:15;3660:79;:::i;:::-;3800:2;3779:15;-1:-1:-1;;3775:29:16;3760:45;;;;3807:2;3756:54;;3420:396;-1:-1:-1;;3420:396:16:o;4298:184::-;4368:6;4421:2;4409:9;4400:7;4396:23;4392:32;4389:52;;;4437:1;4434;4427:12;4389:52;-1:-1:-1;4460:16:16;;4298:184;-1:-1:-1;4298:184:16:o;4766:287::-;4895:3;4933:6;4927:13;4949:66;5008:6;5003:3;4996:4;4988:6;4984:17;4949:66;:::i;:::-;5031:16;;;;;4766:287;-1:-1:-1;;4766:287:16:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220cff5703b2f5209d6469b3edd4711ce86ee6265cdd9b90d660a0fcb3a1f719f6064736f6c63430008140033","offset":4975}},"immutableReferences":{"968":[{"start":2982,"length":32},{"start":3023,"length":32},{"start":3392,"length":32}]},"transformations":[{"id":"968","type":"replace","offset":2982,"reason":"immutable"},{"id":"968","type":"replace","offset":3023,"reason":"immutable"},{"id":"968","type":"replace","offset":3392,"reason":"immutable"}],"transformationValues":{"immutables":{"968":"0x0000000000000000000000007425926e3b8540e8175185ebc36482e3758bbfa7"}}},"deployment":{"transactionHash":"0x620b2304c2c2a0d2e4d78a354951b580ee83026d625ec3f87fa1a5afb97b8cb8","blockNumber":"41062891","transactionIndex":"46","deployer":"0xd7648CBcece018829EA7B0e561605E7fd3DB8Af6"},"sources":{"src/BlacklistValidatorUpgradeable.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\npragma solidity ^0.8.20;\n\nimport \"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\n\nimport \"./IValidator.sol\";\n\n/**\n * @title BlacklistValidator\n * @dev Rejects transfers from blacklisted addresses.\n */\ncontract BlacklistValidatorUpgradeable is\n    Initializable,\n    Ownable2StepUpgradeable,\n    AccessControlUpgradeable,\n    UUPSUpgradeable,\n    IValidator\n{\n    bytes32 public constant ADMIN_ROLE = keccak256(\"ADMIN_ROLE\");\n    // keccak256(\"monerium.validator\")\n    bytes32 private constant ID = 0x5341d189213c4172d0c7256f80bc5f8e6350af3aaff7a029625d8dd94f0f82a5;\n\n    struct BlacklistValidatorStorage {\n        mapping(address => bool) blacklist;\n    }\n\n    // keccak256(\"Monerium.BlacklistValidatorStorage\")\n    bytes32 private constant BlacklistValidatorStorageLocation =\n        0x187fd434edb52abef1e387c6baed33eabbe6de77c176d95834d5ab434a07fc18;\n\n    function _getBlacklistValidatorStorage()\n        private\n        pure\n        returns (BlacklistValidatorStorage storage $)\n    {\n        assembly {\n            $.slot := BlacklistValidatorStorageLocation\n\n        }\n    }\n\n    error Unauthorized();\n\n    /**\n     * @dev Emitted when an address is added to the blacklist.\n     * @param adversary Address added.\n     */\n    event Ban(address indexed adversary);\n\n    /**\n     * @dev Emitted when an address is removed from the blacklist.\n     * @param friend Address removed.\n     */\n    event Unban(address indexed friend);\n\n    /**\n     * @dev Emitted when admin account is added.\n     * @param account The address of the account.\n     */\n    event AdminAccountAdded(address indexed account);\n\n    /**\n     * @dev Emitted when admin account is removed.\n     * @param account The address of the account.\n     */\n    event AdminAccountRemoved(address indexed account);\n\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n\n\n    /**\n     * @dev Initializes the contract.\n     */\n    function initialize() public initializer {\n        __Ownable2Step_init();\n        __Ownable_init(_msgSender());\n        __AccessControl_init();\n    }\n\n    // _authorizeUpgrade is a crucial part of the UUPS upgrade pattern in OpenZeppelin.\n    // By defining this function, we can control the upgrade process and prevent unauthorized changes.\n    // This function can be customized to include additional checks or logic, such as a timelock or a multisig requirement.\n    function _authorizeUpgrade(\n        address newImplementation\n    ) internal override onlyOwner {}\n\n    // CONTRACT_ID returns the contract identifier.\n    function CONTRACT_ID() public pure returns (bytes32) {\n        return ID;\n    }\n\n    /**\n     * @dev Adds an address to the blacklist.\n     * @param adversary Address to add.\n     */\n    function ban(address adversary) external onlyAdminAccounts {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        \n        $.blacklist[adversary] = true;\n        emit Ban(adversary);\n    }\n\n    /**\n     * @dev Removes an address from the blacklist.\n     * @param friend Address to remove.\n     */\n    function unban(address friend) external onlyAdminAccounts {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        $.blacklist[friend] = false;\n        emit Unban(friend);\n    }\n\n    /**\n     * @dev Checks if an address is in the blacklist.\n     * @param account Address to check.\n     * @return true if the address is in the blacklist.\n     */\n    function isBan(address account) external view returns (bool) {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        return $.blacklist[account];\n    }\n\n    /**\n     * @dev Validates token transfer.\n     * Implements IValidator interface.\n     */\n    function validate(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool valid) {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        valid = !($.blacklist[from]);\n        emit Decision(from, to, amount, valid);\n    }\n\n    /**\n     * @dev modifier to restrict access to admin accounts.\n     */\n    modifier onlyAdminAccounts() {\n        if (!isAdminAccount(_msgSender())) {\n            revert Unauthorized();\n        }\n        _;\n    }\n\n    /**\n     * @dev Checks wether an address is a admin account.\n     * @param account The address of the account.\n     * @return true if admin account.\n     */\n    function isAdminAccount(address account) public view returns (bool) {\n        return hasRole(ADMIN_ROLE, account);\n    }\n\n    /**\n     * @dev add admin account.\n     * @param account The address of the account.\n     */\n    function addAdminAccount(address account) public virtual onlyOwner {\n        _grantRole(ADMIN_ROLE, account);\n        emit AdminAccountAdded(account);\n    }\n\n    /**\n     * @dev remove admin account.\n     * @param account The address of the account.\n     */\n    function removeAdminAccount(address account) public virtual onlyOwner {\n        _revokeRole(ADMIN_ROLE, account);\n        emit AdminAccountRemoved(account);\n    }\n\n}\n\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {OwnableUpgradeable} from \"./OwnableUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\n    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable2Step\n    struct Ownable2StepStorage {\n        address _pendingOwner;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Ownable2Step\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant Ownable2StepStorageLocation = 0x237e158222e3e6968b72b9db0d8043aacf074ad9f650f0d1606b4d82ee432c00;\n\n    function _getOwnable2StepStorage() private pure returns (Ownable2StepStorage storage $) {\n        assembly {\n            $.slot := Ownable2StepStorageLocation\n        }\n    }\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    function __Ownable2Step_init() internal onlyInitializing {\n    }\n\n    function __Ownable2Step_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        Ownable2StepStorage storage $ = _getOwnable2StepStorage();\n        return $._pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        Ownable2StepStorage storage $ = _getOwnable2StepStorage();\n        $._pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        Ownable2StepStorage storage $ = _getOwnable2StepStorage();\n        delete $._pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        if (pendingOwner() != sender) {\n            revert OwnableUnauthorizedAccount(sender);\n        }\n        _transferOwnership(sender);\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/AccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"@openzeppelin/contracts/access/IAccessControl.sol\";\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {ERC165Upgradeable} from \"../utils/introspection/ERC165Upgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {\n    struct RoleData {\n        mapping(address account => bool) hasRole;\n        bytes32 adminRole;\n    }\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n\n    /// @custom:storage-location erc7201:openzeppelin.storage.AccessControl\n    struct AccessControlStorage {\n        mapping(bytes32 role => RoleData) _roles;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.AccessControl\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;\n\n    function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {\n        assembly {\n            $.slot := AccessControlStorageLocation\n        }\n    }\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with an {AccessControlUnauthorizedAccount} error including the required role.\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    function __AccessControl_init() internal onlyInitializing {\n    }\n\n    function __AccessControl_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        return $._roles[role].hasRole[account];\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n     * is missing `role`.\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert AccessControlUnauthorizedAccount(account, role);\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        return $._roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n        if (callerConfirmation != _msgSender()) {\n            revert AccessControlBadConfirmation();\n        }\n\n        _revokeRole(role, callerConfirmation);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        $._roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        if (!hasRole(role, account)) {\n            $._roles[role].hasRole[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        if (hasRole(role, account)) {\n            $._roles[role].hasRole[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Storage of the initializable contract.\n     *\n     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\n     * when using with upgradeable contracts.\n     *\n     * @custom:storage-location erc7201:openzeppelin.storage.Initializable\n     */\n    struct InitializableStorage {\n        /**\n         * @dev Indicates that the contract has been initialized.\n         */\n        uint64 _initialized;\n        /**\n         * @dev Indicates that the contract is in the process of being initialized.\n         */\n        bool _initializing;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Initializable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\n\n    /**\n     * @dev The contract is already initialized.\n     */\n    error InvalidInitialization();\n\n    /**\n     * @dev The contract is not initializing.\n     */\n    error NotInitializing();\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint64 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\n     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\n     * production.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        // Cache values to avoid duplicated sloads\n        bool isTopLevelCall = !$._initializing;\n        uint64 initialized = $._initialized;\n\n        // Allowed calls:\n        // - initialSetup: the contract is not in the initializing state and no previous version was\n        //                 initialized\n        // - construction: the contract is initialized at version 1 (no reininitialization) and the\n        //                 current contract is just being deployed\n        bool initialSetup = initialized == 0 && isTopLevelCall;\n        bool construction = initialized == 1 && address(this).code.length == 0;\n\n        if (!initialSetup && !construction) {\n            revert InvalidInitialization();\n        }\n        $._initialized = 1;\n        if (isTopLevelCall) {\n            $._initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            $._initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint64 version) {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing || $._initialized >= version) {\n            revert InvalidInitialization();\n        }\n        $._initialized = version;\n        $._initializing = true;\n        _;\n        $._initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        _checkInitializing();\n        _;\n    }\n\n    /**\n     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\n     */\n    function _checkInitializing() internal view virtual {\n        if (!_isInitializing()) {\n            revert NotInitializing();\n        }\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing) {\n            revert InvalidInitialization();\n        }\n        if ($._initialized != type(uint64).max) {\n            $._initialized = type(uint64).max;\n            emit Initialized(type(uint64).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint64) {\n        return _getInitializableStorage()._initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _getInitializableStorage()._initializing;\n    }\n\n    /**\n     * @dev Returns a pointer to the storage namespace.\n     */\n    // solhint-disable-next-line var-name-mixedcase\n    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\n        assembly {\n            $.slot := INITIALIZABLE_STORAGE\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\nimport {Initializable} from \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {\n    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n    address private immutable __self = address(this);\n\n    /**\n     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\n     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\n     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\n     * If the getter returns `\"5.0.0\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\n     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\n     * during an upgrade.\n     */\n    string public constant UPGRADE_INTERFACE_VERSION = \"5.0.0\";\n\n    /**\n     * @dev The call is from an unauthorized context.\n     */\n    error UUPSUnauthorizedCallContext();\n\n    /**\n     * @dev The storage `slot` is unsupported as a UUID.\n     */\n    error UUPSUnsupportedProxiableUUID(bytes32 slot);\n\n    /**\n     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\n     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n     * fail.\n     */\n    modifier onlyProxy() {\n        _checkProxy();\n        _;\n    }\n\n    /**\n     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n     * callable on the implementing contract but not through proxies.\n     */\n    modifier notDelegated() {\n        _checkNotDelegated();\n        _;\n    }\n\n    function __UUPSUpgradeable_init() internal onlyInitializing {\n    }\n\n    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\n     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n     */\n    function proxiableUUID() external view virtual notDelegated returns (bytes32) {\n        return ERC1967Utils.IMPLEMENTATION_SLOT;\n    }\n\n    /**\n     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n     * encoded in `data`.\n     *\n     * Calls {_authorizeUpgrade}.\n     *\n     * Emits an {Upgraded} event.\n     *\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\n        _authorizeUpgrade(newImplementation);\n        _upgradeToAndCallUUPS(newImplementation, data);\n    }\n\n    /**\n     * @dev Reverts if the execution is not performed via delegatecall or the execution\n     * context is not of a proxy with an ERC1967-compliant implementation pointing to self.\n     * See {_onlyProxy}.\n     */\n    function _checkProxy() internal view virtual {\n        if (\n            address(this) == __self || // Must be called through delegatecall\n            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\n        ) {\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Reverts if the execution is performed via delegatecall.\n     * See {notDelegated}.\n     */\n    function _checkNotDelegated() internal view virtual {\n        if (address(this) != __self) {\n            // Must not be called through delegatecall\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n     * {upgradeToAndCall}.\n     *\n     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n     *\n     * ```solidity\n     * function _authorizeUpgrade(address) internal onlyOwner {}\n     * ```\n     */\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /**\n     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\n     *\n     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\n     * is expected to be the implementation slot in ERC1967.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\n        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\n                revert UUPSUnsupportedProxiableUUID(slot);\n            }\n            ERC1967Utils.upgradeToAndCall(newImplementation, data);\n        } catch {\n            // The implementation is not UUPS\n            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\n        }\n    }\n}\n"},"src/IValidator.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\npragma solidity ^0.8.20;\n\n/**\n * @title IValidator\n * @dev Contracts implementing this interface validate token transfers.\n */\ninterface IValidator {\n    /**\n     * @dev Emitted when a validator makes a decision.\n     * @param from Sender address.\n     * @param to Recipient address.\n     * @param amount Number of tokens.\n     * @param valid True if transfer approved, false if rejected.\n     */\n    event Decision(\n        address indexed from,\n        address indexed to,\n        uint256 amount,\n        bool valid\n    );\n\n    /**\n     * @dev Validates token transfer.\n     * If the sender is on the blacklist the transfer is denied.\n     * @param from Sender address.\n     * @param to Recipient address.\n     * @param amount Number of tokens.\n     */\n    function validate(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool valid);\n\n    /**\n     * @dev Returns the contract identifier.\n     */ \n     function CONTRACT_ID() external view returns (bytes32);\n\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable\n    struct OwnableStorage {\n        address _owner;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Ownable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;\n\n    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {\n        assembly {\n            $.slot := OwnableStorageLocation\n        }\n    }\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    function __Ownable_init(address initialOwner) internal onlyInitializing {\n        __Ownable_init_unchained(initialOwner);\n    }\n\n    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        OwnableStorage storage $ = _getOwnableStorage();\n        return $._owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        OwnableStorage storage $ = _getOwnableStorage();\n        address oldOwner = $._owner;\n        $._owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev The `account` is missing a role.\n     */\n    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n    /**\n     * @dev The caller of a function is not the expected one.\n     *\n     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n     */\n    error AccessControlBadConfirmation();\n\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)\n\npragma solidity ^0.8.20;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {Initializable} from \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165 {\n    function __ERC165_init() internal onlyInitializing {\n    }\n\n    function __ERC165_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n    /**\n     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n     * address.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy.\n     */\n    function proxiableUUID() external view returns (bytes32);\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IBeacon} from \"../beacon/IBeacon.sol\";\nimport {Address} from \"../../utils/Address.sol\";\nimport {StorageSlot} from \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n */\nlibrary ERC1967Utils {\n    // We re-declare ERC-1967 events here because they can't be used directly from IERC1967.\n    // This will be fixed in Solidity 0.8.21. At that point we should remove these events.\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\n\n    /**\n     * @dev Emitted when the beacon is changed.\n     */\n    event BeaconUpgraded(address indexed beacon);\n\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev The `implementation` of the proxy is invalid.\n     */\n    error ERC1967InvalidImplementation(address implementation);\n\n    /**\n     * @dev The `admin` of the proxy is invalid.\n     */\n    error ERC1967InvalidAdmin(address admin);\n\n    /**\n     * @dev The `beacon` of the proxy is invalid.\n     */\n    error ERC1967InvalidBeacon(address beacon);\n\n    /**\n     * @dev An upgrade function sees `msg.value > 0` that may be lost.\n     */\n    error ERC1967NonPayable();\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function getImplementation() internal view returns (address) {\n        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 implementation slot.\n     */\n    function _setImplementation(address newImplementation) private {\n        if (newImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(newImplementation);\n        }\n        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\n    }\n\n    /**\n     * @dev Performs implementation upgrade with additional setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) internal {\n        _setImplementation(newImplementation);\n        emit Upgraded(newImplementation);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(newImplementation, data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Storage slot with the admin of the contract.\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Returns the current admin.\n     *\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using\n     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n     */\n    function getAdmin() internal view returns (address) {\n        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        if (newAdmin == address(0)) {\n            revert ERC1967InvalidAdmin(address(0));\n        }\n        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {IERC1967-AdminChanged} event.\n     */\n    function changeAdmin(address newAdmin) internal {\n        emit AdminChanged(getAdmin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n     * This is the keccak-256 hash of \"eip1967.proxy.beacon\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n    /**\n     * @dev Returns the current beacon.\n     */\n    function getBeacon() internal view returns (address) {\n        return StorageSlot.getAddressSlot(BEACON_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new beacon in the EIP1967 beacon slot.\n     */\n    function _setBeacon(address newBeacon) private {\n        if (newBeacon.code.length == 0) {\n            revert ERC1967InvalidBeacon(newBeacon);\n        }\n\n        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\n\n        address beaconImplementation = IBeacon(newBeacon).implementation();\n        if (beaconImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(beaconImplementation);\n        }\n    }\n\n    /**\n     * @dev Change the beacon and trigger a setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-BeaconUpgraded} event.\n     *\n     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\n     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\n     * efficiency.\n     */\n    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\n        _setBeacon(newBeacon);\n        emit BeaconUpgraded(newBeacon);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\n     * if an upgrade doesn't perform an initialization call.\n     */\n    function _checkNonPayable() private {\n        if (msg.value > 0) {\n            revert ERC1967NonPayable();\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n    /**\n     * @dev Must return an address that can be used as a delegate call target.\n     *\n     * {UpgradeableBeacon} will check that this address is a contract.\n     */\n    function implementation() external view returns (address);\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error AddressInsufficientBalance(address account);\n\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedInnerCall();\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert AddressInsufficientBalance(address(this));\n        }\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            revert FailedInnerCall();\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {FailedInnerCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert AddressInsufficientBalance(address(this));\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\n     * unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {FailedInnerCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert FailedInnerCall();\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.20+commit.a1b79de6","compilerSettings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"shanghai","remappings":[":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",":ds-test/=lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/"]},"name":"BlacklistValidatorUpgradeable","fullyQualifiedName":"src/BlacklistValidatorUpgradeable.sol:BlacklistValidatorUpgradeable"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AccessControlBadConfirmation","type":"error","inputs":[]},{"name":"AccessControlUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"neededRole","type":"bytes32","internalType":"bytes32"}]},{"name":"AddressEmptyCode","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"ERC1967InvalidImplementation","type":"error","inputs":[{"name":"implementation","type":"address","internalType":"address"}]},{"name":"ERC1967NonPayable","type":"error","inputs":[]},{"name":"FailedInnerCall","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"UUPSUnauthorizedCallContext","type":"error","inputs":[]},{"name":"UUPSUnsupportedProxiableUUID","type":"error","inputs":[{"name":"slot","type":"bytes32","internalType":"bytes32"}]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"AdminAccountAdded","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"AdminAccountRemoved","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Ban","type":"event","inputs":[{"name":"adversary","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Decision","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"valid","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleAdminChanged","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"previousAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"newAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"RoleGranted","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleRevoked","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Unban","type":"event","inputs":[{"name":"friend","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"CONTRACT_ID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"pure"},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"UPGRADE_INTERFACE_VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"addAdminAccount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"ban","type":"function","inputs":[{"name":"adversary","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"getRoleAdmin","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"grantRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"hasRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"isAdminAccount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isBan","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"removeAdminAccount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"callerConfirmation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"revokeRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unban","type":"function","inputs":[{"name":"friend","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"validate","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"valid","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.20+commit.a1b79de6"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"AdminAccountAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"AdminAccountRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"adversary","type":"address"}],"name":"Ban","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"valid","type":"bool"}],"name":"Decision","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"friend","type":"address"}],"name":"Unban","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CONTRACT_ID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addAdminAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"adversary","type":"address"}],"name":"ban","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isAdminAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isBan","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeAdminAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"friend","type":"address"}],"name":"unban","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"validate","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"details":"Rejects transfers from blacklisted addresses.","errors":{"AccessControlBadConfirmation()":[{"details":"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}."}],"AccessControlUnauthorizedAccount(address,bytes32)":[{"details":"The `account` is missing a role."}],"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"ERC1967InvalidImplementation(address)":[{"details":"The `implementation` of the proxy is invalid."}],"ERC1967NonPayable()":[{"details":"An upgrade function sees `msg.value > 0` that may be lost."}],"FailedInnerCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"UUPSUnauthorizedCallContext()":[{"details":"The call is from an unauthorized context."}],"UUPSUnsupportedProxiableUUID(bytes32)":[{"details":"The storage `slot` is unsupported as a UUID."}]},"events":{"AdminAccountAdded(address)":{"details":"Emitted when admin account is added.","params":{"account":"The address of the account."}},"AdminAccountRemoved(address)":{"details":"Emitted when admin account is removed.","params":{"account":"The address of the account."}},"Ban(address)":{"details":"Emitted when an address is added to the blacklist.","params":{"adversary":"Address added."}},"Decision(address,address,uint256,bool)":{"details":"Emitted when a validator makes a decision.","params":{"amount":"Number of tokens.","from":"Sender address.","to":"Recipient address.","valid":"True if transfer approved, false if rejected."}},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized or reinitialized."},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this."},"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"Unban(address)":{"details":"Emitted when an address is removed from the blacklist.","params":{"friend":"Address removed."}},"Upgraded(address)":{"details":"Emitted when the implementation is upgraded."}},"kind":"dev","methods":{"CONTRACT_ID()":{"details":"Returns the contract identifier."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"addAdminAccount(address)":{"details":"add admin account.","params":{"account":"The address of the account."}},"ban(address)":{"details":"Adds an address to the blacklist.","params":{"adversary":"Address to add."}},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"initialize()":{"details":"Initializes the contract."},"isAdminAccount(address)":{"details":"Checks wether an address is a admin account.","params":{"account":"The address of the account."},"returns":{"_0":"true if admin account."}},"isBan(address)":{"details":"Checks if an address is in the blacklist.","params":{"account":"Address to check."},"returns":{"_0":"true if the address is in the blacklist."}},"owner()":{"details":"Returns the address of the current owner."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"proxiableUUID()":{"details":"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier."},"removeAdminAccount(address)":{"details":"remove admin account.","params":{"account":"The address of the account."}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner."},"unban(address)":{"details":"Removes an address from the blacklist.","params":{"friend":"Address to remove."}},"upgradeToAndCall(address,bytes)":{"custom:oz-upgrades-unsafe-allow-reachable":"delegatecall","details":"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event."},"validate(address,address,uint256)":{"details":"Validates token transfer. Implements IValidator interface."}},"title":"BlacklistValidator","version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"src/BlacklistValidatorUpgradeable.sol":"BlacklistValidatorUpgradeable"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",":ds-test/=lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/"]},"sources":{"lib/openzeppelin-contracts-upgradeable/contracts/access/AccessControlUpgradeable.sol":{"keccak256":"0x6662ec4e5cefca03eeadd073e9469df8d2944bb2ee8ec8f7622c2c46aab5f225","license":"MIT","urls":["bzz-raw://4d8544c6f8daa4d1bc215c6a72fe0acdb748664a105b0e5efc19295667521d45","dweb:/ipfs/QmdGWqdnXT8S3RgCR6aV8XHZrsybieMQLLnug1NtpSjEXN"]},"lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol":{"keccak256":"0xbca4a4f66d98028293dba695851d1b20d3e0ba2fff7453fb241f192fa3fc6b6f","license":"MIT","urls":["bzz-raw://013b3cfd9d1e34dad409c3b9a340860e8651e61cda509de33599fb5102f62fe7","dweb:/ipfs/QmTVjDKofM9Nst8w8LAA3HHgi1eCnGYBpFb7Nbat71e2xz"]},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"keccak256":"0xc163fcf9bb10138631a9ba5564df1fa25db9adff73bd9ee868a8ae1858fe093a","license":"MIT","urls":["bzz-raw://9706d43a0124053d9880f6e31a59f31bc0a6a3dc1acd66ce0a16e1111658c5f6","dweb:/ipfs/QmUFmfowzkRwGtDu36cXV9SPTBHJ3n7dG9xQiK5B28jTf2"]},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"keccak256":"0x631188737069917d2f909d29ce62c4d48611d326686ba6683e26b72a23bfac0b","license":"MIT","urls":["bzz-raw://7a61054ae84cd6c4d04c0c4450ba1d6de41e27e0a2c4f1bcdf58f796b401c609","dweb:/ipfs/QmUvtdp7X1mRVyC3CsHrtPbgoqWaXHp3S1ZR24tpAQYJWM"]},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol":{"keccak256":"0x3f13b947637c4969c0644cab4ef399cdc4b67f101463b8775c5a43b118558e53","license":"MIT","urls":["bzz-raw://c6683e6ade6985d394d32baaef5eea0d8b9ff0b3eca86ae413d6cdde114a9930","dweb:/ipfs/QmdBE8T1BTddZxpdECMsb3KiCFyjNWmxcCddYrWFTXmWPj"]},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"keccak256":"0x72d47aebad24c59f6e78d0c3e827440173419a333fd910a37fa1e532c98f7e4c","license":"MIT","urls":["bzz-raw://dc8d1401a44d84ede55b6641d58f63f12a83aecb0816d577d947392b55a6b43b","dweb:/ipfs/QmUskJ7JGzg17MAgRoZfZ3p7P9uucsgm2fKyXQvxdLThLE"]},"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol":{"keccak256":"0xdaba3f7c42c55b2896353f32bd27d4d5f8bae741b3b05d4c53f67abc4dc47ce8","license":"MIT","urls":["bzz-raw://1fa2e61141c602510bcd2cd936ed9561922ac8772a9b9c9a9db091a74e354a45","dweb:/ipfs/QmcHQDDoEBwJmwUbzoVkytvJsBx3KVHYFFnDkvRGWh9Wmh"]},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol":{"keccak256":"0xb6b36edd6a2999fd243ff226d6cbf84bd71af2432bbd0dfe19392996a1d9cb41","license":"MIT","urls":["bzz-raw://1fd2f35495652e57e3f99bc6c510bc5f7dd398a176ea2e72d8ed730aebc6ca26","dweb:/ipfs/QmTQV6X4gkikTib49cho5iDX3JvSQbdsoEChoDwrk3CbbH"]},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol":{"keccak256":"0x2a1f9944df2015c081d89cd41ba22ffaf10aa6285969f0dc612b235cc448999c","license":"MIT","urls":["bzz-raw://ef381843676aec64421200ee85eaa0b1356a35f28b9fc67e746a6bbb832077d9","dweb:/ipfs/QmY8aorMYA2TeTCnu6ejDjzb4rW4t7TCtW4GZ6LoxTFm7v"]},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol":{"keccak256":"0x06a78f9b3ee3e6d0eb4e4cd635ba49960bea34cac1db8c0a27c75f2319f1fd65","license":"MIT","urls":["bzz-raw://547d21aa17f4f3f1a1a7edf7167beff8dd9496a0348d5588f15cc8a4b29d052a","dweb:/ipfs/QmT16JtRQSWNpLo9W23jr6CzaMuTAcQcjJJcdRd8HLJ6cE"]},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol":{"keccak256":"0xc59a78b07b44b2cf2e8ab4175fca91e8eca1eee2df7357b8d2a8833e5ea1f64c","license":"MIT","urls":["bzz-raw://5aa4f07e65444784c29cd7bfcc2341b34381e4e5b5da9f0c5bd00d7f430e66fa","dweb:/ipfs/QmWRMh4Q9DpaU9GvsiXmDdoNYMyyece9if7hnfLz7uqzWM"]},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol":{"keccak256":"0xaf28a975a78550e45f65e559a3ad6a5ad43b9b8a37366999abd1b7084eb70721","license":"MIT","urls":["bzz-raw://b7bd24e224f67f65bfadf85dc2929fa965456bb2415478bd0125471b5ce35245","dweb:/ipfs/QmRaydGr8BTHs1kvaZfsNU69pKzUAGFrvABn1KiRSbE51y"]},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"keccak256":"0x32ba59b4b7299237c8ba56319110989d7978a039faf754793064e967e5894418","license":"MIT","urls":["bzz-raw://1ae50c8b562427df610cc4540c9bf104acca7ef8e2dcae567ae7e52272281e9c","dweb:/ipfs/QmTHiadFCSJUPpRjNegc5SahmeU8bAoY8i9Aq6tVscbcKR"]},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x4296879f55019b23e135000eb36896057e7101fb7fb859c5ef690cf14643757b","license":"MIT","urls":["bzz-raw://87b3541437c8c443ccd36795e56a338ed12855eec17f8da624511b8d1a7e14df","dweb:/ipfs/QmeJQCtZrQjtJLr6u7ZHWeH3pBnjtLWzvRrKViAi7UZqxL"]},"src/BlacklistValidatorUpgradeable.sol":{"keccak256":"0xbb8c79ffd69464606a588487e9cd820b767544f722d65d3af419362677b2b8a0","license":"Apache-2.0","urls":["bzz-raw://f68eb5e0fbdb0233bb7bf0c274a53bf92761b29a3812c357db4cee6eafc462b2","dweb:/ipfs/QmYRyJYfRqv61gmCEDNzWHJPp5BLLyhLoP2TMgJ9D94Gzg"]},"src/IValidator.sol":{"keccak256":"0xb0dbebb00e2cc65c329c41b56e6d02e213ece1b3b8ac2174b2385b143add2098","license":"Apache-2.0","urls":["bzz-raw://4a879b7943496744b9d1ef3350ef77d2dd25aa33be09805b65824e4710333ef8","dweb:/ipfs/QmZy6joCeRxv47SSdNC7mMiZajZQU7dHGpawHZM7TzT2Fb"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","title":"BlacklistValidator","errors":{"FailedInnerCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"ERC1967NonPayable()":[{"details":"An upgrade function sees `msg.value > 0` that may be lost."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"UUPSUnauthorizedCallContext()":[{"details":"The call is from an unauthorized context."}],"AccessControlBadConfirmation()":[{"details":"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC1967InvalidImplementation(address)":[{"details":"The `implementation` of the proxy is invalid."}],"UUPSUnsupportedProxiableUUID(bytes32)":[{"details":"The storage `slot` is unsupported as a UUID."}],"AccessControlUnauthorizedAccount(address,bytes32)":[{"details":"The `account` is missing a role."}]},"events":{"Ban(address)":{"params":{"adversary":"Address added."},"details":"Emitted when an address is added to the blacklist."},"Unban(address)":{"params":{"friend":"Address removed."},"details":"Emitted when an address is removed from the blacklist."},"Upgraded(address)":{"details":"Emitted when the implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized or reinitialized."},"AdminAccountAdded(address)":{"params":{"account":"The address of the account."},"details":"Emitted when admin account is added."},"AdminAccountRemoved(address)":{"params":{"account":"The address of the account."},"details":"Emitted when admin account is removed."},"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"Decision(address,address,uint256,bool)":{"params":{"to":"Recipient address.","from":"Sender address.","valid":"True if transfer approved, false if rejected.","amount":"Number of tokens."},"details":"Emitted when a validator makes a decision."},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this."}},"details":"Rejects transfers from blacklisted addresses.","methods":{"owner()":{"details":"Returns the address of the current owner."},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"ban(address)":{"params":{"adversary":"Address to add."},"details":"Adds an address to the blacklist."},"initialize()":{"details":"Initializes the contract."},"CONTRACT_ID()":{"details":"Returns the contract identifier."},"isBan(address)":{"params":{"account":"Address to check."},"details":"Checks if an address is in the blacklist.","returns":{"_0":"true if the address is in the blacklist."}},"pendingOwner()":{"details":"Returns the address of the pending owner."},"unban(address)":{"params":{"friend":"Address to remove."},"details":"Removes an address from the blacklist."},"proxiableUUID()":{"details":"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"isAdminAccount(address)":{"params":{"account":"The address of the account."},"details":"Checks wether an address is a admin account.","returns":{"_0":"true if admin account."}},"addAdminAccount(address)":{"params":{"account":"The address of the account."},"details":"add admin account."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner."},"removeAdminAccount(address)":{"params":{"account":"The address of the account."},"details":"remove admin account."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event."},"upgradeToAndCall(address,bytes)":{"details":"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.","custom:oz-upgrades-unsafe-allow-reachable":"delegatecall"},"validate(address,address,uint256)":{"details":"Validates token transfer. Implements IValidator interface."}},"version":1},"sourceIds":{"src/IValidator.sol":{"id":15},"src/BlacklistValidatorUpgradeable.sol":{"id":14},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"id":5},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"id":2},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"id":3},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol":{"id":4},"lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol":{"id":1},"lib/openzeppelin-contracts-upgradeable/contracts/access/AccessControlUpgradeable.sol":{"id":0},"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol":{"id":6},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol":{"id":11},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"id":12},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol":{"id":10},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol":{"id":7},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol":{"id":8},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol":{"id":9},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":13}},"additionalInput":null,"stdJsonInput":{"sources":{"src/IValidator.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\npragma solidity ^0.8.20;\n\n/**\n * @title IValidator\n * @dev Contracts implementing this interface validate token transfers.\n */\ninterface IValidator {\n    /**\n     * @dev Emitted when a validator makes a decision.\n     * @param from Sender address.\n     * @param to Recipient address.\n     * @param amount Number of tokens.\n     * @param valid True if transfer approved, false if rejected.\n     */\n    event Decision(\n        address indexed from,\n        address indexed to,\n        uint256 amount,\n        bool valid\n    );\n\n    /**\n     * @dev Validates token transfer.\n     * If the sender is on the blacklist the transfer is denied.\n     * @param from Sender address.\n     * @param to Recipient address.\n     * @param amount Number of tokens.\n     */\n    function validate(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool valid);\n\n    /**\n     * @dev Returns the contract identifier.\n     */ \n     function CONTRACT_ID() external view returns (bytes32);\n\n}\n"},"src/BlacklistValidatorUpgradeable.sol":{"content":"// SPDX-License-Identifier: Apache-2.0\npragma solidity ^0.8.20;\n\nimport \"@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\n\nimport \"./IValidator.sol\";\n\n/**\n * @title BlacklistValidator\n * @dev Rejects transfers from blacklisted addresses.\n */\ncontract BlacklistValidatorUpgradeable is\n    Initializable,\n    Ownable2StepUpgradeable,\n    AccessControlUpgradeable,\n    UUPSUpgradeable,\n    IValidator\n{\n    bytes32 public constant ADMIN_ROLE = keccak256(\"ADMIN_ROLE\");\n    // keccak256(\"monerium.validator\")\n    bytes32 private constant ID = 0x5341d189213c4172d0c7256f80bc5f8e6350af3aaff7a029625d8dd94f0f82a5;\n\n    struct BlacklistValidatorStorage {\n        mapping(address => bool) blacklist;\n    }\n\n    // keccak256(\"Monerium.BlacklistValidatorStorage\")\n    bytes32 private constant BlacklistValidatorStorageLocation =\n        0x187fd434edb52abef1e387c6baed33eabbe6de77c176d95834d5ab434a07fc18;\n\n    function _getBlacklistValidatorStorage()\n        private\n        pure\n        returns (BlacklistValidatorStorage storage $)\n    {\n        assembly {\n            $.slot := BlacklistValidatorStorageLocation\n\n        }\n    }\n\n    error Unauthorized();\n\n    /**\n     * @dev Emitted when an address is added to the blacklist.\n     * @param adversary Address added.\n     */\n    event Ban(address indexed adversary);\n\n    /**\n     * @dev Emitted when an address is removed from the blacklist.\n     * @param friend Address removed.\n     */\n    event Unban(address indexed friend);\n\n    /**\n     * @dev Emitted when admin account is added.\n     * @param account The address of the account.\n     */\n    event AdminAccountAdded(address indexed account);\n\n    /**\n     * @dev Emitted when admin account is removed.\n     * @param account The address of the account.\n     */\n    event AdminAccountRemoved(address indexed account);\n\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n\n\n    /**\n     * @dev Initializes the contract.\n     */\n    function initialize() public initializer {\n        __Ownable2Step_init();\n        __Ownable_init(_msgSender());\n        __AccessControl_init();\n    }\n\n    // _authorizeUpgrade is a crucial part of the UUPS upgrade pattern in OpenZeppelin.\n    // By defining this function, we can control the upgrade process and prevent unauthorized changes.\n    // This function can be customized to include additional checks or logic, such as a timelock or a multisig requirement.\n    function _authorizeUpgrade(\n        address newImplementation\n    ) internal override onlyOwner {}\n\n    // CONTRACT_ID returns the contract identifier.\n    function CONTRACT_ID() public pure returns (bytes32) {\n        return ID;\n    }\n\n    /**\n     * @dev Adds an address to the blacklist.\n     * @param adversary Address to add.\n     */\n    function ban(address adversary) external onlyAdminAccounts {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        \n        $.blacklist[adversary] = true;\n        emit Ban(adversary);\n    }\n\n    /**\n     * @dev Removes an address from the blacklist.\n     * @param friend Address to remove.\n     */\n    function unban(address friend) external onlyAdminAccounts {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        $.blacklist[friend] = false;\n        emit Unban(friend);\n    }\n\n    /**\n     * @dev Checks if an address is in the blacklist.\n     * @param account Address to check.\n     * @return true if the address is in the blacklist.\n     */\n    function isBan(address account) external view returns (bool) {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        return $.blacklist[account];\n    }\n\n    /**\n     * @dev Validates token transfer.\n     * Implements IValidator interface.\n     */\n    function validate(\n        address from,\n        address to,\n        uint256 amount\n    ) external returns (bool valid) {\n        BlacklistValidatorStorage storage $ = _getBlacklistValidatorStorage();\n        valid = !($.blacklist[from]);\n        emit Decision(from, to, amount, valid);\n    }\n\n    /**\n     * @dev modifier to restrict access to admin accounts.\n     */\n    modifier onlyAdminAccounts() {\n        if (!isAdminAccount(_msgSender())) {\n            revert Unauthorized();\n        }\n        _;\n    }\n\n    /**\n     * @dev Checks wether an address is a admin account.\n     * @param account The address of the account.\n     * @return true if admin account.\n     */\n    function isAdminAccount(address account) public view returns (bool) {\n        return hasRole(ADMIN_ROLE, account);\n    }\n\n    /**\n     * @dev add admin account.\n     * @param account The address of the account.\n     */\n    function addAdminAccount(address account) public virtual onlyOwner {\n        _grantRole(ADMIN_ROLE, account);\n        emit AdminAccountAdded(account);\n    }\n\n    /**\n     * @dev remove admin account.\n     * @param account The address of the account.\n     */\n    function removeAdminAccount(address account) public virtual onlyOwner {\n        _revokeRole(ADMIN_ROLE, account);\n        emit AdminAccountRemoved(account);\n    }\n\n}\n\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)\n\npragma solidity ^0.8.20;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable\n    struct OwnableStorage {\n        address _owner;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Ownable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;\n\n    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {\n        assembly {\n            $.slot := OwnableStorageLocation\n        }\n    }\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    function __Ownable_init(address initialOwner) internal onlyInitializing {\n        __Ownable_init_unchained(initialOwner);\n    }\n\n    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        OwnableStorage storage $ = _getOwnableStorage();\n        return $._owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        OwnableStorage storage $ = _getOwnableStorage();\n        address oldOwner = $._owner;\n        $._owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Storage of the initializable contract.\n     *\n     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\n     * when using with upgradeable contracts.\n     *\n     * @custom:storage-location erc7201:openzeppelin.storage.Initializable\n     */\n    struct InitializableStorage {\n        /**\n         * @dev Indicates that the contract has been initialized.\n         */\n        uint64 _initialized;\n        /**\n         * @dev Indicates that the contract is in the process of being initialized.\n         */\n        bool _initializing;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Initializable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\n\n    /**\n     * @dev The contract is already initialized.\n     */\n    error InvalidInitialization();\n\n    /**\n     * @dev The contract is not initializing.\n     */\n    error NotInitializing();\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint64 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\n     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\n     * production.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        // Cache values to avoid duplicated sloads\n        bool isTopLevelCall = !$._initializing;\n        uint64 initialized = $._initialized;\n\n        // Allowed calls:\n        // - initialSetup: the contract is not in the initializing state and no previous version was\n        //                 initialized\n        // - construction: the contract is initialized at version 1 (no reininitialization) and the\n        //                 current contract is just being deployed\n        bool initialSetup = initialized == 0 && isTopLevelCall;\n        bool construction = initialized == 1 && address(this).code.length == 0;\n\n        if (!initialSetup && !construction) {\n            revert InvalidInitialization();\n        }\n        $._initialized = 1;\n        if (isTopLevelCall) {\n            $._initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            $._initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint64 version) {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing || $._initialized >= version) {\n            revert InvalidInitialization();\n        }\n        $._initialized = version;\n        $._initializing = true;\n        _;\n        $._initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        _checkInitializing();\n        _;\n    }\n\n    /**\n     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\n     */\n    function _checkInitializing() internal view virtual {\n        if (!_isInitializing()) {\n            revert NotInitializing();\n        }\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing) {\n            revert InvalidInitialization();\n        }\n        if ($._initialized != type(uint64).max) {\n            $._initialized = type(uint64).max;\n            emit Initialized(type(uint64).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint64) {\n        return _getInitializableStorage()._initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _getInitializableStorage()._initializing;\n    }\n\n    /**\n     * @dev Returns a pointer to the storage namespace.\n     */\n    // solhint-disable-next-line var-name-mixedcase\n    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\n        assembly {\n            $.slot := INITIALIZABLE_STORAGE\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\nimport {Initializable} from \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {\n    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n    address private immutable __self = address(this);\n\n    /**\n     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\n     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\n     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\n     * If the getter returns `\"5.0.0\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\n     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\n     * during an upgrade.\n     */\n    string public constant UPGRADE_INTERFACE_VERSION = \"5.0.0\";\n\n    /**\n     * @dev The call is from an unauthorized context.\n     */\n    error UUPSUnauthorizedCallContext();\n\n    /**\n     * @dev The storage `slot` is unsupported as a UUID.\n     */\n    error UUPSUnsupportedProxiableUUID(bytes32 slot);\n\n    /**\n     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\n     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n     * fail.\n     */\n    modifier onlyProxy() {\n        _checkProxy();\n        _;\n    }\n\n    /**\n     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n     * callable on the implementing contract but not through proxies.\n     */\n    modifier notDelegated() {\n        _checkNotDelegated();\n        _;\n    }\n\n    function __UUPSUpgradeable_init() internal onlyInitializing {\n    }\n\n    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\n     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n     */\n    function proxiableUUID() external view virtual notDelegated returns (bytes32) {\n        return ERC1967Utils.IMPLEMENTATION_SLOT;\n    }\n\n    /**\n     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n     * encoded in `data`.\n     *\n     * Calls {_authorizeUpgrade}.\n     *\n     * Emits an {Upgraded} event.\n     *\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\n        _authorizeUpgrade(newImplementation);\n        _upgradeToAndCallUUPS(newImplementation, data);\n    }\n\n    /**\n     * @dev Reverts if the execution is not performed via delegatecall or the execution\n     * context is not of a proxy with an ERC1967-compliant implementation pointing to self.\n     * See {_onlyProxy}.\n     */\n    function _checkProxy() internal view virtual {\n        if (\n            address(this) == __self || // Must be called through delegatecall\n            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\n        ) {\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Reverts if the execution is performed via delegatecall.\n     * See {notDelegated}.\n     */\n    function _checkNotDelegated() internal view virtual {\n        if (address(this) != __self) {\n            // Must not be called through delegatecall\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n     * {upgradeToAndCall}.\n     *\n     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n     *\n     * ```solidity\n     * function _authorizeUpgrade(address) internal onlyOwner {}\n     * ```\n     */\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /**\n     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\n     *\n     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\n     * is expected to be the implementation slot in ERC1967.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\n        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\n                revert UUPSUnsupportedProxiableUUID(slot);\n            }\n            ERC1967Utils.upgradeToAndCall(newImplementation, data);\n        } catch {\n            // The implementation is not UUPS\n            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.20;\n\nimport {OwnableUpgradeable} from \"./OwnableUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is specified at deployment time in the constructor for `Ownable`. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {\n    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable2Step\n    struct Ownable2StepStorage {\n        address _pendingOwner;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Ownable2Step\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant Ownable2StepStorageLocation = 0x237e158222e3e6968b72b9db0d8043aacf074ad9f650f0d1606b4d82ee432c00;\n\n    function _getOwnable2StepStorage() private pure returns (Ownable2StepStorage storage $) {\n        assembly {\n            $.slot := Ownable2StepStorageLocation\n        }\n    }\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    function __Ownable2Step_init() internal onlyInitializing {\n    }\n\n    function __Ownable2Step_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        Ownable2StepStorage storage $ = _getOwnable2StepStorage();\n        return $._pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        Ownable2StepStorage storage $ = _getOwnable2StepStorage();\n        $._pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        Ownable2StepStorage storage $ = _getOwnable2StepStorage();\n        delete $._pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        if (pendingOwner() != sender) {\n            revert OwnableUnauthorizedAccount(sender);\n        }\n        _transferOwnership(sender);\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/access/AccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"@openzeppelin/contracts/access/IAccessControl.sol\";\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {ERC165Upgradeable} from \"../utils/introspection/ERC165Upgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {\n    struct RoleData {\n        mapping(address account => bool) hasRole;\n        bytes32 adminRole;\n    }\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n\n    /// @custom:storage-location erc7201:openzeppelin.storage.AccessControl\n    struct AccessControlStorage {\n        mapping(bytes32 role => RoleData) _roles;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.AccessControl\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;\n\n    function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {\n        assembly {\n            $.slot := AccessControlStorageLocation\n        }\n    }\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with an {AccessControlUnauthorizedAccount} error including the required role.\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    function __AccessControl_init() internal onlyInitializing {\n    }\n\n    function __AccessControl_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        return $._roles[role].hasRole[account];\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n     * is missing `role`.\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert AccessControlUnauthorizedAccount(account, role);\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        return $._roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n        if (callerConfirmation != _msgSender()) {\n            revert AccessControlBadConfirmation();\n        }\n\n        _revokeRole(role, callerConfirmation);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        $._roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        if (!hasRole(role, account)) {\n            $._roles[role].hasRole[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n        AccessControlStorage storage $ = _getAccessControlStorage();\n        if (hasRole(role, account)) {\n            $._roles[role].hasRole[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {Initializable} from \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165 {\n    function __ERC165_init() internal onlyInitializing {\n    }\n\n    function __ERC165_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error AddressInsufficientBalance(address account);\n\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedInnerCall();\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert AddressInsufficientBalance(address(this));\n        }\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            revert FailedInnerCall();\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {FailedInnerCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert AddressInsufficientBalance(address(this));\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\n     * unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {FailedInnerCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert FailedInnerCall();\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n    /**\n     * @dev Must return an address that can be used as a delegate call target.\n     *\n     * {UpgradeableBeacon} will check that this address is a contract.\n     */\n    function implementation() external view returns (address);\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev The `account` is missing a role.\n     */\n    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n    /**\n     * @dev The caller of a function is not the expected one.\n     *\n     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n     */\n    error AccessControlBadConfirmation();\n\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n    /**\n     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n     * address.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy.\n     */\n    function proxiableUUID() external view returns (bytes32);\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)\n\npragma solidity ^0.8.20;\n\nimport {IBeacon} from \"../beacon/IBeacon.sol\";\nimport {Address} from \"../../utils/Address.sol\";\nimport {StorageSlot} from \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This abstract contract provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\n */\nlibrary ERC1967Utils {\n    // We re-declare ERC-1967 events here because they can't be used directly from IERC1967.\n    // This will be fixed in Solidity 0.8.21. At that point we should remove these events.\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\n\n    /**\n     * @dev Emitted when the beacon is changed.\n     */\n    event BeaconUpgraded(address indexed beacon);\n\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev The `implementation` of the proxy is invalid.\n     */\n    error ERC1967InvalidImplementation(address implementation);\n\n    /**\n     * @dev The `admin` of the proxy is invalid.\n     */\n    error ERC1967InvalidAdmin(address admin);\n\n    /**\n     * @dev The `beacon` of the proxy is invalid.\n     */\n    error ERC1967InvalidBeacon(address beacon);\n\n    /**\n     * @dev An upgrade function sees `msg.value > 0` that may be lost.\n     */\n    error ERC1967NonPayable();\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function getImplementation() internal view returns (address) {\n        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 implementation slot.\n     */\n    function _setImplementation(address newImplementation) private {\n        if (newImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(newImplementation);\n        }\n        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\n    }\n\n    /**\n     * @dev Performs implementation upgrade with additional setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) internal {\n        _setImplementation(newImplementation);\n        emit Upgraded(newImplementation);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(newImplementation, data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Storage slot with the admin of the contract.\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Returns the current admin.\n     *\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using\n     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n     */\n    function getAdmin() internal view returns (address) {\n        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the EIP1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        if (newAdmin == address(0)) {\n            revert ERC1967InvalidAdmin(address(0));\n        }\n        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {IERC1967-AdminChanged} event.\n     */\n    function changeAdmin(address newAdmin) internal {\n        emit AdminChanged(getAdmin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n     * This is the keccak-256 hash of \"eip1967.proxy.beacon\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n    /**\n     * @dev Returns the current beacon.\n     */\n    function getBeacon() internal view returns (address) {\n        return StorageSlot.getAddressSlot(BEACON_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new beacon in the EIP1967 beacon slot.\n     */\n    function _setBeacon(address newBeacon) private {\n        if (newBeacon.code.length == 0) {\n            revert ERC1967InvalidBeacon(newBeacon);\n        }\n\n        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\n\n        address beaconImplementation = IBeacon(newBeacon).implementation();\n        if (beaconImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(beaconImplementation);\n        }\n    }\n\n    /**\n     * @dev Change the beacon and trigger a setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-BeaconUpgraded} event.\n     *\n     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\n     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\n     * efficiency.\n     */\n    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\n        _setBeacon(newBeacon);\n        emit BeaconUpgraded(newBeacon);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\n     * if an upgrade doesn't perform an initialization call.\n     */\n    function _checkNonPayable() private {\n        if (msg.value > 0) {\n            revert ERC1967NonPayable();\n        }\n    }\n}\n"},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"}},"language":"Solidity","settings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"shanghai","remappings":[":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",":ds-test/=lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/"]}},"stdJsonOutput":{"sources":{"src/IValidator.sol":{"id":15},"src/BlacklistValidatorUpgradeable.sol":{"id":14},"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol":{"id":5},"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol":{"id":2},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"id":3},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol":{"id":4},"lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol":{"id":1},"lib/openzeppelin-contracts-upgradeable/contracts/access/AccessControlUpgradeable.sol":{"id":0},"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol":{"id":6},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol":{"id":11},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"id":12},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol":{"id":10},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol":{"id":7},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol":{"id":8},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol":{"id":9},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":13}},"contracts":{"src/BlacklistValidatorUpgradeable.sol":{"BlacklistValidatorUpgradeable":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AccessControlBadConfirmation","type":"error","inputs":[]},{"name":"AccessControlUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"neededRole","type":"bytes32","internalType":"bytes32"}]},{"name":"AddressEmptyCode","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"ERC1967InvalidImplementation","type":"error","inputs":[{"name":"implementation","type":"address","internalType":"address"}]},{"name":"ERC1967NonPayable","type":"error","inputs":[]},{"name":"FailedInnerCall","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"UUPSUnauthorizedCallContext","type":"error","inputs":[]},{"name":"UUPSUnsupportedProxiableUUID","type":"error","inputs":[{"name":"slot","type":"bytes32","internalType":"bytes32"}]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"AdminAccountAdded","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"AdminAccountRemoved","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Ban","type":"event","inputs":[{"name":"adversary","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Decision","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"valid","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleAdminChanged","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"previousAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"newAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"RoleGranted","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleRevoked","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Unban","type":"event","inputs":[{"name":"friend","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"CONTRACT_ID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"pure"},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"UPGRADE_INTERFACE_VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"addAdminAccount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"ban","type":"function","inputs":[{"name":"adversary","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"getRoleAdmin","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"grantRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"hasRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"isAdminAccount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isBan","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"removeAdminAccount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"callerConfirmation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"revokeRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unban","type":"function","inputs":[{"name":"friend","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"validate","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"valid","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AccessControlBadConfirmation\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"neededRole\",\"type\":\"bytes32\"}],\"name\":\"AccessControlUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"ERC1967InvalidImplementation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC1967NonPayable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedInnerCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitialization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotInitializing\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UUPSUnauthorizedCallContext\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"UUPSUnsupportedProxiableUUID\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"AdminAccountAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"AdminAccountRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"adversary\",\"type\":\"address\"}],\"name\":\"Ban\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"name\":\"Decision\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"version\",\"type\":\"uint64\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"friend\",\"type\":\"address\"}],\"name\":\"Unban\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CONTRACT_ID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"UPGRADE_INTERFACE_VERSION\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addAdminAccount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"adversary\",\"type\":\"address\"}],\"name\":\"ban\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isAdminAccount\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isBan\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"removeAdminAccount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"callerConfirmation\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"friend\",\"type\":\"address\"}],\"name\":\"unban\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"validate\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"valid\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Rejects transfers from blacklisted addresses.\",\"errors\":{\"AccessControlBadConfirmation()\":[{\"details\":\"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\"}],\"AccessControlUnauthorizedAccount(address,bytes32)\":[{\"details\":\"The `account` is missing a role.\"}],\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"ERC1967InvalidImplementation(address)\":[{\"details\":\"The `implementation` of the proxy is invalid.\"}],\"ERC1967NonPayable()\":[{\"details\":\"An upgrade function sees `msg.value > 0` that may be lost.\"}],\"FailedInnerCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"InvalidInitialization()\":[{\"details\":\"The contract is already initialized.\"}],\"NotInitializing()\":[{\"details\":\"The contract is not initializing.\"}],\"OwnableInvalidOwner(address)\":[{\"details\":\"The owner is not a valid owner account. (eg. `address(0)`)\"}],\"OwnableUnauthorizedAccount(address)\":[{\"details\":\"The caller account is not authorized to perform an operation.\"}],\"UUPSUnauthorizedCallContext()\":[{\"details\":\"The call is from an unauthorized context.\"}],\"UUPSUnsupportedProxiableUUID(bytes32)\":[{\"details\":\"The storage `slot` is unsupported as a UUID.\"}]},\"events\":{\"AdminAccountAdded(address)\":{\"details\":\"Emitted when admin account is added.\",\"params\":{\"account\":\"The address of the account.\"}},\"AdminAccountRemoved(address)\":{\"details\":\"Emitted when admin account is removed.\",\"params\":{\"account\":\"The address of the account.\"}},\"Ban(address)\":{\"details\":\"Emitted when an address is added to the blacklist.\",\"params\":{\"adversary\":\"Address added.\"}},\"Decision(address,address,uint256,bool)\":{\"details\":\"Emitted when a validator makes a decision.\",\"params\":{\"amount\":\"Number of tokens.\",\"from\":\"Sender address.\",\"to\":\"Recipient address.\",\"valid\":\"True if transfer approved, false if rejected.\"}},\"Initialized(uint64)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"},\"RoleAdminChanged(bytes32,bytes32,bytes32)\":{\"details\":\"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this.\"},\"RoleGranted(bytes32,address,address)\":{\"details\":\"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}.\"},\"RoleRevoked(bytes32,address,address)\":{\"details\":\"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)\"},\"Unban(address)\":{\"details\":\"Emitted when an address is removed from the blacklist.\",\"params\":{\"friend\":\"Address removed.\"}},\"Upgraded(address)\":{\"details\":\"Emitted when the implementation is upgraded.\"}},\"kind\":\"dev\",\"methods\":{\"CONTRACT_ID()\":{\"details\":\"Returns the contract identifier.\"},\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"addAdminAccount(address)\":{\"details\":\"add admin account.\",\"params\":{\"account\":\"The address of the account.\"}},\"ban(address)\":{\"details\":\"Adds an address to the blacklist.\",\"params\":{\"adversary\":\"Address to add.\"}},\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"initialize()\":{\"details\":\"Initializes the contract.\"},\"isAdminAccount(address)\":{\"details\":\"Checks wether an address is a admin account.\",\"params\":{\"account\":\"The address of the account.\"},\"returns\":{\"_0\":\"true if admin account.\"}},\"isBan(address)\":{\"details\":\"Checks if an address is in the blacklist.\",\"params\":{\"account\":\"Address to check.\"},\"returns\":{\"_0\":\"true if the address is in the blacklist.\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"proxiableUUID()\":{\"details\":\"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\"},\"removeAdminAccount(address)\":{\"details\":\"remove admin account.\",\"params\":{\"account\":\"The address of the account.\"}},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"unban(address)\":{\"details\":\"Removes an address from the blacklist.\",\"params\":{\"friend\":\"Address to remove.\"}},\"upgradeToAndCall(address,bytes)\":{\"custom:oz-upgrades-unsafe-allow-reachable\":\"delegatecall\",\"details\":\"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"},\"validate(address,address,uint256)\":{\"details\":\"Validates token transfer. Implements IValidator interface.\"}},\"title\":\"BlacklistValidator\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/BlacklistValidatorUpgradeable.sol\":\"BlacklistValidatorUpgradeable\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/\"]},\"sources\":{\"lib/openzeppelin-contracts-upgradeable/contracts/access/AccessControlUpgradeable.sol\":{\"keccak256\":\"0x6662ec4e5cefca03eeadd073e9469df8d2944bb2ee8ec8f7622c2c46aab5f225\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4d8544c6f8daa4d1bc215c6a72fe0acdb748664a105b0e5efc19295667521d45\",\"dweb:/ipfs/QmdGWqdnXT8S3RgCR6aV8XHZrsybieMQLLnug1NtpSjEXN\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol\":{\"keccak256\":\"0xbca4a4f66d98028293dba695851d1b20d3e0ba2fff7453fb241f192fa3fc6b6f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://013b3cfd9d1e34dad409c3b9a340860e8651e61cda509de33599fb5102f62fe7\",\"dweb:/ipfs/QmTVjDKofM9Nst8w8LAA3HHgi1eCnGYBpFb7Nbat71e2xz\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol\":{\"keccak256\":\"0xc163fcf9bb10138631a9ba5564df1fa25db9adff73bd9ee868a8ae1858fe093a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9706d43a0124053d9880f6e31a59f31bc0a6a3dc1acd66ce0a16e1111658c5f6\",\"dweb:/ipfs/QmUFmfowzkRwGtDu36cXV9SPTBHJ3n7dG9xQiK5B28jTf2\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol\":{\"keccak256\":\"0x631188737069917d2f909d29ce62c4d48611d326686ba6683e26b72a23bfac0b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7a61054ae84cd6c4d04c0c4450ba1d6de41e27e0a2c4f1bcdf58f796b401c609\",\"dweb:/ipfs/QmUvtdp7X1mRVyC3CsHrtPbgoqWaXHp3S1ZR24tpAQYJWM\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol\":{\"keccak256\":\"0x3f13b947637c4969c0644cab4ef399cdc4b67f101463b8775c5a43b118558e53\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c6683e6ade6985d394d32baaef5eea0d8b9ff0b3eca86ae413d6cdde114a9930\",\"dweb:/ipfs/QmdBE8T1BTddZxpdECMsb3KiCFyjNWmxcCddYrWFTXmWPj\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol\":{\"keccak256\":\"0x72d47aebad24c59f6e78d0c3e827440173419a333fd910a37fa1e532c98f7e4c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://dc8d1401a44d84ede55b6641d58f63f12a83aecb0816d577d947392b55a6b43b\",\"dweb:/ipfs/QmUskJ7JGzg17MAgRoZfZ3p7P9uucsgm2fKyXQvxdLThLE\"]},\"lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol\":{\"keccak256\":\"0xdaba3f7c42c55b2896353f32bd27d4d5f8bae741b3b05d4c53f67abc4dc47ce8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1fa2e61141c602510bcd2cd936ed9561922ac8772a9b9c9a9db091a74e354a45\",\"dweb:/ipfs/QmcHQDDoEBwJmwUbzoVkytvJsBx3KVHYFFnDkvRGWh9Wmh\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol\":{\"keccak256\":\"0xb6b36edd6a2999fd243ff226d6cbf84bd71af2432bbd0dfe19392996a1d9cb41\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1fd2f35495652e57e3f99bc6c510bc5f7dd398a176ea2e72d8ed730aebc6ca26\",\"dweb:/ipfs/QmTQV6X4gkikTib49cho5iDX3JvSQbdsoEChoDwrk3CbbH\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC1822.sol\":{\"keccak256\":\"0x2a1f9944df2015c081d89cd41ba22ffaf10aa6285969f0dc612b235cc448999c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ef381843676aec64421200ee85eaa0b1356a35f28b9fc67e746a6bbb832077d9\",\"dweb:/ipfs/QmY8aorMYA2TeTCnu6ejDjzb4rW4t7TCtW4GZ6LoxTFm7v\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol\":{\"keccak256\":\"0x06a78f9b3ee3e6d0eb4e4cd635ba49960bea34cac1db8c0a27c75f2319f1fd65\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://547d21aa17f4f3f1a1a7edf7167beff8dd9496a0348d5588f15cc8a4b29d052a\",\"dweb:/ipfs/QmT16JtRQSWNpLo9W23jr6CzaMuTAcQcjJJcdRd8HLJ6cE\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol\":{\"keccak256\":\"0xc59a78b07b44b2cf2e8ab4175fca91e8eca1eee2df7357b8d2a8833e5ea1f64c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5aa4f07e65444784c29cd7bfcc2341b34381e4e5b5da9f0c5bd00d7f430e66fa\",\"dweb:/ipfs/QmWRMh4Q9DpaU9GvsiXmDdoNYMyyece9if7hnfLz7uqzWM\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol\":{\"keccak256\":\"0xaf28a975a78550e45f65e559a3ad6a5ad43b9b8a37366999abd1b7084eb70721\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7bd24e224f67f65bfadf85dc2929fa965456bb2415478bd0125471b5ce35245\",\"dweb:/ipfs/QmRaydGr8BTHs1kvaZfsNU69pKzUAGFrvABn1KiRSbE51y\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0x32ba59b4b7299237c8ba56319110989d7978a039faf754793064e967e5894418\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1ae50c8b562427df610cc4540c9bf104acca7ef8e2dcae567ae7e52272281e9c\",\"dweb:/ipfs/QmTHiadFCSJUPpRjNegc5SahmeU8bAoY8i9Aq6tVscbcKR\"]},\"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x4296879f55019b23e135000eb36896057e7101fb7fb859c5ef690cf14643757b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://87b3541437c8c443ccd36795e56a338ed12855eec17f8da624511b8d1a7e14df\",\"dweb:/ipfs/QmeJQCtZrQjtJLr6u7ZHWeH3pBnjtLWzvRrKViAi7UZqxL\"]},\"src/BlacklistValidatorUpgradeable.sol\":{\"keccak256\":\"0xbb8c79ffd69464606a588487e9cd820b767544f722d65d3af419362677b2b8a0\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://f68eb5e0fbdb0233bb7bf0c274a53bf92761b29a3812c357db4cee6eafc462b2\",\"dweb:/ipfs/QmYRyJYfRqv61gmCEDNzWHJPp5BLLyhLoP2TMgJ9D94Gzg\"]},\"src/IValidator.sol\":{\"keccak256\":\"0xb0dbebb00e2cc65c329c41b56e6d02e213ece1b3b8ac2174b2385b143add2098\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://4a879b7943496744b9d1ef3350ef77d2dd25aa33be09805b65824e4710333ef8\",\"dweb:/ipfs/QmZy6joCeRxv47SSdNC7mMiZajZQU7dHGpawHZM7TzT2Fb\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","title":"BlacklistValidator","errors":{"FailedInnerCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"ERC1967NonPayable()":[{"details":"An upgrade function sees `msg.value > 0` that may be lost."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"UUPSUnauthorizedCallContext()":[{"details":"The call is from an unauthorized context."}],"AccessControlBadConfirmation()":[{"details":"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC1967InvalidImplementation(address)":[{"details":"The `implementation` of the proxy is invalid."}],"UUPSUnsupportedProxiableUUID(bytes32)":[{"details":"The storage `slot` is unsupported as a UUID."}],"AccessControlUnauthorizedAccount(address,bytes32)":[{"details":"The `account` is missing a role."}]},"events":{"Ban(address)":{"params":{"adversary":"Address added."},"details":"Emitted when an address is added to the blacklist."},"Unban(address)":{"params":{"friend":"Address removed."},"details":"Emitted when an address is removed from the blacklist."},"Upgraded(address)":{"details":"Emitted when the implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized or reinitialized."},"AdminAccountAdded(address)":{"params":{"account":"The address of the account."},"details":"Emitted when admin account is added."},"AdminAccountRemoved(address)":{"params":{"account":"The address of the account."},"details":"Emitted when admin account is removed."},"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"Decision(address,address,uint256,bool)":{"params":{"to":"Recipient address.","from":"Sender address.","valid":"True if transfer approved, false if rejected.","amount":"Number of tokens."},"details":"Emitted when a validator makes a decision."},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this."}},"details":"Rejects transfers from blacklisted addresses.","methods":{"owner()":{"details":"Returns the address of the current owner."},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"ban(address)":{"params":{"adversary":"Address to add."},"details":"Adds an address to the blacklist."},"initialize()":{"details":"Initializes the contract."},"CONTRACT_ID()":{"details":"Returns the contract identifier."},"isBan(address)":{"params":{"account":"Address to check."},"details":"Checks if an address is in the blacklist.","returns":{"_0":"true if the address is in the blacklist."}},"pendingOwner()":{"details":"Returns the address of the pending owner."},"unban(address)":{"params":{"friend":"Address to remove."},"details":"Removes an address from the blacklist."},"proxiableUUID()":{"details":"Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"isAdminAccount(address)":{"params":{"account":"The address of the account."},"details":"Checks wether an address is a admin account.","returns":{"_0":"true if admin account."}},"addAdminAccount(address)":{"params":{"account":"The address of the account."},"details":"add admin account."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner."},"removeAdminAccount(address)":{"params":{"account":"The address of the account."},"details":"remove admin account."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event."},"upgradeToAndCall(address,bytes)":{"details":"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.","custom:oz-upgrades-unsafe-allow-reachable":"delegatecall"},"validate(address,address,uint256)":{"details":"Validates token transfer. Implements IValidator interface."}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"502:4886:14:-:0;;;1171:4:4;1128:48;;2134:53:14;;;;;;;;;-1:-1:-1;2158:22:14;:20;:22::i;:::-;502:4886;;7711:422:3;8870:21;7900:15;;;;;;;7896:76;;;7938:23;;-1:-1:-1;;;7938:23:3;;;;;;;;;;;7896:76;7985:14;;-1:-1:-1;;;;;7985:14:3;;;:34;7981:146;;8035:33;;-1:-1:-1;;;;;;8035:33:3;-1:-1:-1;;;;;8035:33:3;;;;;8087:29;;158:50:16;;;8087:29:3;;146:2:16;131:18;8087:29:3;;;;;;;7981:146;7760:373;7711:422::o;14:200:16:-;502:4886:14;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"502:4886:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3443:202:0;;;;;;;;;;-1:-1:-1;3443:202:0;;;;;:::i;:::-;;:::i;:::-;;;470:14:16;;463:22;445:41;;433:2;418:18;3443:202:0;;;;;;;;4759:191;;;;;;;;;;-1:-1:-1;4759:191:0;;;;;:::i;:::-;;:::i;:::-;;;828:25:16;;;816:2;801:18;4759:191:0;682:177:16;5246:136:0;;;;;;;;;;-1:-1:-1;5246:136:0;;;;;:::i;:::-;;:::i;:::-;;3777:184:14;;;;;;;;;;-1:-1:-1;3777:184:14;;;;;:::i;:::-;-1:-1:-1;;;;;3934:20:14;3832:4;3934:20;;;-1:-1:-1;;;;;;;;;;;3934:20:14;;;;;;;;;3777:184;4738:120;;;;;;;;;;-1:-1:-1;4738:120:14;;;;;:::i;:::-;;:::i;6348:245:0:-;;;;;;;;;;-1:-1:-1;6348:245:0;;;;;:::i;:::-;;:::i;2874:79:14:-;;;;;;;;;;-1:-1:-1;799:66:14;2874:79;;4158:214:4;;;;;;:::i;:::-;;:::i;4961:156:14:-;;;;;;;;;;-1:-1:-1;4961:156:14;;;;;:::i;:::-;;:::i;3705:134:4:-;;;;;;;;;;;;;:::i;5223:162:14:-;;;;;;;;;;-1:-1:-1;5223:162:14;;;;;:::i;:::-;;:::i;3155:101:2:-;;;;;;;;;;;;;:::i;664:60:14:-;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;664:60:14;;2774:229:1;;;;;;;;;;;;;:::i;2248:149:14:-;;;;;;;;;;;;;:::i;2441:144:2:-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;2788:32:16;;;2770:51;;2758:2;2743:18;2441:144:2;2624:203:16;3732:207:0;;;;;;;;;;-1:-1:-1;3732:207:0;;;;;:::i;:::-;;:::i;3061:222:14:-;;;;;;;;;;-1:-1:-1;3061:222:14;;;;;:::i;:::-;;:::i;2317:49:0:-;;;;;;;;;;-1:-1:-1;2317:49:0;2362:4;2317:49;;4061:292:14;;;;;;;;;;-1:-1:-1;4061:292:14;;;;;:::i;:::-;;:::i;1819:58:4:-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1819:58:4;;;;;;;;;;;;:::i;3396:209:14:-;;;;;;;;;;-1:-1:-1;3396:209:14;;;;;:::i;:::-;;:::i;5662:138:0:-;;;;;;;;;;-1:-1:-1;5662:138:0;;;;;:::i;:::-;;:::i;1680:168:1:-;;;;;;;;;;;;;:::i;2041:247::-;;;;;;;;;;-1:-1:-1;2041:247:1;;;;;:::i;:::-;;:::i;3443:202:0:-;3528:4;-1:-1:-1;;;;;;3551:47:0;;-1:-1:-1;;;3551:47:0;;:87;;-1:-1:-1;;;;;;;;;;1133:40:6;;;3602:36:0;3544:94;3443:202;-1:-1:-1;;3443:202:0:o;4759:191::-;4824:7;4919:14;;;-1:-1:-1;;;;;;;;;;;4919:14:0;;;;;:24;;;;4759:191::o;5246:136::-;5320:18;5333:4;5320:12;:18::i;:::-;3191:16;3202:4;3191:10;:16::i;:::-;5350:25:::1;5361:4;5367:7;5350:10;:25::i;:::-;;5246:136:::0;;;:::o;4738:120:14:-;4800:4;4823:28;-1:-1:-1;;;;;;;;;;;4843:7:14;4823;:28::i;6348:245:0:-;-1:-1:-1;;;;;6441:34:0;;966:10:5;6441:34:0;6437:102;;6498:30;;-1:-1:-1;;;6498:30:0;;;;;;;;;;;6437:102;6549:37;6561:4;6567:18;6549:11;:37::i;:::-;;6348:245;;:::o;4158:214:4:-;2653:13;:11;:13::i;:::-;4273:36:::1;4291:17;4273;:36::i;:::-;4319:46;4341:17;4360:4;4319:21;:46::i;:::-;4158:214:::0;;:::o;4961:156:14:-;2334:13:2;:11;:13::i;:::-;5038:31:14::1;-1:-1:-1::0;;;;;;;;;;;5061:7:14::1;5038:10;:31::i;:::-;-1:-1:-1::0;5084:26:14::1;::::0;-1:-1:-1;;;;;5084:26:14;::::1;::::0;::::1;::::0;;;::::1;4961:156:::0;:::o;3705:134:4:-;3774:7;2924:20;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;;3705:134:4;:::o;5223:162:14:-;2334:13:2;:11;:13::i;:::-;5303:32:14::1;-1:-1:-1::0;;;;;;;;;;;5327:7:14::1;5303:11;:32::i;:::-;-1:-1:-1::0;5350:28:14::1;::::0;-1:-1:-1;;;;;5350:28:14;::::1;::::0;::::1;::::0;;;::::1;5223:162:::0;:::o;3155:101:2:-;2334:13;:11;:13::i;:::-;3219:30:::1;3246:1;3219:18;:30::i;:::-;3155:101::o:0;2774:229:1:-;966:10:5;;2869:14:1;:12;:14::i;:::-;-1:-1:-1;;;;;2869:24:1;;2865:96;;2916:34;;-1:-1:-1;;;2916:34:1;;-1:-1:-1;;;;;2788:32:16;;2916:34:1;;;2770:51:16;2743:18;;2916:34:1;;;;;;;;2865:96;2970:26;2989:6;2970:18;:26::i;:::-;2816:187;2774:229::o;2248:149:14:-;8870:21:3;4302:15;;-1:-1:-1;;;4302:15:3;;;;4301:16;;4348:14;;4158:30;4726:16;;:34;;;;;4746:14;4726:34;4706:54;;4770:17;4790:11;:16;;4805:1;4790:16;:50;;;;-1:-1:-1;4818:4:3;4810:25;:30;4790:50;4770:70;;4856:12;4855:13;:30;;;;;4873:12;4872:13;4855:30;4851:91;;;4908:23;;-1:-1:-1;;;4908:23:3;;;;;;;;;;;4851:91;4951:18;;-1:-1:-1;;4951:18:3;4968:1;4951:18;;;4979:67;;;;5013:22;;-1:-1:-1;;;;5013:22:3;-1:-1:-1;;;5013:22:3;;;4979:67;2299:21:14::1;:19;:21::i;:::-;2330:28;966:10:5::0;2330:14:14::1;:28::i;:::-;2368:22;:20;:22::i;:::-;5070:14:3::0;5066:101;;;5100:23;;-1:-1:-1;;;;5100:23:3;;;5142:14;;-1:-1:-1;3974:50:16;;5142:14:3;;3962:2:16;3947:18;5142:14:3;;;;;;;5066:101;4092:1081;;;;;2248:149:14:o;2441:144:2:-;2487:7;;1313:22;2533:20;2570:8;-1:-1:-1;;;;;2570:8:2;;2441:144;-1:-1:-1;;2441:144:2:o;3732:207:0:-;3809:4;3901:14;;;-1:-1:-1;;;;;;;;;;;3901:14:0;;;;;;;;-1:-1:-1;;;;;3901:31:0;;;;;;;;;;;;;;;3732:207::o;3061:222:14:-;4478:28;966:10:5;4738:120:14;:::i;4478:28::-;4473:81;;4529:14;;-1:-1:-1;;;4529:14:14;;;;;;;;;;;4473:81;-1:-1:-1;;;;;3218:22:14;::::1;3130:35;3218:22:::0;;;-1:-1:-1;;;;;;;;;;;3218:22:14::1;::::0;;;;;;;:29;;-1:-1:-1;;3218:29:14::1;3243:4;3218:29;::::0;;3262:14;1330:33;;3218:22;3262:14:::1;::::0;::::1;3120:163;3061:222:::0;:::o;4061:292::-;-1:-1:-1;;;;;4280:17:14;;;4169:10;4280:17;;;-1:-1:-1;;;;;;;;;;;4280:17:14;;;;;;;;;;4313:33;;4203:25:16;;;4280:17:14;;;;4278:20;4244:18:16;;;4237:50;;;4313:33:14;;4278:20;;1330:33;;4313;;;;;;;;;;;;;4181:172;4061:292;;;;;:::o;3396:209::-;4478:28;966:10:5;4738:120:14;:::i;4478:28::-;4473:81;;4529:14;;-1:-1:-1;;;4529:14:14;;;;;;;;;;;4473:81;-1:-1:-1;;;;;3543:19:14;::::1;3464:35;3543:19:::0;;;-1:-1:-1;;;;;;;;;;;3543:19:14::1;::::0;;;;;;;:27;;-1:-1:-1;;3543:27:14::1;::::0;;3585:13;1330:33;;3543:19;3585:13:::1;::::0;::::1;3454:151;3396:209:::0;:::o;5662:138:0:-;5737:18;5750:4;5737:12;:18::i;:::-;3191:16;3202:4;3191:10;:16::i;:::-;5767:26:::1;5779:4;5785:7;5767:11;:26::i;1680:168:1:-:0;1733:7;;1318:27;1784:25;1187:174;2041:247;2334:13:2;:11;:13::i;:::-;1318:27:1;2197:26;;-1:-1:-1;;;;;;2197:26:1::1;-1:-1:-1::0;;;;;2197:26:1;::::1;::::0;;::::1;::::0;;2263:7:::1;:5;:7::i;:::-;-1:-1:-1::0;;;;;2238:43:1::1;;;;;;;;;;;2120:168;2041:247:::0;:::o;4148:103:0:-;4214:30;4225:4;966:10:5;4214::0;:30::i;7270:387::-;7347:4;-1:-1:-1;;;;;;;;;;;7437:22:0;7445:4;7451:7;7437;:22::i;:::-;7432:219;;7475:8;:14;;;;;;;;;;;-1:-1:-1;;;;;7475:31:0;;;;;;;;;:38;;-1:-1:-1;;7475:38:0;7509:4;7475:38;;;7559:12;966:10:5;;887:96;7559:12:0;-1:-1:-1;;;;;7532:40:0;7550:7;-1:-1:-1;;;;;7532:40:0;7544:4;7532:40;;;;;;;;;;7593:4;7586:11;;;;;7432:219;7635:5;7628:12;;;;;7892:388;7970:4;-1:-1:-1;;;;;;;;;;;8059:22:0;8067:4;8073:7;8059;:22::i;:::-;8055:219;;;8131:5;8097:14;;;;;;;;;;;-1:-1:-1;;;;;8097:31:0;;;;;;;;;;:39;;-1:-1:-1;;8097:39:0;;;8155:40;966:10:5;;8097:14:0;;8155:40;;8131:5;8155:40;8216:4;8209:11;;;;;4599:312:4;4679:4;-1:-1:-1;;;;;4688:6:4;4671:23;;;:120;;;4785:6;-1:-1:-1;;;;;4749:42:4;:32;-1:-1:-1;;;;;;;;;;;2035:53:9;-1:-1:-1;;;;;2035:53:9;;1957:138;4749:32:4;-1:-1:-1;;;;;4749:42:4;;;4671:120;4654:251;;;4865:29;;-1:-1:-1;;;4865:29:4;;;;;;;;;;;2718:98:14;2334:13:2;:11;:13::i;6052:538:4:-;6169:17;-1:-1:-1;;;;;6151:50:4;;:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6151:52:4;;;;;;;;-1:-1:-1;;6151:52:4;;;;;;;;;;;;:::i;:::-;;;6147:437;;6513:60;;-1:-1:-1;;;6513:60:4;;-1:-1:-1;;;;;2788:32:16;;6513:60:4;;;2770:51:16;2743:18;;6513:60:4;2624:203:16;6147:437:4;-1:-1:-1;;;;;;;;;;;6245:40:4;;6241:120;;6312:34;;-1:-1:-1;;;6312:34:4;;;;;828:25:16;;;801:18;;6312:34:4;682:177:16;6241:120:4;6374:54;6404:17;6423:4;6374:29;:54::i;2658:162:2:-;966:10:5;2717:7:2;:5;:7::i;:::-;-1:-1:-1;;;;;2717:23:2;;2713:101;;2763:40;;-1:-1:-1;;;2763:40:2;;966:10:5;2763:40:2;;;2770:51:16;2743:18;;2763:40:2;2624:203:16;5028:213:4;5102:4;-1:-1:-1;;;;;5111:6:4;5094:23;;5090:145;;5195:29;;-1:-1:-1;;;5195:29:4;;;;;;;;;;;2472:222:1;1318:27;2621:22;;-1:-1:-1;;;;;;2621:22:1;;;2653:34;2678:8;2653:24;:34::i;1461:64::-;6931:20:3;:18;:20::i;1847:127:2:-;6931:20:3;:18;:20::i;:::-;1929:38:2::1;1954:12;1929:24;:38::i;4381:197:0:-:0;4469:22;4477:4;4483:7;4469;:22::i;:::-;4464:108;;4514:47;;-1:-1:-1;;;4514:47:0;;-1:-1:-1;;;;;4679:32:16;;4514:47:0;;;4661:51:16;4728:18;;;4721:34;;;4634:18;;4514:47:0;4487:274:16;2779:335:9;2870:37;2889:17;2870:18;:37::i;:::-;2922:27;;-1:-1:-1;;;;;2922:27:9;;;;;;;;2964:11;;:15;2960:148;;2995:53;3024:17;3043:4;2995:28;:53::i;2960:148::-;3079:18;:16;:18::i;3774:248:2:-;1313:22;3923:8;;-1:-1:-1;;;;;;3941:19:2;;-1:-1:-1;;;;;3941:19:2;;;;;;;;3975:40;;3923:8;;;;;3975:40;;3847:24;;3975:40;3837:185;;3774:248;:::o;7084:141:3:-;8870:21;8560:40;-1:-1:-1;;;8560:40:3;;;;7146:73;;7191:17;;-1:-1:-1;;;7191:17:3;;;;;;;;;;;1980:235:2;6931:20:3;:18;:20::i;:::-;-1:-1:-1;;;;;2076:26:2;::::1;2072:95;;2125:31;::::0;-1:-1:-1;;;2125:31:2;;2153:1:::1;2125:31;::::0;::::1;2770:51:16::0;2743:18;;2125:31:2::1;2624:203:16::0;2186:281:9;2263:17;-1:-1:-1;;;;;2263:29:9;;2296:1;2263:34;2259:119;;2320:47;;-1:-1:-1;;;2320:47:9;;-1:-1:-1;;;;;2788:32:16;;2320:47:9;;;2770:51:16;2743:18;;2320:47:9;2624:203:16;2259:119:9;-1:-1:-1;;;;;;;;;;;2387:73:9;;-1:-1:-1;;;;;;2387:73:9;-1:-1:-1;;;;;2387:73:9;;;;;;;;;;2186:281::o;4106:253:11:-;4189:12;4214;4228:23;4255:6;-1:-1:-1;;;;;4255:19:11;4275:4;4255:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4213:67;;;;4297:55;4324:6;4332:7;4341:10;4297:26;:55::i;:::-;4290:62;4106:253;-1:-1:-1;;;;;4106:253:11:o;6598:122:9:-;6648:9;:13;6644:70;;6684:19;;-1:-1:-1;;;6684:19:9;;;;;;;;;;;4625:582:11;4769:12;4798:7;4793:408;;4821:19;4829:10;4821:7;:19::i;:::-;4793:408;;;5045:17;;:22;:49;;;;-1:-1:-1;;;;;;5071:18:11;;;:23;5045:49;5041:119;;;5121:24;;-1:-1:-1;;;5121:24:11;;-1:-1:-1;;;;;2788:32:16;;5121:24:11;;;2770:51:16;2743:18;;5121:24:11;2624:203:16;5041:119:11;-1:-1:-1;5180:10:11;4793:408;4625:582;;;;;:::o;5743:516::-;5874:17;;:21;5870:383;;6102:10;6096:17;6158:15;6145:10;6141:2;6137:19;6130:44;5870:383;6225:17;;-1:-1:-1;;;6225:17:11;;;;;;;;;;;14:286:16;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:16;;209:43;;199:71;;266:1;263;256:12;497:180;556:6;609:2;597:9;588:7;584:23;580:32;577:52;;;625:1;622;615:12;577:52;-1:-1:-1;648:23:16;;497:180;-1:-1:-1;497:180:16:o;864:173::-;932:20;;-1:-1:-1;;;;;981:31:16;;971:42;;961:70;;1027:1;1024;1017:12;961:70;864:173;;;:::o;1042:254::-;1110:6;1118;1171:2;1159:9;1150:7;1146:23;1142:32;1139:52;;;1187:1;1184;1177:12;1139:52;1223:9;1210:23;1200:33;;1252:38;1286:2;1275:9;1271:18;1252:38;:::i;:::-;1242:48;;1042:254;;;;;:::o;1301:186::-;1360:6;1413:2;1401:9;1392:7;1388:23;1384:32;1381:52;;;1429:1;1426;1419:12;1381:52;1452:29;1471:9;1452:29;:::i;1492:127::-;1553:10;1548:3;1544:20;1541:1;1534:31;1584:4;1581:1;1574:15;1608:4;1605:1;1598:15;1624:995;1701:6;1709;1762:2;1750:9;1741:7;1737:23;1733:32;1730:52;;;1778:1;1775;1768:12;1730:52;1801:29;1820:9;1801:29;:::i;:::-;1791:39;;1881:2;1870:9;1866:18;1853:32;1904:18;1945:2;1937:6;1934:14;1931:34;;;1961:1;1958;1951:12;1931:34;1999:6;1988:9;1984:22;1974:32;;2044:7;2037:4;2033:2;2029:13;2025:27;2015:55;;2066:1;2063;2056:12;2015:55;2102:2;2089:16;2124:2;2120;2117:10;2114:36;;;2130:18;;:::i;:::-;2205:2;2199:9;2173:2;2259:13;;-1:-1:-1;;2255:22:16;;;2279:2;2251:31;2247:40;2235:53;;;2303:18;;;2323:22;;;2300:46;2297:72;;;2349:18;;:::i;:::-;2389:10;2385:2;2378:22;2424:2;2416:6;2409:18;2464:7;2459:2;2454;2450;2446:11;2442:20;2439:33;2436:53;;;2485:1;2482;2475:12;2436:53;2541:2;2536;2532;2528:11;2523:2;2515:6;2511:15;2498:46;2586:1;2581:2;2576;2568:6;2564:15;2560:24;2553:35;2607:6;2597:16;;;;;;;1624:995;;;;;:::o;2832:328::-;2909:6;2917;2925;2978:2;2966:9;2957:7;2953:23;2949:32;2946:52;;;2994:1;2991;2984:12;2946:52;3017:29;3036:9;3017:29;:::i;:::-;3007:39;;3065:38;3099:2;3088:9;3084:18;3065:38;:::i;:::-;3055:48;;3150:2;3139:9;3135:18;3122:32;3112:42;;2832:328;;;;;:::o;3165:250::-;3250:1;3260:113;3274:6;3271:1;3268:13;3260:113;;;3350:11;;;3344:18;3331:11;;;3324:39;3296:2;3289:10;3260:113;;;-1:-1:-1;;3407:1:16;3389:16;;3382:27;3165:250::o;3420:396::-;3569:2;3558:9;3551:21;3532:4;3601:6;3595:13;3644:6;3639:2;3628:9;3624:18;3617:34;3660:79;3732:6;3727:2;3716:9;3712:18;3707:2;3699:6;3695:15;3660:79;:::i;:::-;3800:2;3779:15;-1:-1:-1;;3775:29:16;3760:45;;;;3807:2;3756:54;;3420:396;-1:-1:-1;;3420:396:16:o;4298:184::-;4368:6;4421:2;4409:9;4400:7;4396:23;4392:32;4389:52;;;4437:1;4434;4427:12;4389:52;-1:-1:-1;4460:16:16;;4298:184;-1:-1:-1;4298:184:16:o;4766:287::-;4895:3;4933:6;4927:13;4949:66;5008:6;5003:3;4996:4;4988:6;4984:17;4949:66;:::i;:::-;5031:16;;;;;4766:287;-1:-1:-1;;4766:287:16:o","linkReferences":{},"immutableReferences":{"968":[{"start":2982,"length":32},{"start":3023,"length":32},{"start":3392,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"acceptOwnership()","signatureHash4":"0x79ba5097","signatureHash32":"0x79ba5097e5519a381a52113cdcc59540d13f73fd9d26abc0453484a096cc96f2"},{"signature":"addAdminAccount(address)","signatureHash4":"0x4fe57e7a","signatureHash32":"0x4fe57e7aeef8a0c3c93a09eee8d048a47288b01aa7536e78e0e2f1c99830618f"},{"signature":"ADMIN_ROLE()","signatureHash4":"0x75b238fc","signatureHash32":"0x75b238fcfe57c335a03dd53fc4e92497cb515c943e5b3bb6c303dd55b6a02046"},{"signature":"ban(address)","signatureHash4":"0x97c3ccd8","signatureHash32":"0x97c3ccd8841dd41a2f6e2a49e12247afa2a5cefdca17efa3813370952efa2994"},{"signature":"CONTRACT_ID()","signatureHash4":"0x3e35487c","signatureHash32":"0x3e35487c0e92d1a1a46044db07d174b2f70a9b45d4d93e684d43bbe14f7ce23c"},{"signature":"DEFAULT_ADMIN_ROLE()","signatureHash4":"0xa217fddf","signatureHash32":"0xa217fddfde7807bb766525e432eeeecaaf4de889a05e8df9fb827257fb978cf4"},{"signature":"getRoleAdmin(bytes32)","signatureHash4":"0x248a9ca3","signatureHash32":"0x248a9ca39e7e298ea3bbd193e7d36b87492efea84ff513fd03940aaa5bc0d98f"},{"signature":"grantRole(bytes32,address)","signatureHash4":"0x2f2ff15d","signatureHash32":"0x2f2ff15deca029b64bbc0874ae59c8f39be024a95aa718b4c13ca407db350be8"},{"signature":"hasRole(bytes32,address)","signatureHash4":"0x91d14854","signatureHash32":"0x91d1485424b278bc736d5d34907ed48280c7188845bc82b33370da2b4dc1194e"},{"signature":"initialize()","signatureHash4":"0x8129fc1c","signatureHash32":"0x8129fc1cf5a76b8b9d76c7ab5059b1685decddb2380c6e4cebb774b7c17ae83f"},{"signature":"isAdminAccount(address)","signatureHash4":"0x329e0587","signatureHash32":"0x329e05876d84ad23094b82594387f69310069a53436b6176e36d3e5086ac7b30"},{"signature":"isBan(address)","signatureHash4":"0x2f7398fb","signatureHash32":"0x2f7398fb886568db49e81d92fc54331ca8923a6069b3dcb71d79aacfd2928ef2"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"pendingOwner()","signatureHash4":"0xe30c3978","signatureHash32":"0xe30c3978ddd82956a01b5cb08d17f1a2d73e636aeefb7b36f896e41d4c2aab90"},{"signature":"proxiableUUID()","signatureHash4":"0x52d1902d","signatureHash32":"0x52d1902ddf94a87b87c42e6ab3aff7da3c30beb57dc65dd86cb2543522a55a4c"},{"signature":"removeAdminAccount(address)","signatureHash4":"0x67a89a72","signatureHash32":"0x67a89a72e836e8aa988ea3173b3fa06c27de470fc226603ce6fa75d6cc88e27e"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"renounceRole(bytes32,address)","signatureHash4":"0x36568abe","signatureHash32":"0x36568abe2c7e6c1d662bad0fe1760ac72cf2f9478a86be824d68ec83895c49e9"},{"signature":"revokeRole(bytes32,address)","signatureHash4":"0xd547741f","signatureHash32":"0xd547741fd8d55981251e167708119763c372f2b41e85a1468b0a759b055a009f"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"unban(address)","signatureHash4":"0xb9f14557","signatureHash32":"0xb9f145574aea91c936072283947e3fde5a594a788be78d00ab32afbe48ee5ea0"},{"signature":"UPGRADE_INTERFACE_VERSION()","signatureHash4":"0xad3cb1cc","signatureHash32":"0xad3cb1cc5c2df3b903ea43f30f77a80ecfeefbed7932a4a8e68c92af99e41dfd"},{"signature":"upgradeToAndCall(address,bytes)","signatureHash4":"0x4f1ef286","signatureHash32":"0x4f1ef2866b98625bdfefae89411f7a82754ac4089eff8e78c8832329a538337f"},{"signature":"validate(address,address,uint256)","signatureHash4":"0xaa3ad4e4","signatureHash32":"0xaa3ad4e4e75228d990dac62d387014b6ef4c6db4c857f4115cd87ea8245e206c"}],"event":[{"signature":"AdminAccountAdded(address)","signatureHash4":"0x5c7eb798","signatureHash32":"0x5c7eb798b922f0164aa9c5340006161c64436190a49eebc58b4e6e0715700ae6"},{"signature":"AdminAccountRemoved(address)","signatureHash4":"0xc3198db9","signatureHash32":"0xc3198db98a2c50068f0a99b9297e60b2dbf0eafcde57e366e70a29f887c44e10"},{"signature":"Ban(address)","signatureHash4":"0x9a4e7572","signatureHash32":"0x9a4e757235705bd178419abc9fa645392c5c7dce5b09940a81ef76794b84bd68"},{"signature":"Decision(address,address,uint256,bool)","signatureHash4":"0x7421973e","signatureHash32":"0x7421973e31248bda00bf2f04b80b46b34fc9e23ab57848234aed6cc5d437b6a8"},{"signature":"Initialized(uint64)","signatureHash4":"0xc7f505b2","signatureHash32":"0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"OwnershipTransferStarted(address,address)","signatureHash4":"0x38d16b8c","signatureHash32":"0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700"},{"signature":"RoleAdminChanged(bytes32,bytes32,bytes32)","signatureHash4":"0xbd79b86f","signatureHash32":"0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff"},{"signature":"RoleGranted(bytes32,address,address)","signatureHash4":"0x2f878811","signatureHash32":"0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d"},{"signature":"RoleRevoked(bytes32,address,address)","signatureHash4":"0xf6391f5c","signatureHash32":"0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b"},{"signature":"Unban(address)","signatureHash4":"0x866c4c4c","signatureHash32":"0x866c4c4c778f85c380f911e6c43d125e57865fec38a5ccf53b62b74a8473ed16"},{"signature":"Upgraded(address)","signatureHash4":"0xbc7cd75a","signatureHash32":"0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b"}],"error":[{"signature":"AccessControlBadConfirmation()","signatureHash4":"0x6697b232","signatureHash32":"0x6697b23232a647058342c0724fe7c415cab25915b54e5dbc03f233173d37b41c"},{"signature":"AccessControlUnauthorizedAccount(address,bytes32)","signatureHash4":"0xe2517d3f","signatureHash32":"0xe2517d3fbfae6f8515ef5ff1ccedc3933ab0cbbda0b492c06eb54ad10ef03b3e"},{"signature":"AddressEmptyCode(address)","signatureHash4":"0x9996b315","signatureHash32":"0x9996b315c842ff135b8fc4a08ad5df1c344efbc03d2687aecc0678050d2aac89"},{"signature":"ERC1967InvalidImplementation(address)","signatureHash4":"0x4c9c8ce3","signatureHash32":"0x4c9c8ce3ceb3130f17f7cdba48d89b5b0129f266a8bac114e6e315a41879b617"},{"signature":"ERC1967NonPayable()","signatureHash4":"0xb398979f","signatureHash32":"0xb398979fa84f543c8e222f17890372c487baf85e062276c127fef521eea7224b"},{"signature":"FailedInnerCall()","signatureHash4":"0x1425ea42","signatureHash32":"0x1425ea42df7c932537f94e8b917ea9c5931f140fb6e8098822ef05dc56222ca9"},{"signature":"InvalidInitialization()","signatureHash4":"0xf92ee8a9","signatureHash32":"0xf92ee8a957075833165f68c320933b1a1294aafc84ee6e0dd3fb178008f9aaf5"},{"signature":"NotInitializing()","signatureHash4":"0xd7e6bcf8","signatureHash32":"0xd7e6bcf8597daa127dc9f0048d2f08d5ef140a2cb659feabd700beff1f7a8302"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"},{"signature":"UUPSUnauthorizedCallContext()","signatureHash4":"0xe07c8dba","signatureHash32":"0xe07c8dba242a06571ac65fe4bbe20522c9fb111cb33599b799ff8039c1ed18f4"},{"signature":"UUPSUnsupportedProxiableUUID(bytes32)","signatureHash4":"0xaa1d49a4","signatureHash32":"0xaa1d49a4c084bfa9aeeee2a0be65267a7f19ba7e1476b114dac513d2c14cb563"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"8453","address":"0x7425926e3B8540E8175185EBC36482E3758bBFa7"}