{"matchId":"42553511","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-07-18T03:33:05Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"967:122:24:-:0;;;1002:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1062:7;1071:12;808:1:26;820;824:7;833:12;742:16:25;772:17;803:7;824:12;2356:385:27;;;;;;;;;;;;;-1:-1:-1;;;2356:385:27;;;;;;;;;;;;;;;;-1:-1:-1;;;2356:385:27;;;2607:16;2592:5;1616:4:5;3328:431:15;;;;;;;;;;;;;-1:-1:-1;;;3328:431:15;;;2564:5:27;2571:7;1675:5:2;1667;:13;;;;;;:::i;:::-;-1:-1:-1;1690:7:2;:17;1700:7;1690;:17;:::i;:::-;-1:-1:-1;3401:45:15;;-1:-1:-1;3401:4:15;;-1:-1:-1;3432:13:15;3401:30;:45::i;:::-;3393:53;;3467:51;:7;3501:16;3467:33;:51::i;:::-;3456:62;;3542:22;;;;;;;;;;3528:36;;3591:25;;;;;;3574:42;;3644:13;3627:30;;3692:23;4226:11;;4239:14;;4204:80;;;2079:95;4204:80;;;3699:25:35;3740:18;;;3733:34;;;;3783:18;;;3776:34;4255:13:15;3826:18:35;;;3819:34;4278:4:15;3869:19:35;;;3862:61;4168:7:15;;3671:19:35;;4204:80:15;;;;;;;;;;;;4194:91;;;;;;4187:98;;4113:179;;3692:23;3667:48;;-1:-1:-1;;3747:4:15;3725:27;;-1:-1:-1;;;;;;409:20:28;;405:52;;438:19;;-1:-1:-1;;;438:19:28;;;;;;;;;;;405:52;467:5;:14;;-1:-1:-1;;;;;;467:14:28;-1:-1:-1;;;;;467:14:28;;;;;;;;496:32;;;-1:-1:-1;3309:51:35;;3391:2;3376:18;;3369:60;;;;496:32:28;;3282:18:35;496:32:28;;;;;;;-1:-1:-1;;;;;;;;2635:27:27;;::::3;;::::0;2672:16;;::::3;;::::0;2698::::3;:36:::0;;-1:-1:-1;;;;;;2698:36:27::3;::::0;;;::::3;::::0;;;::::3;::::0;;-1:-1:-1;967:122:24;;-1:-1:-1;;;;;;;;967:122:24;2887:340:11;2983:11;3032:2;3016:5;3010:19;:24;3006:215;;;3057:20;3071:5;3057:13;:20::i;:::-;3050:27;;;;3006:215;3134:5;3108:46;3149:5;3134;3108:46;:::i;:::-;-1:-1:-1;1390:66:11;;-1:-1:-1;3006:215:11;2887:340;;;;:::o;1708:286::-;1773:11;1796:17;1822:3;1796:30;;1854:2;1840:4;:11;:16;1836:72;;;1893:3;1879:18;;-1:-1:-1;;;1879:18:11;;;;;;;;:::i;:::-;;;;;;;;1836:72;1974:11;;1957:13;1974:4;1957:13;:::i;:::-;1949:36;;1708:286;-1:-1:-1;;;1708:286:11:o;14:177:35:-;93:13;;-1:-1:-1;;;;;135:31:35;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;494:127::-;555:10;550:3;546:20;543:1;536:31;586:4;583:1;576:15;610:4;607:1;600:15;626:380;705:1;701:12;;;;748;;;769:61;;823:4;815:6;811:17;801:27;;769:61;876:2;868:6;865:14;845:18;842:38;839:161;;922:10;917:3;913:20;910:1;903:31;957:4;954:1;947:15;985:4;982:1;975:15;839:161;;626:380;;;:::o;1137:518::-;1239:2;1234:3;1231:11;1228:421;;;1275:5;1272:1;1265:16;1319:4;1316:1;1306:18;1389:2;1377:10;1373:19;1370:1;1366:27;1360:4;1356:38;1425:4;1413:10;1410:20;1407:47;;;-1:-1:-1;1448:4:35;1407:47;1503:2;1498:3;1494:12;1491:1;1487:20;1481:4;1477:31;1467:41;;1558:81;1576:2;1569:5;1566:13;1558:81;;;1635:1;1621:16;;1602:1;1591:13;1558:81;;;1562:3;;1228:421;1137:518;;;:::o;1831:1299::-;1951:10;;-1:-1:-1;;;;;1973:30:35;;1970:56;;;2006:18;;:::i;:::-;2035:97;2125:6;2085:38;2117:4;2111:11;2085:38;:::i;:::-;2079:4;2035:97;:::i;:::-;2181:4;2212:2;2201:14;;2229:1;2224:649;;;;2917:1;2934:6;2931:89;;;-1:-1:-1;2986:19:35;;;2980:26;2931:89;-1:-1:-1;;1788:1:35;1784:11;;;1780:24;1776:29;1766:40;1812:1;1808:11;;;1763:57;3033:81;;2194:930;;2224:649;1084:1;1077:14;;;1121:4;1108:18;;-1:-1:-1;;2260:20:35;;;2378:222;2392:7;2389:1;2386:14;2378:222;;;2474:19;;;2468:26;2453:42;;2581:4;2566:20;;;;2534:1;2522:14;;;;2408:12;2378:222;;;2382:3;2628:6;2619:7;2616:19;2613:201;;;2689:19;;;2683:26;-1:-1:-1;;2772:1:35;2768:14;;;2784:3;2764:24;2760:37;2756:42;2741:58;2726:74;;2613:201;-1:-1:-1;;;;2860:1:35;2844:14;;;2840:22;2827:36;;-1:-1:-1;1831:1299:35:o;3934:418::-;4083:2;4072:9;4065:21;4046:4;4115:6;4109:13;4158:6;4153:2;4142:9;4138:18;4131:34;4217:6;4212:2;4204:6;4200:15;4195:2;4184:9;4180:18;4174:50;4273:1;4268:2;4259:6;4248:9;4244:22;4240:31;4233:42;4343:2;4336;4332:7;4327:2;4319:6;4315:15;4311:29;4300:9;4296:45;4292:54;4284:62;;;3934:418;;;;:::o;4357:297::-;4475:12;;4522:4;4511:16;;;4505:23;;4475:12;4540:16;;4537:111;;;-1:-1:-1;;4614:4:35;4610:17;;;;4607:1;4603:25;4599:38;4588:50;;4357:297;-1:-1:-1;4357:297:35:o;:::-;967:122:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{},"transformations":[{"type":"insert","offset":10625,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x0000000000000000000000004200000000000000000000000000000000000010000000000000000000000000cf62f905562626cfcdd2261162a51fd02fc9c5b6"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"967:122:24:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4511:519:27;;;;;;:::i;:::-;;:::i;:::-;;;470:14:35;;463:22;445:41;;433:2;418:18;4511:519:27;;;;;;;;1714:37;;;;;;;;-1:-1:-1;;;;;661:32:35;;;643:51;;631:2;616:18;1714:37:27;497:203:35;1779:89:2;;;:::i;:::-;;;;;;;:::i;3998:186::-;;;;;;:::i;:::-;;:::i;541:138:28:-;;;;;;:::i;:::-;;:::i;:::-;;2849:97:2;2927:12;;2849:97;;;2044:25:35;;;2032:2;2017:18;2849:97:2;1898:177:35;4776:244:2;;;;;;:::i;:::-;;:::i;7267:684:27:-;;;;;;:::i;:::-;;:::i;2707:82:2:-;;;2780:2;2601:36:35;;2589:2;2574:18;2707:82:2;2459:184:35;2659:112:5;;;:::i;5272:218:27:-;;;;;;:::i;:::-;;:::i;618:87:4:-;;;;;;:::i;:::-;;:::i;260:29:28:-;;;;;-1:-1:-1;;;;;260:29:28;;;640:95:26;714:14;;;;;;;;;;;;-1:-1:-1;;;714:14:26;;;;640:95;;8614:220:32;;;;;;:::i;:::-;;:::i;6519:191:27:-;;;;;;:::i;:::-;;:::i;3004:116:2:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3095:18:2;3069:7;3095:18;;;;;;;;;;;;3004:116;6144:199:27;;;;;;:::i;:::-;;:::i;685:348:28:-;;;:::i;1021:158:4:-;;;;;;:::i;:::-;;:::i;2409:143:5:-;;;;;;:::i;:::-;;:::i;5144:557:15:-;;;:::i;:::-;;;;;;;;;;;;;:::i;7107:1079:32:-;;;;;;:::i;:::-;;:::i;234:20:28:-;;;;;-1:-1:-1;;;;;234:20:28;;;1981:93:2;;;:::i;6812:347:27:-;;;;;;:::i;:::-;;:::i;5671:224::-;;;;;;:::i;:::-;;:::i;1164:517:33:-;;;;;;:::i;:::-;;:::i;3315:178:2:-;;;;;;:::i;:::-;;:::i;3841:80:27:-;3908:6;3841:80;;9205:554:32;;;;;;:::i;:::-;;:::i;8126:245:27:-;;;;;;:::i;:::-;;:::i;3612:85::-;3678:12;3612:85;;3943:995:32;;;;;;:::i;:::-;;:::i;1818:360:26:-;;;;;;:::i;:::-;;:::i;1806:30:27:-;;;;;;:::i;:::-;;:::i;1484:31::-;;;;;-1:-1:-1;;;;;1484:31:27;;;3551:140:2;;;;;;:::i;:::-;-1:-1:-1;;;;;3657:18:2;;;3631:7;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3551:140;2779:569:32;;;;;;:::i;:::-;;:::i;11562:181::-;;;;;;:::i;:::-;-1:-1:-1;;;;;11671:58:32;;;;11648:4;11671:58;;;-1:-1:-1;;;;;;;;;;;11671:58:32;;;;;;;;:65;;;;;;;;;;;11562:181;1588:31:27;;;;;5761:567:32;;;;;;:::i;:::-;;:::i;1946:39:27:-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;4511:519;4590:4;-1:-1:-1;;;;;;;;;;;;;;;4949:22:27;;;;;:48;;-1:-1:-1;;;;;;;4975:22:27;;;;;;;4949:48;:74;;;-1:-1:-1;;;;;;;5001:22:27;;;;;;;4949:74;4942:81;4511:519;-1:-1:-1;;;;;4511:519:27:o;1779:89:2:-;1824:13;1856:5;1849:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89;:::o;3998:186::-;4071:4;735:10:8;4125:31:2;735:10:8;4141:7:2;4150:5;4125:8;:31::i;:::-;4173:4;4166:11;;;3998:186;;;;;:::o;541:138:28:-;1180:5;;-1:-1:-1;;;;;1180:5:28;1166:10;:19;1162:43;;1194:11;;-1:-1:-1;;;1194:11:28;;;;;;;;;;;1162:43;612:14:::1;:23:::0;;-1:-1:-1;;;;;;612:23:28::1;-1:-1:-1::0;;;;;612:23:28;::::1;::::0;;::::1;::::0;;;650:22:::1;::::0;643:51:35;;;650:22:28::1;::::0;631:2:35;616:18;650:22:28::1;;;;;;;;541:138:::0;:::o;4776:244:2:-;4863:4;735:10:8;4919:37:2;4935:4;735:10:8;4950:5:2;4919:15;:37::i;:::-;4966:26;4976:4;4982:2;4986:5;4966:9;:26::i;:::-;5009:4;5002:11;;;4776:244;;;;;;:::o;7267:684:27:-;2933:16;;-1:-1:-1;;;;;2933:16:27;2919:10;:30;;:53;;-1:-1:-1;2967:5:27;;-1:-1:-1;;;;;2967:5:27;2953:10;:19;2919:53;2911:87;;;;-1:-1:-1;;;2911:87:27;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;7351:28:27;::::1;7343:62;;;;-1:-1:-1::0;;;7343:62:27::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7423:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:31;;:23:::0;:31:::1;7415:64;;;::::0;-1:-1:-1;;;7415:64:27;;11842:2:35;7415:64:27::1;::::0;::::1;11824:21:35::0;11881:2;11861:18;;;11854:30;-1:-1:-1;;;11900:18:35;;;11893:50;11960:18;;7415:64:27::1;11640:344:35::0;7415:64:27::1;-1:-1:-1::0;;;;;7532:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;7525:30;;-1:-1:-1;;7525:30:27::1;::::0;;7631:269:::1;7655:13;:20:::0;7651:24;::::1;7631:269;;;7720:14;-1:-1:-1::0;;;;;7700:34:27::1;:13;7714:1;7700:16;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;7700:16:27::1;:34:::0;7696:194:::1;;7781:1;7754:13;7768:1;7754:16;;;;;;;;:::i;:::-;;;;;;;;;:29;;;;;-1:-1:-1::0;;;;;7754:29:27::1;;;;;-1:-1:-1::0;;;;;7754:29:27::1;;;;;;7870:5;;7696:194;7677:3;;7631:269;;;-1:-1:-1::0;7915:29:27::1;::::0;-1:-1:-1;;;;;661:32:35;;643:51;;7915:29:27::1;::::0;631:2:35;616:18;7915:29:27::1;497:203:35::0;2659:112:5;2718:7;2744:20;:18;:20::i;:::-;2737:27;;2659:112;:::o;5272:218:27:-;3306:10;-1:-1:-1;;;;;3320:6:27;3306:20;;3298:85;;;;-1:-1:-1;;;3298:85:27;;;;;;;:::i;:::-;5431:19:::1;5437:3;5442:7;5431:5;:19::i;:::-;5470:3;-1:-1:-1::0;;;;;5465:18:27::1;;5475:7;5465:18;;;;2044:25:35::0;;2032:2;2017:18;;1898:177;5465:18:27::1;;;;;;;;5272:218:::0;;:::o;618:87:4:-;672:26;735:10:8;692:5:4;672;:26::i;:::-;618:87;:::o;8614:220:32:-;8728:99;8762:10;8781:5;8816:1;8819;8822;8799:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;8728:19;:99::i;:::-;8614:220;;;;;:::o;6519:191:27:-;3143:10;3135:19;;;;:7;:19;;;;;;;;:27;;:19;:27;3127:52;;;;-1:-1:-1;;;3127:52:27;;13087:2:35;3127:52:27;;;13069:21:35;13126:2;13106:18;;;13099:30;-1:-1:-1;;;13145:18:35;;;13138:42;13197:18;;3127:52:27;12885:336:35;3127:52:27;6606:32:::1;6618:9;6629:8;6606:11;:32::i;:::-;6653:50;::::0;2044:25:35;;;-1:-1:-1;;;;;6653:50:27;::::1;::::0;6671:10:::1;::::0;6653:50:::1;::::0;2032:2:35;2017:18;6653:50:27::1;;;;;;;;6519:191:::0;;:::o;6144:199::-;3143:10;3135:19;;;;:7;:19;;;;;;;;:27;;:19;:27;3127:52;;;;-1:-1:-1;;;3127:52:27;;13087:2:35;3127:52:27;;;13069:21:35;13126:2;13106:18;;;13099:30;-1:-1:-1;;;13145:18:35;;;13138:42;13197:18;;3127:52:27;12885:336:35;3127:52:27;6236:35:::1;6251:9;6262:8;6236:14;:35::i;:::-;6286:50;::::0;2044:25:35;;;6315:10:27::1;::::0;-1:-1:-1;;;;;6286:50:27;::::1;::::0;::::1;::::0;2032:2:35;2017:18;6286:50:27::1;1898:177:35::0;685:348:28;856:14;;-1:-1:-1;;;;;856:14:28;842:10;:28;838:69;;879:28;;-1:-1:-1;;;879:28:28;;;;;;;;;;;838:69;935:5;;942:14;;922:35;;;-1:-1:-1;;;;;935:5:28;;;13400:51:35;;942:14:28;;;;13482:2:35;13467:18;;13460:60;922:35:28;;13373:18:35;922:35:28;;;;;;;975:14;;;967:5;:22;;-1:-1:-1;;;;;;967:22:28;;;-1:-1:-1;;;;;975:14:28;;967:22;;;;999:27;;;685:348::o;1021:158:4:-;1096:45;1112:7;735:10:8;1135:5:4;1096:15;:45::i;:::-;1151:21;1157:7;1166:5;1151;:21::i;:::-;1021:158;;:::o;2409:143:5:-;-1:-1:-1;;;;;624:14:9;;2500:7:5;624:14:9;;;:7;:14;;;;;;2526:19:5;538:107:9;5144:557:15;5242:13;5269:18;5301:21;5336:15;5365:25;5404:12;5430:27;5533:13;:11;:13::i;:::-;5560:16;:14;:16::i;:::-;5668;;;5652:1;5668:16;;;;;;;;;-1:-1:-1;;;5482:212:15;;;-1:-1:-1;5482:212:15;;-1:-1:-1;5590:13:15;;-1:-1:-1;5625:4:15;;-1:-1:-1;5652:1:15;-1:-1:-1;5668:16:15;-1:-1:-1;5482:212:15;-1:-1:-1;5144:557:15:o;7107:1079:32:-;-1:-1:-1;;;;;7387:16:32;;7393:10;7387:16;7383:76;;7412:47;;-1:-1:-1;;;7412:47:32;;7435:10;7412:47;;;13400:51:35;-1:-1:-1;;;;;13487:32:35;;13467:18;;;13460:60;13373:18;;7412:47:32;13226:300:35;7383:76:32;7492:10;7473:15;:29;7469:64;;7511:22;;-1:-1:-1;;;7511:22:32;;;;;;;;;;;7469:64;7566:11;7547:15;:30;7543:65;;7586:22;;-1:-1:-1;;;7586:22:32;;;;;;;;;;;7543:65;7618:63;7660:4;7673:5;7618:27;:63::i;:::-;7727:262;7777:4;837:66;7845:35;;7882:4;7888:2;7892:5;7899:10;7911:11;7924:5;7834:96;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7807:137;;;;;;7969:9;7727:27;:262::i;:::-;8060:60;8099:4;8112:5;8060:24;:60::i;:::-;8130:49;8149:4;8159:2;8171:5;8130:10;:49::i;:::-;;7107:1079;;;;;;;:::o;1981:93:2:-;2028:13;2060:7;2053:14;;;;;:::i;6812:347:27:-;2933:16;;-1:-1:-1;;;;;2933:16:27;2919:10;:30;;:53;;-1:-1:-1;2967:5:27;;-1:-1:-1;;;;;2967:5:27;2953:10;:19;2919:53;2911:87;;;;-1:-1:-1;;;2911:87:27;;;;;;;:::i;:::-;-1:-1:-1;;;;;6893:28:27;::::1;6885:62;;;;-1:-1:-1::0;;;6885:62:27::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6966:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:32;6958:67;;;::::0;-1:-1:-1;;;6958:67:27;;14397:2:35;6958:67:27::1;::::0;::::1;14379:21:35::0;14436:2;14416:18;;;14409:30;-1:-1:-1;;;14455:18:35;;;14448:52;14517:18;;6958:67:27::1;14195:346:35::0;6958:67:27::1;-1:-1:-1::0;;;;;7035:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;;;;:30;;-1:-1:-1;;7035:30:27::1;7061:4;7035:30:::0;;::::1;::::0;;;7075:13:::1;:34:::0;;;;::::1;::::0;;;;;;;;::::1;::::0;;-1:-1:-1;;;;;;7075:34:27::1;::::0;::::1;::::0;;7125:27;;643:51:35;;;7125:27:27::1;::::0;616:18:35;7125:27:27::1;497:203:35::0;5671:224:27;3306:10;-1:-1:-1;;;;;3320:6:27;3306:20;;3298:85;;;;-1:-1:-1;;;3298:85:27;;;;;;;:::i;:::-;5832:21:::1;5838:5;5845:7;5832:5;:21::i;:::-;5873:5;-1:-1:-1::0;;;;;5868:20:27::1;;5880:7;5868:20;;;;2044:25:35::0;;2032:2;2017:18;;1898:177;1164:517:33;1367:8;1348:15;:27;;1340:64;;;;-1:-1:-1;;;1340:64:33;;14748:2:35;1340:64:33;;;14730:21:35;14787:2;14767:18;;;14760:30;14826:26;14806:18;;;14799:54;14870:18;;1340:64:33;14546:348:35;1340:64:33;1415:216;1465:5;480:95;1534:5;1541:7;1550:5;1557:17;1568:5;1557:10;:17::i;:::-;1506:79;;;;;;15186:25:35;;;;-1:-1:-1;;;;;15247:32:35;;;15227:18;;;15220:60;15316:32;;;;15296:18;;;15289:60;15365:18;;;15358:34;15408:19;;;15401:35;15452:19;;;15445:35;;;15158:19;;1506:79:33;14899:587:35;1415:216:33;1642:32;1652:5;1659:7;1668:5;1642:9;:32::i;3315:178:2:-;3384:4;735:10:8;3438:27:2;735:10:8;3455:2:2;3459:5;3438:9;:27::i;9205:554:32:-;9310:69;9352:10;9371:5;9310:27;:69::i;:::-;9485:60;;;1059:66;9485:60;;;15693:25:35;-1:-1:-1;;;;;15754:32:35;;15734:18;;;15727:60;;;;15803:18;;;15796:34;;;9389:202:32;;9439:10;;15666:18:35;;9485:60:32;15491:345:35;9389:202:32;-1:-1:-1;;;;;9602:58:32;;:46;:58;;;-1:-1:-1;;;;;;;;;;;9602:58:32;;;;;;;;:65;;;;;;;;;:72;;-1:-1:-1;;9602:72:32;9670:4;9602:72;;;9689:63;9602:65;;:58;9689:63;;;9205:554;;;:::o;8126:245:27:-;2933:16;;-1:-1:-1;;;;;2933:16:27;2919:10;:30;;:53;;-1:-1:-1;2967:5:27;;-1:-1:-1;;;;;2967:5:27;2953:10;:19;2919:53;2911:87;;;;-1:-1:-1;;;2911:87:27;;;;;;;:::i;:::-;-1:-1:-1;;;;;8212:31:27;::::1;8204:65;;;;-1:-1:-1::0;;;8204:65:27::1;;;;;;;:::i;:::-;8279:16;:36:::0;;-1:-1:-1;;;;;;8279:36:27::1;-1:-1:-1::0;;;;;8279:36:27;::::1;::::0;;::::1;::::0;;;8330:34:::1;::::0;643:51:35;;;8330:34:27::1;::::0;631:2:35;616:18;8330:34:27::1;497:203:35::0;3943:995:32;4243:10;4224:15;:29;4220:64;;4262:22;;-1:-1:-1;;;4262:22:32;;;;;;;;;;;4220:64;4317:11;4298:15;:30;4294:65;;4337:22;;-1:-1:-1;;;4337:22:32;;;;;;;;;;;4294:65;4369:63;4411:4;4424:5;4369:27;:63::i;:::-;4478:263;4528:4;546:66;4596:36;;4634:4;4640:2;4644:5;4651:10;4663:11;4676:5;4585:97;;;;;;;;;;;;;;:::i;1818:360:26:-;2064:107;2093:5;2109:7;2125:5;2142:8;2155:1;2161;2167;2064:19;:107::i;:::-;1818:360;;;;;;;:::o;1806:30:27:-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1806:30:27;;-1:-1:-1;1806:30:27;:::o;2779:569:32:-;3084:257;3130:4;3152:2;3175:5;3206:10;3243:11;3275:5;3322:1;3325;3328;3305:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3084;:257::i;:::-;2779:569;;;;;;;;;:::o;5761:567::-;6065:256;6110:4;6132:2;6155:5;6186:10;6223:11;6255:5;6302:1;6305;6308;6285:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;6065:24;:256::i;8726:128:2:-;8810:37;8819:5;8826:7;8835:5;8842:4;8810:8;:37::i;:::-;8726:128;;;:::o;10415:476::-;-1:-1:-1;;;;;3657:18:2;;;10514:24;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;10580:36:2;;10576:309;;;10655:5;10636:16;:24;10632:130;;;10687:60;;-1:-1:-1;;;10687:60:2;;-1:-1:-1;;;;;16061:32:35;;10687:60:2;;;16043:51:35;16110:18;;;16103:34;;;16153:18;;;16146:34;;;16016:18;;10687:60:2;15841:345:35;10632:130:2;10803:57;10812:5;10819:7;10847:5;10828:16;:24;10854:5;10803:8;:57::i;:::-;10504:387;10415:476;;;:::o;5393:300::-;-1:-1:-1;;;;;5476:18:2;;5472:86;;5517:30;;-1:-1:-1;;;5517:30:2;;5544:1;5517:30;;;643:51:35;616:18;;5517:30:2;497:203:35;5472:86:2;-1:-1:-1;;;;;5571:16:2;;5567:86;;5610:32;;-1:-1:-1;;;5610:32:2;;5639:1;5610:32;;;643:51:35;616:18;;5610:32:2;497:203:35;5567:86:2;5662:24;5670:4;5676:2;5680:5;5662:7;:24::i;3845:262:15:-;3898:7;3929:4;-1:-1:-1;;;;;3938:11:15;3921:28;;:63;;;;;3970:14;3953:13;:31;3921:63;3917:184;;;-1:-1:-1;4007:22:15;;3845:262::o;3917:184::-;4067:23;4204:80;;;2079:95;4204:80;;;16677:25:35;4226:11:15;16718:18:35;;;16711:34;;;;4239:14:15;16761:18:35;;;16754:34;4255:13:15;16804:18:35;;;16797:34;4278:4:15;16847:19:35;;;16840:61;4168:7:15;;16649:19:35;;4204:80:15;;;;;;;;;;;;4194:91;;;;;;4187:98;;4113:179;;7458:208:2;-1:-1:-1;;;;;7528:21:2;;7524:91;;7572:32;;-1:-1:-1;;;7572:32:2;;7601:1;7572:32;;;643:51:35;616:18;;7572:32:2;497:203:35;7524:91:2;7624:35;7640:1;7644:7;7653:5;7624:7;:35::i;7984:206::-;-1:-1:-1;;;;;8054:21:2;;8050:89;;8098:30;;-1:-1:-1;;;8098:30:2;;8125:1;8098:30;;;643:51:35;616:18;;8098:30:2;497:203:35;8050:89:2;8148:35;8156:7;8173:1;8177:5;8148:7;:35::i;6021:126:15:-;6067:13;6099:41;:5;6126:13;6099:26;:41::i;6473:135::-;6522:13;6554:47;:8;6584:16;6554:29;:47::i;10174:233:32:-;-1:-1:-1;;;;;;;;;;;;;;;;10273:58:32;;:46;:58;;;;;;;;;;;:65;;;;;;;;;;10269:132;;;10361:29;;-1:-1:-1;;;10361:29:32;;;;;;;;;;;538:373:34;677:191;740:6;770:45;802:10;770:17;:45::i;:::-;844:9;677:36;:191::i;:::-;659:245;;886:18;;-1:-1:-1;;;886:18:34;;;;;;;;;;;10821:240:32;-1:-1:-1;;;;;10908:58:32;;:46;:58;;;-1:-1:-1;;;;;;;;;;;10908:58:32;;;;;;;;:65;;;;;;;;;:72;;-1:-1:-1;;10908:72:32;10976:4;10908:72;;;10995:59;10908:65;;:58;10995:59;;;10821:240;;:::o;1035:166:26:-;1124:4;1140:33;1156:4;1162:2;1166:6;1140:15;:33::i;:::-;-1:-1:-1;1190:4:26;1035:166;;;;;:::o;1537:132::-;-1:-1:-1;;;;;1121:14:9;;1613:7:26;1121:14:9;;;:7;:14;;;;;:16;;;;;;;;1639:23:26;759:395:9;1377:154:26;1486:38;1501:5;1508:7;1517:6;1486:14;:38::i;770:388:33:-;969:182;997:5;1025:7;1053:5;1082:8;1132:1;1135;1138;1115:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;969:6;:182::i;9701:432:2:-;-1:-1:-1;;;;;9813:19:2;;9809:89;;9855:32;;-1:-1:-1;;;9855:32:2;;9884:1;9855:32;;;643:51:35;616:18;;9855:32:2;497:203:35;9809:89:2;-1:-1:-1;;;;;9911:21:2;;9907:90;;9955:31;;-1:-1:-1;;;9955:31:2;;9983:1;9955:31;;;643:51:35;616:18;;9955:31:2;497:203:35;9907:90:2;-1:-1:-1;;;;;10006:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;10051:76;;;;10101:7;-1:-1:-1;;;;;10085:31:2;10094:5;-1:-1:-1;;;;;10085:31:2;;10110:5;10085:31;;;;2044:25:35;;2032:2;2017:18;;1898:177;10085:31:2;;;;;;;;9701:432;;;;:::o;6008:1107::-;-1:-1:-1;;;;;6097:18:2;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:2;;-1:-1:-1;6093:540:2;;-1:-1:-1;;;;;6307:15:2;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;-1:-1:-1;;;6386:50:2;;-1:-1:-1;;;;;16061:32:35;;6386:50:2;;;16043:51:35;16110:18;;;16103:34;;;16153:18;;;16146:34;;;16016:18;;6386:50:2;15841:345:35;6336:115:2;-1:-1:-1;;;;;6571:15:2;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;-1:-1:-1;;;;;6647:16:2;;6643:425;;6810:12;:21;;;;;;;6643:425;;;-1:-1:-1;;;;;7021:13:2;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;-1:-1:-1;;;;;7083:25:2;7092:4;-1:-1:-1;;;;;7083:25:2;;7102:5;7083:25;;;;2044::35;;2032:2;2017:18;;1898:177;7083:25:2;;;;;;;;6008:1107;;;:::o;3358:267:11:-;3452:13;1390:66;3481:46;;3477:142;;3550:15;3559:5;3550:8;:15::i;:::-;3543:22;;;;3477:142;3603:5;3596:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1207:164:26;1303:7;1329:35;1353:10;1329:23;:35::i;1041:429:23:-;1147:4;1167:6;-1:-1:-1;;;;;1167:18:23;;1189:1;1167:23;1163:301;;1207:17;1226:22;1254:33;1271:4;1277:9;1254:16;:33::i;:::-;-1:-1:-1;1206:81:23;;-1:-1:-1;1206:81:23;-1:-1:-1;1315:26:23;1308:3;:33;;;;;;;;:::i;:::-;;:56;;;;;1358:6;-1:-1:-1;;;;;1345:19:23;:9;-1:-1:-1;;;;;1345:19:23;;1308:56;1301:63;;;;;;1163:301;1402:51;1429:6;1437:4;1443:9;1402:26;:51::i;:::-;1395:58;;;;2078:378:11;2137:13;2162:11;2176:16;2187:4;2176:10;:16::i;:::-;2300:14;;;2311:2;2300:14;;;;;;;;;2162:30;;-1:-1:-1;2280:17:11;;2300:14;;;;;;;;;-1:-1:-1;;;2363:16:11;;;-1:-1:-1;2408:4:11;2399:14;;2392:28;;;;-1:-1:-1;2363:16:11;2078:378::o;4917:176:15:-;4994:7;5020:66;5053:20;:18;:20::i;:::-;5075:10;3501:4:16;3495:11;-1:-1:-1;;;3519:23:16;;3571:4;3562:14;;3555:39;;;;3623:4;3614:14;;3607:34;3679:4;3664:20;;;3326:374;2129:778:22;2232:17;2251:16;2269:14;2299:9;:16;2319:2;2299:22;2295:606;;2604:4;2589:20;;2583:27;2653:4;2638:20;;2632:27;2710:4;2695:20;;2689:27;2337:9;2681:36;2751:25;2762:4;2681:36;2583:27;2632;2751:10;:25::i;:::-;2744:32;;;;;;;;;;;2295:606;-1:-1:-1;;2872:16:22;;2823:1;;-1:-1:-1;2827:35:22;;2295:606;2129:778;;;;;:::o;1877:458:23:-;2020:4;2037:12;2051:19;2074:6;-1:-1:-1;;;;;2074:17:23;2148:4;2154:9;2105:60;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;2105:60:23;;;;;;;;;;;;;;-1:-1:-1;;;;;2105:60:23;-1:-1:-1;;;2105:60:23;;;2074:101;;;2105:60;2074:101;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2036:139;;;;2193:7;:42;;;;;2233:2;2216:6;:13;:19;;2193:42;:134;;;;-1:-1:-1;2251:29:23;;-1:-1:-1;;;2292:34:23;2251:29;;;;;;;;;;;;:::i;:::-;:76;2193:134;2185:143;1877:458;-1:-1:-1;;;;;;1877:458:23:o;2528:245:11:-;2589:7;2661:4;2625:40;;2688:2;2679:11;;2675:69;;;2713:20;;-1:-1:-1;;;2713:20:11;;;;;;;;;;;5203:1551:22;5329:17;;;6283:66;6270:79;;6266:164;;;-1:-1:-1;6381:1:22;;-1:-1:-1;6385:30:22;;-1:-1:-1;6417:1:22;6365:54;;6266:164;6541:24;;;6524:14;6541:24;;;;;;;;;18060:25:35;;;18133:4;18121:17;;18101:18;;;18094:45;;;;18155:18;;;18148:34;;;18198:18;;;18191:34;;;6541:24:22;;18032:19:35;;6541:24:22;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6541:24:22;;-1:-1:-1;;6541:24:22;;;-1:-1:-1;;;;;;;6579:20:22;;6575:113;;-1:-1:-1;6631:1:22;;-1:-1:-1;6635:29:22;;-1:-1:-1;6631:1:22;;-1:-1:-1;6615:62:22;;6575:113;6706:6;-1:-1:-1;6714:20:22;;-1:-1:-1;6714:20:22;;-1:-1:-1;5203:1551:22;;;;;;;;;:::o;14:286:35:-;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:35;;209:43;;199:71;;266:1;263;256:12;705:289;747:3;785:5;779:12;812:6;807:3;800:19;868:6;861:4;854:5;850:16;843:4;838:3;834:14;828:47;920:1;913:4;904:6;899:3;895:16;891:27;884:38;983:4;976:2;972:7;967:2;959:6;955:15;951:29;946:3;942:39;938:50;931:57;;;705:289;;;;:::o;999:220::-;1148:2;1137:9;1130:21;1111:4;1168:45;1209:2;1198:9;1194:18;1186:6;1168:45;:::i;1224:173::-;1292:20;;-1:-1:-1;;;;;1341:31:35;;1331:42;;1321:70;;1387:1;1384;1377:12;1321:70;1224:173;;;:::o;1402:300::-;1470:6;1478;1531:2;1519:9;1510:7;1506:23;1502:32;1499:52;;;1547:1;1544;1537:12;1499:52;1570:29;1589:9;1570:29;:::i;:::-;1560:39;1668:2;1653:18;;;;1640:32;;-1:-1:-1;;;1402:300:35:o;1707:186::-;1766:6;1819:2;1807:9;1798:7;1794:23;1790:32;1787:52;;;1835:1;1832;1825:12;1787:52;1858:29;1877:9;1858:29;:::i;2080:374::-;2157:6;2165;2173;2226:2;2214:9;2205:7;2201:23;2197:32;2194:52;;;2242:1;2239;2232:12;2194:52;2265:29;2284:9;2265:29;:::i;:::-;2255:39;;2313:38;2347:2;2336:9;2332:18;2313:38;:::i;:::-;2080:374;;2303:48;;-1:-1:-1;;;2420:2:35;2405:18;;;;2392:32;;2080:374::o;2830:226::-;2889:6;2942:2;2930:9;2921:7;2917:23;2913:32;2910:52;;;2958:1;2955;2948:12;2910:52;-1:-1:-1;3003:23:35;;2830:226;-1:-1:-1;2830:226:35:o;3061:156::-;3127:20;;3187:4;3176:16;;3166:27;;3156:55;;3207:1;3204;3197:12;3222:612;3315:6;3323;3331;3339;3347;3400:3;3388:9;3379:7;3375:23;3371:33;3368:53;;;3417:1;3414;3407:12;3368:53;3440:29;3459:9;3440:29;:::i;:::-;3430:39;-1:-1:-1;3538:2:35;3523:18;;3510:32;;-1:-1:-1;3585:36:35;3617:2;3602:18;;3585:36;:::i;:::-;3222:612;;;;-1:-1:-1;3575:46:35;;3694:2;3679:18;;3666:32;;-1:-1:-1;3797:3:35;3782:19;3769:33;;3222:612;-1:-1:-1;;3222:612:35:o;3839:1238::-;4245:3;4240;4236:13;4228:6;4224:26;4213:9;4206:45;4287:3;4282:2;4271:9;4267:18;4260:31;4187:4;4314:46;4355:3;4344:9;4340:19;4332:6;4314:46;:::i;:::-;4408:9;4400:6;4396:22;4391:2;4380:9;4376:18;4369:50;4442:33;4468:6;4460;4442:33;:::i;:::-;4506:2;4491:18;;4484:34;;;-1:-1:-1;;;;;4555:32:35;;4549:3;4534:19;;4527:61;4575:3;4604:19;;4597:35;;;4669:22;;;4663:3;4648:19;;4641:51;4741:13;;4763:22;;;4813:2;4839:15;;;;-1:-1:-1;4801:15:35;;;;-1:-1:-1;4882:169:35;4896:6;4893:1;4890:13;4882:169;;;4957:13;;4945:26;;5000:2;5026:15;;;;4991:12;;;;4918:1;4911:9;4882:169;;;-1:-1:-1;5068:3:35;;3839:1238;-1:-1:-1;;;;;;;;;;;3839:1238:35:o;5082:127::-;5143:10;5138:3;5134:20;5131:1;5124:31;5174:4;5171:1;5164:15;5198:4;5195:1;5188:15;5214:725;5256:5;5309:3;5302:4;5294:6;5290:17;5286:27;5276:55;;5327:1;5324;5317:12;5276:55;5367:6;5354:20;5397:18;5389:6;5386:30;5383:56;;;5419:18;;:::i;:::-;5468:2;5462:9;5560:2;5522:17;;-1:-1:-1;;5518:31:35;;;5551:2;5514:40;5510:54;5498:67;;5595:18;5580:34;;5616:22;;;5577:62;5574:88;;;5642:18;;:::i;:::-;5678:2;5671:22;5702;;;5743:19;;;5764:4;5739:30;5736:39;-1:-1:-1;5733:59:35;;;5788:1;5785;5778:12;5733:59;5852:6;5845:4;5837:6;5833:17;5826:4;5818:6;5814:17;5801:58;5907:1;5879:19;;;5900:4;5875:30;5868:41;;;;5883:6;5214:725;-1:-1:-1;;;5214:725:35:o;5944:946::-;6066:6;6074;6082;6090;6098;6106;6114;6167:3;6155:9;6146:7;6142:23;6138:33;6135:53;;;6184:1;6181;6174:12;6135:53;6207:29;6226:9;6207:29;:::i;:::-;6197:39;;6255:38;6289:2;6278:9;6274:18;6255:38;:::i;:::-;6245:48;-1:-1:-1;6362:2:35;6347:18;;6334:32;;-1:-1:-1;6463:2:35;6448:18;;6435:32;;-1:-1:-1;6566:3:35;6551:19;;6538:33;;-1:-1:-1;6670:3:35;6655:19;;6642:33;;-1:-1:-1;6752:3:35;6737:19;;6724:33;6780:18;6769:30;;6766:50;;;6812:1;6809;6802:12;6766:50;6835:49;6876:7;6867:6;6856:9;6852:22;6835:49;:::i;:::-;6825:59;;;5944:946;;;;;;;;;;:::o;6895:704::-;6999:6;7007;7015;7023;7031;7084:3;7072:9;7063:7;7059:23;7055:33;7052:53;;;7101:1;7098;7091:12;7052:53;7124:29;7143:9;7124:29;:::i;:::-;7114:39;;7172:38;7206:2;7195:9;7191:18;7172:38;:::i;:::-;7162:48;-1:-1:-1;7279:2:35;7264:18;;7251:32;;-1:-1:-1;7380:2:35;7365:18;;7352:32;;-1:-1:-1;7461:3:35;7446:19;;7433:33;7489:18;7478:30;;7475:50;;;7521:1;7518;7511:12;7475:50;7544:49;7585:7;7576:6;7565:9;7561:22;7544:49;:::i;:::-;7534:59;;;6895:704;;;;;;;;:::o;7604:508::-;7690:6;7698;7706;7759:2;7747:9;7738:7;7734:23;7730:32;7727:52;;;7775:1;7772;7765:12;7727:52;7798:29;7817:9;7798:29;:::i;:::-;7788:39;-1:-1:-1;7896:2:35;7881:18;;7868:32;;-1:-1:-1;7975:2:35;7960:18;;7947:32;8002:18;7991:30;;7988:50;;;8034:1;8031;8024:12;7988:50;8057:49;8098:7;8089:6;8078:9;8074:22;8057:49;:::i;:::-;8047:59;;;7604:508;;;;;:::o;8117:808::-;8228:6;8236;8244;8252;8260;8268;8276;8329:3;8317:9;8308:7;8304:23;8300:33;8297:53;;;8346:1;8343;8336:12;8297:53;8369:29;8388:9;8369:29;:::i;:::-;8359:39;;8417:38;8451:2;8440:9;8436:18;8417:38;:::i;:::-;8407:48;-1:-1:-1;8524:2:35;8509:18;;8496:32;;-1:-1:-1;8625:2:35;8610:18;;8597:32;;-1:-1:-1;8674:37:35;8706:3;8691:19;;8674:37;:::i;:::-;8117:808;;;;-1:-1:-1;8117:808:35;;;;8664:47;8784:3;8769:19;;8756:33;;-1:-1:-1;8888:3:35;8873:19;;;8860:33;;8117:808;-1:-1:-1;;8117:808:35:o;8930:260::-;8998:6;9006;9059:2;9047:9;9038:7;9034:23;9030:32;9027:52;;;9075:1;9072;9065:12;9027:52;9098:29;9117:9;9098:29;:::i;:::-;9088:39;;9146:38;9180:2;9169:9;9165:18;9146:38;:::i;:::-;9136:48;;8930:260;;;;;:::o;9195:1050::-;9324:6;9332;9340;9348;9356;9364;9372;9380;9388;9441:3;9429:9;9420:7;9416:23;9412:33;9409:53;;;9458:1;9455;9448:12;9409:53;9481:29;9500:9;9481:29;:::i;:::-;9471:39;;9529:38;9563:2;9552:9;9548:18;9529:38;:::i;:::-;9519:48;-1:-1:-1;9636:2:35;9621:18;;9608:32;;-1:-1:-1;9737:2:35;9722:18;;9709:32;;-1:-1:-1;9840:3:35;9825:19;;9812:33;;-1:-1:-1;9944:3:35;9929:19;;9916:33;;-1:-1:-1;9994:37:35;10026:3;10011:19;;9994:37;:::i;:::-;9195:1050;;;;-1:-1:-1;9195:1050:35;;;;;;;;-1:-1:-1;9984:47:35;;10104:3;10089:19;;10076:33;;-1:-1:-1;10208:3:35;10193:19;10180:33;;9195:1050;-1:-1:-1;9195:1050:35:o;10555:380::-;10634:1;10630:12;;;;10677;;;10698:61;;10752:4;10744:6;10740:17;10730:27;;10698:61;10805:2;10797:6;10794:14;10774:18;10771:38;10768:161;;10851:10;10846:3;10842:20;10839:1;10832:31;10886:4;10883:1;10876:15;10914:4;10911:1;10904:15;10768:161;;10555:380;;;:::o;10940:345::-;11142:2;11124:21;;;11181:2;11161:18;;;11154:30;-1:-1:-1;;;11215:2:35;11200:18;;11193:51;11276:2;11261:18;;10940:345::o;11290:::-;11492:2;11474:21;;;11531:2;11511:18;;;11504:30;-1:-1:-1;;;11565:2:35;11550:18;;11543:51;11626:2;11611:18;;11290:345::o;11989:127::-;12050:10;12045:3;12041:20;12038:1;12031:31;12081:4;12078:1;12071:15;12105:4;12102:1;12095:15;12121:416;12323:2;12305:21;;;12362:2;12342:18;;;12335:30;12401:34;12396:2;12381:18;;12374:62;-1:-1:-1;;;12467:2:35;12452:18;;12445:50;12527:3;12512:19;;12121:416::o;12542:338::-;12723:19;;;12767:2;12758:12;;12751:28;;;;12835:3;12813:16;-1:-1:-1;;;;;;12809:36:35;12804:2;12795:12;;12788:58;12871:2;12862:12;;12542:338::o;13531:659::-;13846:25;;;-1:-1:-1;;;;;13907:32:35;;;13902:2;13887:18;;13880:60;13976:32;;;;13971:2;13956:18;;13949:60;14040:2;14025:18;;14018:34;;;;14083:3;14068:19;;14061:35;13927:3;14112:19;;14105:35;;;;14171:3;14156:19;;14149:35;13833:3;13818:19;;13531:659::o;16191:222::-;16256:9;;;16277:10;;;16274:133;;;16329:10;16324:3;16320:20;16317:1;16310:31;16364:4;16361:1;16354:15;16392:4;16389:1;16382:15;16912:127;16973:10;16968:3;16964:20;16961:1;16954:31;17004:4;17001:1;16994:15;17028:4;17025:1;17018:15;17044:289;17219:6;17208:9;17201:25;17262:2;17257;17246:9;17242:18;17235:30;17182:4;17282:45;17323:2;17312:9;17308:18;17300:6;17282:45;:::i;:::-;17274:53;17044:289;-1:-1:-1;;;;17044:289:35:o;17338:301::-;17467:3;17505:6;17499:13;17551:6;17544:4;17536:6;17532:17;17527:3;17521:37;17613:1;17577:16;;17602:13;;;-1:-1:-1;17577:16:35;17338:301;-1:-1:-1;17338:301:35:o;17644:184::-;17714:6;17767:2;17755:9;17746:7;17742:23;17738:32;17735:52;;;17783:1;17780;17773:12;17735:52;-1:-1:-1;17806:16:35;;17644:184;-1:-1:-1;17644:184:35:o","linkReferences":{},"cborAuxdata":{},"immutableReferences":{"3076":[{"start":5367,"length":32}],"3078":[{"start":5325,"length":32}],"3080":[{"start":5283,"length":32}],"3082":[{"start":5448,"length":32}],"3084":[{"start":5488,"length":32}],"3087":[{"start":5679,"length":32}],"3090":[{"start":5724,"length":32}],"7624":[{"start":1261,"length":32},{"start":1597,"length":32},{"start":2575,"length":32},{"start":4005,"length":32}],"7627":[{"start":679,"length":32},{"start":1337,"length":32}]},"transformations":[{"id":"7627","type":"replace","offset":679,"reason":"immutable"},{"id":"7624","type":"replace","offset":1261,"reason":"immutable"},{"id":"7627","type":"replace","offset":1337,"reason":"immutable"},{"id":"7624","type":"replace","offset":1597,"reason":"immutable"},{"id":"7624","type":"replace","offset":2575,"reason":"immutable"},{"id":"7624","type":"replace","offset":4005,"reason":"immutable"},{"id":"3080","type":"replace","offset":5283,"reason":"immutable"},{"id":"3078","type":"replace","offset":5325,"reason":"immutable"},{"id":"3076","type":"replace","offset":5367,"reason":"immutable"},{"id":"3082","type":"replace","offset":5448,"reason":"immutable"},{"id":"3084","type":"replace","offset":5488,"reason":"immutable"},{"id":"3087","type":"replace","offset":5679,"reason":"immutable"},{"id":"3090","type":"replace","offset":5724,"reason":"immutable"}],"transformationValues":{"immutables":{"3076":"0x51676f57c399677dc87e7d37eeb040d6c9bc82a6c715695d74e3c5d3a69550b8","3078":"0x00000000000000000000000000000000000000000000000000000000000000fc","3080":"0x000000000000000000000000ba026e978eb1b11d72adabf33b7cf6f3e321ca83","3082":"0x3a6d82ffbc8300189d057fcb96ec22bff6bdfec7adb9505c78a3794985559756","3084":"0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6","3087":"0x5374616b6564204672617820555344000000000000000000000000000000000f","3090":"0x3100000000000000000000000000000000000000000000000000000000000001","7624":"0x0000000000000000000000004200000000000000000000000000000000000010","7627":"0x000000000000000000000000cf62f905562626cfcdd2261162a51fd02fc9c5b6"}}},"deployment":{"transactionHash":"0xa9215f21cef554fcf883071e4f24c1098aa404ae27e61fb221631dd5e1fd4fbf","blockNumber":"30803945","transactionIndex":"1","deployer":"0xb0E1650A9760e0f383174af042091fc544b8356f"},"sources":{"node_modules/@openzeppelin/contracts-5.2.0/interfaces/IERC5267.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)\n\npragma solidity ^0.8.20;\n\ninterface IERC5267 {\n    /**\n     * @dev MAY be emitted to signal that the domain could have changed.\n     */\n    event EIP712DomainChanged();\n\n    /**\n     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712\n     * signature.\n     */\n    function eip712Domain()\n        external\n        view\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        );\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)\n\npragma solidity ^0.8.20;\n\nimport {ERC20} from \"../ERC20.sol\";\nimport {Context} from \"../../../utils/Context.sol\";\n\n/**\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\n * tokens and those that they have an allowance for, in a way that can be\n * recognized off-chain (via event analysis).\n */\nabstract contract ERC20Burnable is Context, ERC20 {\n    /**\n     * @dev Destroys a `value` amount of tokens from the caller.\n     *\n     * See {ERC20-_burn}.\n     */\n    function burn(uint256 value) public virtual {\n        _burn(_msgSender(), value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, deducting from\n     * the caller's allowance.\n     *\n     * See {ERC20-_burn} and {ERC20-allowance}.\n     *\n     * Requirements:\n     *\n     * - the caller must have allowance for ``accounts``'s tokens of at least\n     * `value`.\n     */\n    function burnFrom(address account, uint256 value) public virtual {\n        _spendAllowance(account, _msgSender(), value);\n        _burn(account, value);\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/ERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20Permit} from \"./IERC20Permit.sol\";\nimport {ERC20} from \"../ERC20.sol\";\nimport {ECDSA} from \"../../../utils/cryptography/ECDSA.sol\";\nimport {EIP712} from \"../../../utils/cryptography/EIP712.sol\";\nimport {Nonces} from \"../../../utils/Nonces.sol\";\n\n/**\n * @dev Implementation of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\nabstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {\n    bytes32 private constant PERMIT_TYPEHASH =\n        keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    /**\n     * @dev Permit deadline has expired.\n     */\n    error ERC2612ExpiredSignature(uint256 deadline);\n\n    /**\n     * @dev Mismatched signature.\n     */\n    error ERC2612InvalidSigner(address signer, address owner);\n\n    /**\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\"1\"`.\n     *\n     * It's a good idea to use the same `name` that is defined as the ERC-20 token name.\n     */\n    constructor(string memory name) EIP712(name, \"1\") {}\n\n    /**\n     * @inheritdoc IERC20Permit\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        if (block.timestamp > deadline) {\n            revert ERC2612ExpiredSignature(deadline);\n        }\n\n        bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\n\n        bytes32 hash = _hashTypedDataV4(structHash);\n\n        address signer = ECDSA.recover(hash, v, r, s);\n        if (signer != owner) {\n            revert ERC2612InvalidSigner(signer, owner);\n        }\n\n        _approve(owner, spender, value);\n    }\n\n    /**\n     * @inheritdoc IERC20Permit\n     */\n    function nonces(address owner) public view virtual override(IERC20Permit, Nonces) returns (uint256) {\n        return super.nonces(owner);\n    }\n\n    /**\n     * @inheritdoc IERC20Permit\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Nonces.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides tracking nonces for addresses. Nonces will only increment.\n */\nabstract contract Nonces {\n    /**\n     * @dev The nonce used for an `account` is not the expected current nonce.\n     */\n    error InvalidAccountNonce(address account, uint256 currentNonce);\n\n    mapping(address account => uint256) private _nonces;\n\n    /**\n     * @dev Returns the next unused nonce for an address.\n     */\n    function nonces(address owner) public view virtual returns (uint256) {\n        return _nonces[owner];\n    }\n\n    /**\n     * @dev Consumes a nonce.\n     *\n     * Returns the current value and increments nonce.\n     */\n    function _useNonce(address owner) internal virtual returns (uint256) {\n        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be\n        // decremented or reset. This guarantees that the nonce never overflows.\n        unchecked {\n            // It is important to do x++ and not ++x here.\n            return _nonces[owner]++;\n        }\n    }\n\n    /**\n     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.\n     */\n    function _useCheckedNonce(address owner, uint256 nonce) internal virtual {\n        uint256 current = _useNonce(owner);\n        if (nonce != current) {\n            revert InvalidAccountNonce(owner, current);\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/ShortStrings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ShortStrings.sol)\n\npragma solidity ^0.8.20;\n\nimport {StorageSlot} from \"./StorageSlot.sol\";\n\n// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |\n// | length  | 0x                                                              BB |\ntype ShortString is bytes32;\n\n/**\n * @dev This library provides functions to convert short memory strings\n * into a `ShortString` type that can be used as an immutable variable.\n *\n * Strings of arbitrary length can be optimized using this library if\n * they are short enough (up to 31 bytes) by packing them with their\n * length (1 byte) in a single EVM word (32 bytes). Additionally, a\n * fallback mechanism can be used for every other case.\n *\n * Usage example:\n *\n * ```solidity\n * contract Named {\n *     using ShortStrings for *;\n *\n *     ShortString private immutable _name;\n *     string private _nameFallback;\n *\n *     constructor(string memory contractName) {\n *         _name = contractName.toShortStringWithFallback(_nameFallback);\n *     }\n *\n *     function name() external view returns (string memory) {\n *         return _name.toStringWithFallback(_nameFallback);\n *     }\n * }\n * ```\n */\nlibrary ShortStrings {\n    // Used as an identifier for strings longer than 31 bytes.\n    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;\n\n    error StringTooLong(string str);\n    error InvalidShortString();\n\n    /**\n     * @dev Encode a string of at most 31 chars into a `ShortString`.\n     *\n     * This will trigger a `StringTooLong` error is the input string is too long.\n     */\n    function toShortString(string memory str) internal pure returns (ShortString) {\n        bytes memory bstr = bytes(str);\n        if (bstr.length > 31) {\n            revert StringTooLong(str);\n        }\n        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));\n    }\n\n    /**\n     * @dev Decode a `ShortString` back to a \"normal\" string.\n     */\n    function toString(ShortString sstr) internal pure returns (string memory) {\n        uint256 len = byteLength(sstr);\n        // using `new string(len)` would work locally but is not memory safe.\n        string memory str = new string(32);\n        assembly (\"memory-safe\") {\n            mstore(str, len)\n            mstore(add(str, 0x20), sstr)\n        }\n        return str;\n    }\n\n    /**\n     * @dev Return the length of a `ShortString`.\n     */\n    function byteLength(ShortString sstr) internal pure returns (uint256) {\n        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;\n        if (result > 31) {\n            revert InvalidShortString();\n        }\n        return result;\n    }\n\n    /**\n     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.\n     */\n    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {\n        if (bytes(value).length < 32) {\n            return toShortString(value);\n        } else {\n            StorageSlot.getStringSlot(store).value = value;\n            return ShortString.wrap(FALLBACK_SENTINEL);\n        }\n    }\n\n    /**\n     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.\n     */\n    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return toString(value);\n        } else {\n            return store;\n        }\n    }\n\n    /**\n     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using\n     * {setWithFallback}.\n     *\n     * WARNING: This will return the \"byte length\" of the string. This may not reflect the actual length in terms of\n     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.\n     */\n    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return byteLength(value);\n        } else {\n            return bytes(store).length;\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.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 ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\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 *\n * TIP: Consider using this library along with {SlotDerivation}.\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 Int256Slot {\n        int256 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        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\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        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\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        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guaratees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(buffer, add(0x20, offset)))\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/EIP712.sol)\n\npragma solidity ^0.8.20;\n\nimport {MessageHashUtils} from \"./MessageHashUtils.sol\";\nimport {ShortStrings, ShortString} from \"../ShortStrings.sol\";\nimport {IERC5267} from \"../../interfaces/IERC5267.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose\n * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract\n * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to\n * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain\n * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the\n * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.\n *\n * @custom:oz-upgrades-unsafe-allow state-variable-immutable\n */\nabstract contract EIP712 is IERC5267 {\n    using ShortStrings for *;\n\n    bytes32 private constant TYPE_HASH =\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n    // invalidate the cached domain separator if the chain id changes.\n    bytes32 private immutable _cachedDomainSeparator;\n    uint256 private immutable _cachedChainId;\n    address private immutable _cachedThis;\n\n    bytes32 private immutable _hashedName;\n    bytes32 private immutable _hashedVersion;\n\n    ShortString private immutable _name;\n    ShortString private immutable _version;\n    string private _nameFallback;\n    string private _versionFallback;\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        _name = name.toShortStringWithFallback(_nameFallback);\n        _version = version.toShortStringWithFallback(_versionFallback);\n        _hashedName = keccak256(bytes(name));\n        _hashedVersion = keccak256(bytes(version));\n\n        _cachedChainId = block.chainid;\n        _cachedDomainSeparator = _buildDomainSeparator();\n        _cachedThis = address(this);\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {\n            return _cachedDomainSeparator;\n        } else {\n            return _buildDomainSeparator();\n        }\n    }\n\n    function _buildDomainSeparator() private view returns (bytes32) {\n        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n\n    /**\n     * @dev See {IERC-5267}.\n     */\n    function eip712Domain()\n        public\n        view\n        virtual\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        )\n    {\n        return (\n            hex\"0f\", // 01111\n            _EIP712Name(),\n            _EIP712Version(),\n            block.chainid,\n            address(this),\n            bytes32(0),\n            new uint256[](0)\n        );\n    }\n\n    /**\n     * @dev The name parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _name which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Name() internal view returns (string memory) {\n        return _name.toStringWithFallback(_nameFallback);\n    }\n\n    /**\n     * @dev The version parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _version which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Version() internal view returns (string memory) {\n        return _version.toStringWithFallback(_versionFallback);\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.20;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing a bytes32 `messageHash` with\n     * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n     * keccak256, although any bytes32 value can be safely used because the final digest will\n     * be re-hashed.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing an arbitrary `message` with\n     * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n        return\n            keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x00` (data with intended validator).\n     *\n     * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n     * `validator` address. Then hashing the result.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\n     *\n     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n     * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            mstore(ptr, hex\"19_01\")\n            mstore(add(ptr, 0x02), domainSeparator)\n            mstore(add(ptr, 0x22), structHash)\n            digest := keccak256(ptr, 0x42)\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\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[ERC 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"},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2²⁵⁶ + prod0.\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= prod1) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\n        for (uint256 i = 0; i < byteArray.length; ++i) {\n            if (byteArray[i] != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 exp;\n        unchecked {\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\n            value >>= exp;\n            result += exp;\n\n            result += SafeCast.toUint(value > 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 isGt;\n        unchecked {\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= isGt * 128;\n            result += isGt * 16;\n\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= isGt * 64;\n            result += isGt * 8;\n\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= isGt * 32;\n            result += isGt * 4;\n\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= isGt * 16;\n            result += isGt * 2;\n\n            result += SafeCast.toUint(value > (1 << 8) - 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev An uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.3.0/interfaces/IERC1271.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/IERC1271.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-1271 standard signature validation method for\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\n */\ninterface IERC1271 {\n    /**\n     * @dev Should return whether the signature provided is valid for the provided data\n     * @param hash      Hash of the data to be signed\n     * @param signature Signature byte array associated with `hash`\n     */\n    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);\n}\n"},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/SignatureChecker.sol)\n\npragma solidity ^0.8.20;\n\nimport {ECDSA} from \"./ECDSA.sol\";\nimport {IERC1271} from \"../../interfaces/IERC1271.sol\";\n\n/**\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA\n * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like\n * Argent and Safe Wallet (previously Gnosis Safe).\n */\nlibrary SignatureChecker {\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the\n     * signature is validated against that smart contract using ERC-1271, otherwise it's validated using `ECDSA.recover`.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\n        if (signer.code.length == 0) {\n            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);\n            return err == ECDSA.RecoverError.NoError && recovered == signer;\n        } else {\n            return isValidERC1271SignatureNow(signer, hash, signature);\n        }\n    }\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\n     * against the signer smart contract using ERC-1271.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidERC1271SignatureNow(\n        address signer,\n        bytes32 hash,\n        bytes memory signature\n    ) internal view returns (bool) {\n        (bool success, bytes memory result) = signer.staticcall(\n            abi.encodeCall(IERC1271.isValidSignature, (hash, signature))\n        );\n        return (success &&\n            result.length >= 32 &&\n            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));\n    }\n}\n"},"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.8.0;\n\n// ====================================================================\n// |     ______                   _______                             |\n// |    / _____________ __  __   / ____(_____  ____ _____  ________   |\n// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \\/ __ `/ __ \\/ ___/ _ \\  |\n// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |\n// | /_/   /_/   \\__,_/_/|_|  /_/   /_/_/ /_/\\__,_/_/ /_/\\___/\\___/   |\n// |                                                                  |\n// ====================================================================\n// ============================= FrxUSD ===============================\n// ====================================================================\n// Frax Finance: https://github.com/FraxFinance\n// Tested for 18-decimal underlying assets only\n\nimport { SfrxUSD2 } from \"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol\";\n\ncontract SfrxUSD is SfrxUSD2 {\n    constructor(address _bridge, address _remoteToken) SfrxUSD2(_bridge, _remoteToken) {}\n}\n"},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { ERC20PermitPermissionedOptiMintable } from \"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol\";\n\ncontract SfrxUSD is ERC20PermitPermissionedOptiMintable {\n    function version() public pure virtual override returns (string memory) {\n        return \"1.0.0\";\n    }\n\n    /// @param _creator_address The contract creator\n    /// @param _timelock_address The timelock\n    /// @param _bridge Address of the L2 standard bridge\n    /// @param _remoteToken Address of the corresponding L1 token\n    constructor(\n        address _creator_address,\n        address _timelock_address,\n        address _bridge,\n        address _remoteToken\n    )\n        ERC20PermitPermissionedOptiMintable(\n            _creator_address,\n            _timelock_address,\n            _bridge,\n            _remoteToken,\n            \"Staked Frax USD\",\n            \"sfrxUSD\"\n        )\n    {}\n}\n"},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol":{"content":"//SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.0;\n\nimport { ERC20Permit, ERC20, EIP712, Nonces } from \"@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol\";\nimport { SfrxUSD } from \"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol\";\nimport { PermitModule } from \"src/contracts/shared/core/modules/PermitModule.sol\";\nimport { EIP3009Module, SignatureModule } from \"src/contracts/shared/core/modules/EIP3009Module.sol\";\n\n/// @title SfrxUSD v2.0.0\n/// @notice Frax USD Stablecoin by Frax Finance\n/// @dev v2.0.0 adds ERC-1271 and EIP-3009 support\ncontract SfrxUSD2 is SfrxUSD, EIP3009Module, PermitModule {\n    function version() public pure override returns (string memory) {\n        return \"2.0.0\";\n    }\n\n    constructor(address _bridge, address _remoteToken) SfrxUSD(address(1), address(1), _bridge, _remoteToken) {}\n\n    /*//////////////////////////////////////////////////////////////\n                        Module Overrides\n    //////////////////////////////////////////////////////////////*/\n\n    function __transfer(address from, address to, uint256 amount) internal override returns (bool) {\n        ERC20._transfer(from, to, amount);\n        return true;\n    }\n\n    function __hashTypedDataV4(bytes32 structHash) internal view override(SignatureModule) returns (bytes32) {\n        return EIP712._hashTypedDataV4(structHash);\n    }\n\n    function __approve(address owner, address spender, uint256 amount) internal override(PermitModule) {\n        ERC20._approve(owner, spender, amount);\n    }\n\n    function __useNonce(address owner) internal override(PermitModule) returns (uint256) {\n        return Nonces._useNonce(owner);\n    }\n\n    function __domainSeparatorV4() internal view override(PermitModule) returns (bytes32) {\n        return EIP712._domainSeparatorV4();\n    }\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public override(ERC20Permit, PermitModule) {\n        return\n            PermitModule.permit({ owner: owner, spender: spender, value: value, deadline: deadline, v: v, r: r, s: s });\n    }\n}\n"},"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IERC20 } from \"@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol\";\nimport { ERC20Permit, ERC20 } from \"@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol\";\nimport { ERC20Burnable } from \"@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol\";\nimport { IERC165 } from \"@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol\";\nimport { ILegacyMintableERC20 } from \"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol\";\nimport { IOptimismMintableERC20 } from \"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol\";\nimport { ISemver } from \"src/contracts/fraxtal/shared/interfaces/ISemver.sol\";\nimport { OwnedV2 } from \"src/contracts/fraxtal/shared/OwnedV2.sol\";\n\n/// @title Parent contract for frxETH.sol, but also CrossChainCanonicalV2\n/**\n * @notice Combines Openzeppelin's ERC20Permit and ERC20Burnable with Synthetix's Owned and Optimism's OptimismMintableERC20.\n *     Also includes a list of authorized minters\n */\n/// @dev ERC20PermitPermissionedOptiMintable adheres to EIP-712/EIP-2612 and can use permits\ncontract ERC20PermitPermissionedOptiMintable is\n    ERC20Permit,\n    ERC20Burnable,\n    OwnedV2,\n    IOptimismMintableERC20,\n    ILegacyMintableERC20,\n    ISemver\n{\n    /// @custom:semver 1.0.0\n    function version() public pure virtual returns (string memory) {\n        return \"1.0.0\";\n    }\n\n    /// @notice The timelock address\n    address public timelock_address;\n\n    /// @notice Address of the L2 StandardBridge on this network.\n    address public immutable BRIDGE;\n\n    /// @notice Address of the corresponding version of this token on the remote chain.\n    address public immutable REMOTE_TOKEN;\n\n    /// @notice Array of the non-bridge minters\n    address[] public minters_array;\n\n    /// @notice Mapping of the non-bridge minters\n    /// @dev Mapping is used for faster verification\n    mapping(address => bool) public minters;\n\n    /* ========== CONSTRUCTOR ========== */\n\n    /// @custom:semver 1.0.0\n    /// @param _creator_address The contract creator\n    /// @param _timelock_address The timelock\n    /// @param _bridge Address of the L2 standard bridge\n    /// @param _remoteToken Address of the corresponding L1 token\n    /// @param _name ERC20 name\n    /// @param _symbol ERC20 symbol\n    constructor(\n        address _creator_address,\n        address _timelock_address,\n        address _bridge,\n        address _remoteToken,\n        string memory _name,\n        string memory _symbol\n    ) ERC20(_name, _symbol) ERC20Permit(_name) OwnedV2(_creator_address) {\n        REMOTE_TOKEN = _remoteToken;\n        BRIDGE = _bridge;\n        timelock_address = _timelock_address;\n    }\n\n    /* ========== MODIFIERS ========== */\n\n    /// @notice A modifier that only allows the contract owner or the timelock to call\n    modifier onlyByOwnGov() {\n        require(msg.sender == timelock_address || msg.sender == owner, \"Not owner or timelock\");\n        _;\n    }\n\n    /// @notice A modifier that only allows a non-bridge minter to call\n    modifier onlyMinters() {\n        require(minters[msg.sender] == true, \"Only minters\");\n        _;\n    }\n\n    /// @notice A modifier that only allows the bridge to call\n    modifier onlyBridge() {\n        require(msg.sender == BRIDGE, \"OptimismMintableERC20: only bridge can mint and burn\");\n        _;\n    }\n\n    /* ========== LEGACY VIEWS ========== */\n\n    /// @custom:legacy\n    /// @notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.\n    /// @return address The L1 remote token address\n    function l1Token() public view returns (address) {\n        return REMOTE_TOKEN;\n    }\n\n    /// @custom:legacy\n    /// @notice Legacy getter for the bridge. Use BRIDGE going forward.\n    /// @return address The bridge address\n    function l2Bridge() public view returns (address) {\n        return BRIDGE;\n    }\n\n    /// @custom:legacy\n    /// @notice Legacy getter for REMOTE_TOKEN\n    /// @return address The L1 remote token address\n    function remoteToken() public view returns (address) {\n        return REMOTE_TOKEN;\n    }\n\n    /// @custom:legacy\n    /// @notice Legacy getter for BRIDGE\n    /// @return address The bridge address\n    function bridge() public view returns (address) {\n        return BRIDGE;\n    }\n\n    /// @notice ERC165 interface check function.\n    /// @param _interfaceId Interface ID to check.\n    /// @return Whether or not the interface is supported by this contract.\n    function supportsInterface(bytes4 _interfaceId) external pure virtual returns (bool) {\n        bytes4 iface1 = type(IERC165).interfaceId;\n        // Interface corresponding to the legacy L2StandardERC20.\n        bytes4 iface2 = type(ILegacyMintableERC20).interfaceId;\n        // Interface corresponding to the updated OptimismMintableERC20 (this contract).\n        bytes4 iface3 = type(IOptimismMintableERC20).interfaceId;\n        return _interfaceId == iface1 || _interfaceId == iface2 || _interfaceId == iface3;\n    }\n\n    /* ========== RESTRICTED FUNCTIONS [BRIDGE] ========== */\n\n    /// @notice Allows the StandardBridge on this network to mint tokens.\n    /// @param _to     Address to mint tokens to.\n    /// @param _amount Amount of tokens to mint.\n    function mint(\n        address _to,\n        uint256 _amount\n    ) external virtual override(IOptimismMintableERC20, ILegacyMintableERC20) onlyBridge {\n        _mint(_to, _amount);\n        emit Mint(_to, _amount);\n    }\n\n    /// @notice Allows the StandardBridge on this network to burn tokens.\n    /// @param _from   Address to burn tokens from.\n    /// @param _amount Amount of tokens to burn.\n    function burn(\n        address _from,\n        uint256 _amount\n    ) external virtual override(IOptimismMintableERC20, ILegacyMintableERC20) onlyBridge {\n        _burn(_from, _amount);\n        emit Burn(_from, _amount);\n    }\n\n    /* ========== RESTRICTED FUNCTIONS [NON-BRIDGE MINTERS] ========== */\n\n    /// @notice Used by non-bridge minters to burn tokens\n    /// @param b_address Address of the account to burn from\n    /// @param b_amount Amount of tokens to burn\n    function minter_burn_from(address b_address, uint256 b_amount) public onlyMinters {\n        super.burnFrom(b_address, b_amount);\n        emit TokenMinterBurned(b_address, msg.sender, b_amount);\n    }\n\n    /// @notice Used by non-bridge minters to mint new tokens\n    /// @param m_address Address of the account to mint to\n    /// @param m_amount Amount of tokens to mint\n    function minter_mint(address m_address, uint256 m_amount) public onlyMinters {\n        super._mint(m_address, m_amount);\n        emit TokenMinterMinted(msg.sender, m_address, m_amount);\n    }\n\n    /// @notice Adds a non-bridge minter\n    /// @param minter_address Address of minter to add\n    function addMinter(address minter_address) public onlyByOwnGov {\n        require(minter_address != address(0), \"Zero address detected\");\n\n        require(minters[minter_address] == false, \"Address already exists\");\n        minters[minter_address] = true;\n        minters_array.push(minter_address);\n\n        emit MinterAdded(minter_address);\n    }\n\n    /// @notice Removes a non-bridge minter\n    /// @param minter_address Address of minter to remove\n    function removeMinter(address minter_address) public onlyByOwnGov {\n        require(minter_address != address(0), \"Zero address detected\");\n        require(minters[minter_address] == true, \"Address non-existent\");\n\n        // Delete from the mapping\n        delete minters[minter_address];\n\n        // 'Delete' from the array by setting the address to 0x0\n        for (uint256 i = 0; i < minters_array.length; i++) {\n            if (minters_array[i] == minter_address) {\n                minters_array[i] = address(0); // This will leave a null in the array and keep the indices the same\n                break;\n            }\n        }\n\n        emit MinterRemoved(minter_address);\n    }\n\n    /* ========== RESTRICTED FUNCTIONS [ADMIN-RELATED] ========== */\n\n    /// @notice Sets the timelock address\n    /// @param _timelock_address Address of the timelock\n    function setTimelock(address _timelock_address) public onlyByOwnGov {\n        require(_timelock_address != address(0), \"Zero address detected\");\n        timelock_address = _timelock_address;\n        emit TimelockChanged(_timelock_address);\n    }\n\n    /* ========== EVENTS ========== */\n\n    /// @notice Emitted whenever the bridge burns tokens from an account\n    /// @param account Address of the account tokens are being burned from\n    /// @param amount  Amount of tokens burned\n    event Burn(address indexed account, uint256 amount);\n\n    /// @notice Emitted whenever the bridge mints tokens to an account\n    /// @param account Address of the account tokens are being minted for\n    /// @param amount  Amount of tokens minted.\n    event Mint(address indexed account, uint256 amount);\n\n    /// @notice Emitted when a non-bridge minter is added\n    /// @param minter_address Address of the new minter\n    event MinterAdded(address minter_address);\n\n    /// @notice Emitted when a non-bridge minter is removed\n    /// @param minter_address Address of the removed minter\n    event MinterRemoved(address minter_address);\n\n    /// @notice Emitted when the timelock address changes\n    /// @param timelock_address Address of the removed timelock\n    event TimelockChanged(address timelock_address);\n\n    /// @notice Emitted when a non-bridge minter burns tokens\n    /// @param from The account whose tokens are burned\n    /// @param to The minter doing the burning\n    /// @param amount Amount of tokens burned\n    event TokenMinterBurned(address indexed from, address indexed to, uint256 amount);\n\n    /// @notice Emitted when a non-bridge minter mints tokens\n    /// @param from The minter doing the minting\n    /// @param to The account that gets the newly minted tokens\n    /// @param amount Amount of tokens minted\n    event TokenMinterMinted(address indexed from, address indexed to, uint256 amount);\n}\n"},"src/contracts/fraxtal/shared/OwnedV2.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.8.4;\n\n// https://docs.synthetix.io/contracts/Owned\ncontract OwnedV2 {\n    error OwnerCannotBeZero();\n    error InvalidOwnershipAcceptance();\n    error OnlyOwner();\n\n    address public owner;\n    address public nominatedOwner;\n\n    constructor(address _owner) {\n        // require(_owner != address(0), \"Owner address cannot be 0\");\n        if (_owner == address(0)) revert OwnerCannotBeZero();\n        owner = _owner;\n        emit OwnerChanged(address(0), _owner);\n    }\n\n    function nominateNewOwner(address _owner) external onlyOwner {\n        nominatedOwner = _owner;\n        emit OwnerNominated(_owner);\n    }\n\n    function acceptOwnership() external {\n        // require(msg.sender == nominatedOwner, \"You must be nominated before you can accept ownership\");\n        if (msg.sender != nominatedOwner) revert InvalidOwnershipAcceptance();\n        emit OwnerChanged(owner, nominatedOwner);\n        owner = nominatedOwner;\n        nominatedOwner = address(0);\n    }\n\n    modifier onlyOwner() {\n        // require(msg.sender == owner, \"Only the contract owner may perform this action\");\n        if (msg.sender != owner) revert OnlyOwner();\n        _;\n    }\n\n    event OwnerNominated(address newOwner);\n    event OwnerChanged(address oldOwner, address newOwner);\n}\n"},"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IERC165 } from \"@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol\";\n/// @custom:legacy\n/// @title ILegacyMintableERC20\n/// @notice This interface was available on the legacy L2StandardERC20 contract.\n///         It remains available on the OptimismMintableERC20 contract for\n///         backwards compatibility.\n\ninterface ILegacyMintableERC20 is IERC165 {\n    function l1Token() external view returns (address);\n\n    function mint(address _to, uint256 _amount) external;\n\n    function burn(address _from, uint256 _amount) external;\n}\n"},"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IERC165 } from \"@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol\";\n\n/// @title IOptimismMintableERC20\n/// @notice This interface is available on the OptimismMintableERC20 contract.\n///         We declare it as a separate interface so that it can be used in\n///         custom implementations of OptimismMintableERC20.\ninterface IOptimismMintableERC20 is IERC165 {\n    function remoteToken() external view returns (address);\n\n    function bridge() external returns (address);\n\n    function mint(address _to, uint256 _amount) external;\n\n    function burn(address _from, uint256 _amount) external;\n}\n"},"src/contracts/fraxtal/shared/interfaces/ISemver.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title ISemver\n/// @notice ISemver is a simple contract for ensuring that contracts are\n///         versioned using semantic versioning.\ninterface ISemver {\n    /// @notice Getter for the semantic version of the contract. This is not\n    ///         meant to be used onchain but instead meant to be used by offchain\n    ///         tooling.\n    /// @return Semver contract version as a string.\n    function version() external view returns (string memory);\n}\n"},"src/contracts/shared/core/modules/EIP3009Module.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { SignatureModule } from \"./SignatureModule.sol\";\n\n/// @title Eip3009\n/// @notice Eip3009 provides internal implementations for gas-abstracted transfers under Eip3009 guidelines\n/// @author Frax Finance, inspired by Agora (thanks Drake)\nabstract contract EIP3009Module is SignatureModule {\n    /// @notice keccak256(\"TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\")\n    bytes32 internal constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH =\n        0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267;\n\n    /// @notice keccak256(\"ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\")\n    bytes32 internal constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH =\n        0xd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8;\n\n    /// @notice keccak256(\"CancelAuthorization(address authorizer,bytes32 nonce)\")\n    bytes32 internal constant CANCEL_AUTHORIZATION_TYPEHASH =\n        0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429;\n\n    //==============================================================================\n    // Storage\n    //==============================================================================\n\n    struct EIP3009ModuleStorage {\n        mapping(address authorizer => mapping(bytes32 nonce => bool used)) isAuthorizationUsed;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"frax.storage.EIP3009Module\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant EIP3009ModuleStorageLocation =\n        0x6607eb842e76408d8b3956685dc6b9da5897a1d9b47edcc993ce266e603fa500;\n\n    function _getEIP3009ModuleStorage() private pure returns (EIP3009ModuleStorage storage $) {\n        assembly {\n            $.slot := EIP3009ModuleStorageLocation\n        }\n    }\n\n    //==============================================================================\n    // Functions\n    //==============================================================================\n\n    /// @notice The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @dev added in v1.1.0\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The block.timestamp after which the authorization is valid\n    /// @param validBefore The block.timestamp before which the authorization is valid\n    /// @param nonce Unique nonce\n    /// @param v ECDSA signature parameter v\n    /// @param r ECDSA signature parameters r\n    /// @param s ECDSA signature parameters s\n    function transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external {\n        // Packs signature pieces into bytes\n        transferWithAuthorization({\n            from: from,\n            to: to,\n            value: value,\n            validAfter: validAfter,\n            validBefore: validBefore,\n            nonce: nonce,\n            signature: abi.encodePacked(r, s, v)\n        });\n    }\n\n    /// @notice The ```transferWithAuthorization``` function executes a transfer with a signed authorization\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The time after which this is valid (unix time)\n    /// @param validBefore The time before which this is valid (unix time)\n    /// @param nonce Unique nonce\n    /// @param signature Signature byte array produced by an EOA wallet or a contract wallet\n    function transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) public {\n        // Checks: authorization validity\n        if (block.timestamp <= validAfter) revert InvalidAuthorization();\n        if (block.timestamp >= validBefore) revert ExpiredAuthorization();\n        _requireUnusedAuthorization({ authorizer: from, nonce: nonce });\n\n        // Checks: valid signature\n        _requireIsValidSignatureNow({\n            signer: from,\n            structHash: keccak256(\n                abi.encode(TRANSFER_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce)\n            ),\n            signature: signature\n        });\n\n        // Effects: mark authorization as used and transfer\n        _markAuthorizationAsUsed({ authorizer: from, nonce: nonce });\n        __transfer({ from: from, to: to, amount: value });\n    }\n\n    /// @notice The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer\n    /// @dev This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacks\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The block.timestamp after which the authorization is valid\n    /// @param validBefore The block.timestamp before which the authorization is valid\n    /// @param nonce Unique nonce\n    /// @param v ECDSA signature parameter v\n    /// @param r ECDSA signature parameters r\n    /// @param s ECDSA signature parameters s\n    function receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external {\n        // Packs signature pieces into bytes\n        receiveWithAuthorization({\n            from: from,\n            to: to,\n            value: value,\n            validAfter: validAfter,\n            validBefore: validBefore,\n            nonce: nonce,\n            signature: abi.encodePacked(r, s, v)\n        });\n    }\n\n    /// @notice The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer\n    /// @dev This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacks\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The block.timestamp after which the authorization is valid\n    /// @param validBefore The block.timestamp before which the authorization is valid\n    /// @param nonce Unique nonce\n    /// @param signature Signature byte array produced by an EOA wallet or a contract wallet\n    function receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) public {\n        // Checks: authorization validity\n        if (to != msg.sender) revert InvalidPayee({ caller: msg.sender, payee: to });\n        if (block.timestamp <= validAfter) revert InvalidAuthorization();\n        if (block.timestamp >= validBefore) revert ExpiredAuthorization();\n        _requireUnusedAuthorization({ authorizer: from, nonce: nonce });\n\n        // Checks: valid signature\n        _requireIsValidSignatureNow({\n            signer: from,\n            structHash: keccak256(\n                abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce)\n            ),\n            signature: signature\n        });\n\n        // Effects: mark authorization as used and transfer\n        _markAuthorizationAsUsed({ authorizer: from, nonce: nonce });\n        __transfer({ from: from, to: to, amount: value });\n    }\n\n    /// @notice The ```cancelAuthorization``` function cancels an authorization nonce\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param authorizer   Authorizer's address\n    /// @param nonce        Nonce of the authorization\n    /// @param v            ECDSA signature v value\n    /// @param r            ECDSA signature r value\n    /// @param s            ECDSA signature s value\n    function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external {\n        cancelAuthorization({ authorizer: authorizer, nonce: nonce, signature: abi.encodePacked(r, s, v) });\n    }\n\n    /// @notice The ```cancelAuthorization``` function cancels an authorization nonce\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param authorizer    Authorizer's address\n    /// @param nonce         Nonce of the authorization\n    /// @param signature     Signature byte array produced by an EOA wallet or a contract wallet\n    function cancelAuthorization(address authorizer, bytes32 nonce, bytes memory signature) public {\n        _requireUnusedAuthorization({ authorizer: authorizer, nonce: nonce });\n        _requireIsValidSignatureNow({\n            signer: authorizer,\n            structHash: keccak256(abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce)),\n            signature: signature\n        });\n\n        _getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce] = true;\n        emit AuthorizationCanceled({ authorizer: authorizer, nonce: nonce });\n    }\n\n    //==============================================================================\n    // Internal Checks Functions\n    //==============================================================================\n\n    /// @notice The ```_requireUnusedAuthorization``` checks that an authorization nonce is unused\n    /// @param authorizer    Authorizer's address\n    /// @param nonce         Nonce of the authorization\n    function _requireUnusedAuthorization(address authorizer, bytes32 nonce) private view {\n        if (_getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce]) {\n            revert UsedOrCanceledAuthorization();\n        }\n    }\n\n    //==============================================================================\n    // Internal Effects Functions\n    //==============================================================================\n\n    /// @notice The ```_markAuthorizationAsUsed``` function marks an authorization nonce as used\n    /// @param authorizer    Authorizer's address\n    /// @param nonce         Nonce of the authorization\n    function _markAuthorizationAsUsed(address authorizer, bytes32 nonce) private {\n        _getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce] = true;\n        emit AuthorizationUsed({ authorizer: authorizer, nonce: nonce });\n    }\n\n    //==============================================================================\n    // Views\n    //==============================================================================\n\n    /**\n     * @notice Returns the state of an authorization\n     * @dev Nonces are randomly generated 32-byte data unique to the authorizer's\n     * address\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @return True if the nonce is used\n     */\n    function authorizationState(address authorizer, bytes32 nonce) external view returns (bool) {\n        return _getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce];\n    }\n\n    //==============================================================================\n    // Overridden methods\n    //==============================================================================\n\n    function __transfer(address from, address to, uint256 amount) internal virtual returns (bool);\n\n    //==============================================================================\n    // Events\n    //==============================================================================\n\n    /// @notice ```AuthorizationUsed``` event is emitted when an authorization is used\n    /// @param authorizer Authorizer's address\n    /// @param nonce Nonce of the authorization\n    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);\n\n    /// @notice ```AuthorizationCanceled``` event is emitted when an authorization is canceled\n    /// @param authorizer Authorizer's address\n    /// @param nonce Nonce of the authorization\n    event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);\n\n    //==============================================================================\n    // Errors\n    //==============================================================================\n\n    /// @notice The ```InvalidPayee``` error is emitted when the payee does not match sender in receiveWithAuthorization\n    /// @param caller The caller of the function\n    /// @param payee The expected payee in the function\n    error InvalidPayee(address caller, address payee);\n\n    /// @notice The ```InvalidAuthorization``` error is emitted when the authorization is invalid because its too early\n    error InvalidAuthorization();\n\n    /// @notice The ```ExpiredAuthorization``` error is emitted when the authorization is expired\n    error ExpiredAuthorization();\n\n    /// @notice The ```UsedOrCanceledAuthorization``` error is emitted when the authorization nonce is already used or canceled\n    error UsedOrCanceledAuthorization();\n}\n"},"src/contracts/shared/core/modules/PermitModule.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { SignatureModule } from \"./SignatureModule.sol\";\n\n/// @dev Ripped from OZ 4.9.4 ERC20Permit.sol with namespaced storage and support of ERC1271 signatures\nabstract contract PermitModule is SignatureModule {\n    //==============================================================================\n    // Storage\n    //==============================================================================\n\n    bytes32 private constant PERMIT_TYPEHASH =\n        keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    //==============================================================================\n    // Functions\n    //==============================================================================\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        permit({\n            owner: owner,\n            spender: spender,\n            value: value,\n            deadline: deadline,\n            signature: abi.encodePacked(r, s, v)\n        });\n    }\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        bytes memory signature\n    ) public virtual {\n        require(block.timestamp <= deadline, \"Permit: expired deadline\");\n\n        _requireIsValidSignatureNow({\n            signer: owner,\n            structHash: keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, __useNonce(owner), deadline)),\n            signature: signature\n        });\n\n        __approve(owner, spender, value);\n    }\n\n    //==============================================================================\n    // Virtual methods to override in child class\n    //==============================================================================\n\n    function __approve(address owner, address spender, uint256 amount) internal virtual;\n\n    function __domainSeparatorV4() internal view virtual returns (bytes32);\n\n    function __useNonce(address owner) internal virtual returns (uint256);\n}\n"},"src/contracts/shared/core/modules/SignatureModule.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { SignatureChecker } from \"@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts that use EIP-712 signatures.\n * It provides functionality to initialize the EIP-712 domain separator and verify signatures.\n */\nabstract contract SignatureModule {\n    /// @notice Error thrown when a signature is invalid\n    error InvalidSignature();\n\n    /// @dev Added supportive function to check if the signature is valid\n    function _requireIsValidSignatureNow(address signer, bytes32 structHash, bytes memory signature) internal view {\n        if (\n            !SignatureChecker.isValidSignatureNow({\n                signer: signer,\n                hash: __hashTypedDataV4({ structHash: structHash }),\n                signature: signature\n            })\n        ) revert InvalidSignature();\n    }\n\n    function __hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.30+commit.73712a01","compilerSettings":{"viaIR":false,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"prague","remappings":["frax-std/=node_modules/frax-standard-solidity/src/","@prb/math/=node_modules/@prb/math/","forge-std/=node_modules/forge-std/src/","ds-test/=node_modules/ds-test/src/","@openzeppelin/=node_modules/@openzeppelin/","solmate/=node_modules/solmate/src/","@fraxfinance/=node_modules/@fraxfinance/","@layerzerolabs/=node_modules/@layerzerolabs/","frax-standard-solidity/=node_modules/frax-standard-solidity/","hardhat-deploy/=node_modules/hardhat-deploy/","solidity-bytes-utils/=node_modules/solidity-bytes-utils/"]},"name":"SfrxUSD","fullyQualifiedName":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},"abi":[{"type":"constructor","inputs":[{"name":"_bridge","type":"address","internalType":"address"},{"name":"_remoteToken","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"ERC2612ExpiredSignature","type":"error","inputs":[{"name":"deadline","type":"uint256","internalType":"uint256"}]},{"name":"ERC2612InvalidSigner","type":"error","inputs":[{"name":"signer","type":"address","internalType":"address"},{"name":"owner","type":"address","internalType":"address"}]},{"name":"ExpiredAuthorization","type":"error","inputs":[]},{"name":"InvalidAccountNonce","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"currentNonce","type":"uint256","internalType":"uint256"}]},{"name":"InvalidAuthorization","type":"error","inputs":[]},{"name":"InvalidOwnershipAcceptance","type":"error","inputs":[]},{"name":"InvalidPayee","type":"error","inputs":[{"name":"caller","type":"address","internalType":"address"},{"name":"payee","type":"address","internalType":"address"}]},{"name":"InvalidShortString","type":"error","inputs":[]},{"name":"InvalidSignature","type":"error","inputs":[]},{"name":"OnlyOwner","type":"error","inputs":[]},{"name":"OwnerCannotBeZero","type":"error","inputs":[]},{"name":"StringTooLong","type":"error","inputs":[{"name":"str","type":"string","internalType":"string"}]},{"name":"UsedOrCanceledAuthorization","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"AuthorizationCanceled","type":"event","inputs":[{"name":"authorizer","type":"address","indexed":true,"internalType":"address"},{"name":"nonce","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"AuthorizationUsed","type":"event","inputs":[{"name":"authorizer","type":"address","indexed":true,"internalType":"address"},{"name":"nonce","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"Burn","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"EIP712DomainChanged","type":"event","inputs":[],"anonymous":false},{"name":"Mint","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MinterAdded","type":"event","inputs":[{"name":"minter_address","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"MinterRemoved","type":"event","inputs":[{"name":"minter_address","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"OwnerChanged","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":false,"internalType":"address"},{"name":"newOwner","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"OwnerNominated","type":"event","inputs":[{"name":"newOwner","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"TimelockChanged","type":"event","inputs":[{"name":"timelock_address","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"TokenMinterBurned","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"}],"anonymous":false},{"name":"TokenMinterMinted","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"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"BRIDGE","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"REMOTE_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"addMinter","type":"function","inputs":[{"name":"minter_address","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"authorizationState","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"burn","type":"function","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burn","type":"function","inputs":[{"name":"_from","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burnFrom","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelAuthorization","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelAuthorization","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"eip712Domain","type":"function","inputs":[],"outputs":[{"name":"fields","type":"bytes1","internalType":"bytes1"},{"name":"name","type":"string","internalType":"string"},{"name":"version","type":"string","internalType":"string"},{"name":"chainId","type":"uint256","internalType":"uint256"},{"name":"verifyingContract","type":"address","internalType":"address"},{"name":"salt","type":"bytes32","internalType":"bytes32"},{"name":"extensions","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"name":"l1Token","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"l2Bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"_to","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"minter_burn_from","type":"function","inputs":[{"name":"b_address","type":"address","internalType":"address"},{"name":"b_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"minter_mint","type":"function","inputs":[{"name":"m_address","type":"address","internalType":"address"},{"name":"m_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"minters","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"minters_array","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"nominateNewOwner","type":"function","inputs":[{"name":"_owner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"nominatedOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"nonces","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"receiveWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"receiveWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"remoteToken","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"removeMinter","type":"function","inputs":[{"name":"minter_address","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setTimelock","type":"function","inputs":[{"name":"_timelock_address","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":"pure"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"timelock_address","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"version","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"}],"metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_bridge","type":"address"},{"internalType":"address","name":"_remoteToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[],"name":"ExpiredAuthorization","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidAuthorization","type":"error"},{"inputs":[],"name":"InvalidOwnershipAcceptance","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"address","name":"payee","type":"address"}],"name":"InvalidPayee","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[],"name":"OwnerCannotBeZero","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"inputs":[],"name":"UsedOrCanceledAuthorization","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"authorizer","type":"address"},{"indexed":true,"internalType":"bytes32","name":"nonce","type":"bytes32"}],"name":"AuthorizationCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"authorizer","type":"address"},{"indexed":true,"internalType":"bytes32","name":"nonce","type":"bytes32"}],"name":"AuthorizationUsed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter_address","type":"address"}],"name":"MinterAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter_address","type":"address"}],"name":"MinterRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"timelock_address","type":"address"}],"name":"TimelockChanged","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"}],"name":"TokenMinterBurned","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"}],"name":"TokenMinterMinted","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":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BRIDGE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REMOTE_TOKEN","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter_address","type":"address"}],"name":"addMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"bytes32","name":"nonce","type":"bytes32"}],"name":"authorizationState","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"cancelAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"authorizer","type":"address"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"cancelAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1Token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2Bridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"b_address","type":"address"},{"internalType":"uint256","name":"b_amount","type":"uint256"}],"name":"minter_burn_from","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"m_address","type":"address"},{"internalType":"uint256","name":"m_amount","type":"uint256"}],"name":"minter_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"minters_array","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"receiveWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"receiveWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"remoteToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter_address","type":"address"}],"name":"removeMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_timelock_address","type":"address"}],"name":"setTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timelock_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"transferWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"validAfter","type":"uint256"},{"internalType":"uint256","name":"validBefore","type":"uint256"},{"internalType":"bytes32","name":"nonce","type":"bytes32"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"transferWithAuthorization","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"}],"devdoc":{"errors":{"ERC20InsufficientAllowance(address,uint256,uint256)":[{"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers.","params":{"allowance":"Amount of tokens a `spender` is allowed to operate with.","needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers.","params":{"balance":"Current balance for the interacting account.","needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred."}}],"ERC20InvalidApprover(address)":[{"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals.","params":{"approver":"Address initiating an approval operation."}}],"ERC20InvalidReceiver(address)":[{"details":"Indicates a failure with the token `receiver`. Used in transfers.","params":{"receiver":"Address to which tokens are being transferred."}}],"ERC20InvalidSender(address)":[{"details":"Indicates a failure with the token `sender`. Used in transfers.","params":{"sender":"Address whose tokens are being transferred."}}],"ERC20InvalidSpender(address)":[{"details":"Indicates a failure with the `spender` to be approved. Used in approvals.","params":{"spender":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC2612ExpiredSignature(uint256)":[{"details":"Permit deadline has expired."}],"ERC2612InvalidSigner(address,address)":[{"details":"Mismatched signature."}],"InvalidAccountNonce(address,uint256)":[{"details":"The nonce used for an `account` is not the expected current nonce."}],"InvalidPayee(address,address)":[{"params":{"caller":"The caller of the function","payee":"The expected payee in the function"}}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"AuthorizationCanceled(address,bytes32)":{"params":{"authorizer":"Authorizer's address","nonce":"Nonce of the authorization"}},"AuthorizationUsed(address,bytes32)":{"params":{"authorizer":"Authorizer's address","nonce":"Nonce of the authorization"}},"Burn(address,uint256)":{"params":{"account":"Address of the account tokens are being burned from","amount":"Amount of tokens burned"}},"EIP712DomainChanged()":{"details":"MAY be emitted to signal that the domain could have changed."},"Mint(address,uint256)":{"params":{"account":"Address of the account tokens are being minted for","amount":"Amount of tokens minted."}},"MinterAdded(address)":{"params":{"minter_address":"Address of the new minter"}},"MinterRemoved(address)":{"params":{"minter_address":"Address of the removed minter"}},"TimelockChanged(address)":{"params":{"timelock_address":"Address of the removed timelock"}},"TokenMinterBurned(address,address,uint256)":{"params":{"amount":"Amount of tokens burned","from":"The account whose tokens are burned","to":"The minter doing the burning"}},"TokenMinterMinted(address,address,uint256)":{"params":{"amount":"Amount of tokens minted","from":"The minter doing the minting","to":"The account that gets the newly minted tokens"}},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"kind":"dev","methods":{"DOMAIN_SEPARATOR()":{"details":"Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}."},"addMinter(address)":{"params":{"minter_address":"Address of minter to add"}},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"authorizationState(address,bytes32)":{"details":"Nonces are randomly generated 32-byte data unique to the authorizer's address","params":{"authorizer":"Authorizer's address","nonce":"Nonce of the authorization"},"returns":{"_0":"True if the nonce is used"}},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"bridge()":{"custom:legacy":"@notice Legacy getter for BRIDGE","returns":{"_0":"address The bridge address"}},"burn(address,uint256)":{"params":{"_amount":"Amount of tokens to burn.","_from":"Address to burn tokens from."}},"burn(uint256)":{"details":"Destroys a `value` amount of tokens from the caller. See {ERC20-_burn}."},"burnFrom(address,uint256)":{"details":"Destroys a `value` amount of tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `value`."},"cancelAuthorization(address,bytes32,bytes)":{"details":"EOA wallet signatures should be packed in the order of r, s, v","params":{"authorizer":"Authorizer's address","nonce":"Nonce of the authorization","signature":"Signature byte array produced by an EOA wallet or a contract wallet"}},"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)":{"details":"EOA wallet signatures should be packed in the order of r, s, v","params":{"authorizer":"Authorizer's address","nonce":"Nonce of the authorization","r":"ECDSA signature r value","s":"ECDSA signature s value","v":"ECDSA signature v value"}},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"eip712Domain()":{"details":"See {IERC-5267}."},"l1Token()":{"custom:legacy":"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.","returns":{"_0":"address The L1 remote token address"}},"l2Bridge()":{"custom:legacy":"@notice Legacy getter for the bridge. Use BRIDGE going forward.","returns":{"_0":"address The bridge address"}},"mint(address,uint256)":{"params":{"_amount":"Amount of tokens to mint.","_to":"Address to mint tokens to."}},"minter_burn_from(address,uint256)":{"params":{"b_address":"Address of the account to burn from","b_amount":"Amount of tokens to burn"}},"minter_mint(address,uint256)":{"params":{"m_address":"Address of the account to mint to","m_amount":"Amount of tokens to mint"}},"name()":{"details":"Returns the name of the token."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times."},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"details":"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v","params":{"from":"Payer's address (Authorizer)","nonce":"Unique nonce","signature":"Signature byte array produced by an EOA wallet or a contract wallet","to":"Payee's address","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid","value":"Amount to be transferred"}},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"details":"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v","params":{"from":"Payer's address (Authorizer)","nonce":"Unique nonce","r":"ECDSA signature parameters r","s":"ECDSA signature parameters s","to":"Payee's address","v":"ECDSA signature parameter v","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid","value":"Amount to be transferred"}},"remoteToken()":{"custom:legacy":"@notice Legacy getter for REMOTE_TOKEN","returns":{"_0":"address The L1 remote token address"}},"removeMinter(address)":{"params":{"minter_address":"Address of minter to remove"}},"setTimelock(address)":{"params":{"_timelock_address":"Address of the timelock"}},"supportsInterface(bytes4)":{"params":{"_interfaceId":"Interface ID to check."},"returns":{"_0":"Whether or not the interface is supported by this contract."}},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"details":"EOA wallet signatures should be packed in the order of r, s, v","params":{"from":"Payer's address (Authorizer)","nonce":"Unique nonce","signature":"Signature byte array produced by an EOA wallet or a contract wallet","to":"Payee's address","validAfter":"The time after which this is valid (unix time)","validBefore":"The time before which this is valid (unix time)","value":"Amount to be transferred"}},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"details":"EOA wallet signatures should be packed in the order of r, s, vadded in v1.1.0","params":{"from":"Payer's address (Authorizer)","nonce":"Unique nonce","r":"ECDSA signature parameters r","s":"ECDSA signature parameters s","to":"Payee's address","v":"ECDSA signature parameter v","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid","value":"Amount to be transferred"}}},"version":1},"userdoc":{"errors":{"ExpiredAuthorization()":[{"notice":"The ```ExpiredAuthorization``` error is emitted when the authorization is expired"}],"InvalidAuthorization()":[{"notice":"The ```InvalidAuthorization``` error is emitted when the authorization is invalid because its too early"}],"InvalidPayee(address,address)":[{"notice":"The ```InvalidPayee``` error is emitted when the payee does not match sender in receiveWithAuthorization"}],"InvalidSignature()":[{"notice":"Error thrown when a signature is invalid"}],"UsedOrCanceledAuthorization()":[{"notice":"The ```UsedOrCanceledAuthorization``` error is emitted when the authorization nonce is already used or canceled"}]},"events":{"AuthorizationCanceled(address,bytes32)":{"notice":"```AuthorizationCanceled``` event is emitted when an authorization is canceled"},"AuthorizationUsed(address,bytes32)":{"notice":"```AuthorizationUsed``` event is emitted when an authorization is used"},"Burn(address,uint256)":{"notice":"Emitted whenever the bridge burns tokens from an account"},"Mint(address,uint256)":{"notice":"Emitted whenever the bridge mints tokens to an account"},"MinterAdded(address)":{"notice":"Emitted when a non-bridge minter is added"},"MinterRemoved(address)":{"notice":"Emitted when a non-bridge minter is removed"},"TimelockChanged(address)":{"notice":"Emitted when the timelock address changes"},"TokenMinterBurned(address,address,uint256)":{"notice":"Emitted when a non-bridge minter burns tokens"},"TokenMinterMinted(address,address,uint256)":{"notice":"Emitted when a non-bridge minter mints tokens"}},"kind":"user","methods":{"BRIDGE()":{"notice":"Address of the L2 StandardBridge on this network."},"REMOTE_TOKEN()":{"notice":"Address of the corresponding version of this token on the remote chain."},"addMinter(address)":{"notice":"Adds a non-bridge minter"},"authorizationState(address,bytes32)":{"notice":"Returns the state of an authorization"},"burn(address,uint256)":{"notice":"Allows the StandardBridge on this network to burn tokens."},"cancelAuthorization(address,bytes32,bytes)":{"notice":"The ```cancelAuthorization``` function cancels an authorization nonce"},"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```cancelAuthorization``` function cancels an authorization nonce"},"mint(address,uint256)":{"notice":"Allows the StandardBridge on this network to mint tokens."},"minter_burn_from(address,uint256)":{"notice":"Used by non-bridge minters to burn tokens"},"minter_mint(address,uint256)":{"notice":"Used by non-bridge minters to mint new tokens"},"minters(address)":{"notice":"Mapping of the non-bridge minters"},"minters_array(uint256)":{"notice":"Array of the non-bridge minters"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"notice":"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer"},"removeMinter(address)":{"notice":"Removes a non-bridge minter"},"setTimelock(address)":{"notice":"Sets the timelock address"},"supportsInterface(bytes4)":{"notice":"ERC165 interface check function."},"timelock_address()":{"notice":"The timelock address"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"notice":"The ```transferWithAuthorization``` function executes a transfer with a signed authorization"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009"}},"version":1}},"settings":{"compilationTarget":{"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol":"SfrxUSD"},"evmVersion":"prague","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@fraxfinance/=node_modules/@fraxfinance/",":@layerzerolabs/=node_modules/@layerzerolabs/",":@openzeppelin/=node_modules/@openzeppelin/",":@prb/math/=node_modules/@prb/math/",":ds-test/=node_modules/ds-test/src/",":forge-std/=node_modules/forge-std/src/",":frax-standard-solidity/=node_modules/frax-standard-solidity/",":frax-std/=node_modules/frax-standard-solidity/src/",":hardhat-deploy/=node_modules/hardhat-deploy/",":solidity-bytes-utils/=node_modules/solidity-bytes-utils/",":solmate/=node_modules/solmate/src/"]},"sources":{"node_modules/@openzeppelin/contracts-5.2.0/interfaces/IERC5267.sol":{"keccak256":"0x92aa1df62dc3d33f1656d63bede0923e0df0b706ad4137c8b10b0a8fe549fd92","license":"MIT","urls":["bzz-raw://c5c0f29195ad64cbe556da8e257dac8f05f78c53f90323c0d2accf8e6922d33a","dweb:/ipfs/QmQ61TED8uaCZwcbh8KkgRSsCav7x7HbcGHwHts3U4DmUP"]},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/draft-IERC6093.sol":{"keccak256":"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b","license":"MIT","urls":["bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b","dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz"]},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/ERC20.sol":{"keccak256":"0x6ef9389a2c07bc40d8a7ba48914724ab2c108fac391ce12314f01321813e6368","license":"MIT","urls":["bzz-raw://b7a5cb39b1e6df68f4dd9a5e76e853d745a74ffb3dfd7df4ae4d2ace6992a171","dweb:/ipfs/QmPbzKR19rdM8X3PLQjsmHRepUKhvoZnedSR63XyGtXZib"]},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol":{"keccak256":"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7","license":"MIT","urls":["bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db","dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"]},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol":{"keccak256":"0x2659248df25e34000ed214b3dc8da2160bc39874c992b477d9e2b1b3283dc073","license":"MIT","urls":["bzz-raw://c345af1b0e7ea28d1216d6a04ab28f5534a5229b9edf9ca3cd0e84950ae58d26","dweb:/ipfs/QmY63jtSrYpLRe8Gj1ep2vMDCKxGNNG3hnNVKBVnrs2nmA"]},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol":{"keccak256":"0xaa7f0646f49ebe2606eeca169f85c56451bbaeeeb06265fa076a03369a25d1d3","license":"MIT","urls":["bzz-raw://ee931d4e832385765967efe6366dcc6d00d6a2d794f9c66ee38283c03882de9c","dweb:/ipfs/QmR6SkuJGYxpQeLz38rBdghqaWqEPfzUsL9kBoXgEXKtbD"]},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330","license":"MIT","urls":["bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf","dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r"]},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Permit.sol":{"keccak256":"0x27dbc90e5136ffe46c04f7596fc2dbcc3acebd8d504da3d93fdb8496e6de04f6","license":"MIT","urls":["bzz-raw://0ea8b92e4245d75a5579c10f22f118f7b4ba07c57341f181f0b2a85ff8663de3","dweb:/ipfs/Qme3Ss5ByjmkxxkMdLpyu7fQ1PCtjNFH1wEFszt2BZePiG"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/Nonces.sol":{"keccak256":"0x0082767004fca261c332e9ad100868327a863a88ef724e844857128845ab350f","license":"MIT","urls":["bzz-raw://132dce9686a54e025eb5ba5d2e48208f847a1ec3e60a3e527766d7bf53fb7f9e","dweb:/ipfs/QmXn1a2nUZMpu2z6S88UoTfMVtY2YNh86iGrzJDYmMkKeZ"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/Panic.sol":{"keccak256":"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a","license":"MIT","urls":["bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a","dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/ShortStrings.sol":{"keccak256":"0x7d94fa0af099a2172eb01f9c8a8a443cbe7e0e43654841563e4e09968efdb549","license":"MIT","urls":["bzz-raw://65e38fb76b6add407d4557753ae83dd1268e8261195dbe5c19a580d5ba6e4e9a","dweb:/ipfs/QmTkGSJtaQrqjcyWM4AgemeEmKgtDydKPPVRajsUJRQSrK"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/StorageSlot.sol":{"keccak256":"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97","license":"MIT","urls":["bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b","dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/Strings.sol":{"keccak256":"0x44f87e91783e88415bde66f1a63f6c7f0076f2d511548820407d5c95643ac56c","license":"MIT","urls":["bzz-raw://13a51bc2b23827744dcf5bad10c69e72528cf015a6fe48c93632cdb2c0eb1251","dweb:/ipfs/QmZwPA47Yqgje1qtkdEFEja8ntTahMStYzKf5q3JRnaR7d"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/ECDSA.sol":{"keccak256":"0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84","license":"MIT","urls":["bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9","dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/EIP712.sol":{"keccak256":"0x10eb97d047f8d84fe263a02bb4a656ac6674f6679d74532cc37546289e073a9d","license":"MIT","urls":["bzz-raw://3e41287d40b0c46982f1083d40d32de2761f009c5c51627fe79a7feb0ab1cf5c","dweb:/ipfs/Qme7dbh6HX3ZvUJdbQAcVqXkmyXyfcLiUZRhhon3cU6K8p"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/MessageHashUtils.sol":{"keccak256":"0x4515543bc4c78561f6bea83ecfdfc3dead55bd59858287d682045b11de1ae575","license":"MIT","urls":["bzz-raw://60601f91440125727244fffd2ba84da7caafecaae0fd887c7ccfec678e02b61e","dweb:/ipfs/QmZnKPBtVDiQS9Dp8gZ4sa3ZeTrWVfqF7yuUd6Y8hwm1Rs"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol":{"keccak256":"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8","license":"MIT","urls":["bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621","dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/Math.sol":{"keccak256":"0xa00be322d7db5786750ce0ac7e2f5b633ac30a5ed5fa1ced1e74acfc19acecea","license":"MIT","urls":["bzz-raw://6c84e822f87cbdc4082533b626667b6928715bb2b1e8e7eb96954cebb9e38c8d","dweb:/ipfs/QmZmy9dgxLTerBAQDuuHqbL6EpgRxddqgv5KmwpXYVbKz1"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SafeCast.sol":{"keccak256":"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54","license":"MIT","urls":["bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8","dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy"]},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SignedMath.sol":{"keccak256":"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3","license":"MIT","urls":["bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03","dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ"]},"node_modules/@openzeppelin/contracts-5.3.0/interfaces/IERC1271.sol":{"keccak256":"0x3d4cd07258d675b6dfa3d9dfd623a77b38fb9935f4a5381ff4bc969948720976","license":"MIT","urls":["bzz-raw://30abb60a4d98ad9a33de4fa5e9072342e12df3a79e9c71b5f59ce049ae8cd535","dweb:/ipfs/QmT6NXJDjsf8H14nPYQsFELDB8q5ZTmG9cjdX2bEQJW7ST"]},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/ECDSA.sol":{"keccak256":"0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84","license":"MIT","urls":["bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9","dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n"]},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol":{"keccak256":"0xbdc3bb48ccedb818cd75a6d74a16df55a822e9f6d3cc54c59f576f10aab67b5f","license":"MIT","urls":["bzz-raw://2284f25f2478f419d7781573b17a89d0e7c5589a865d55e2d6ed5163aee23aa8","dweb:/ipfs/QmNsr2625APBQiNKpYnX5VcSnYgfUHR9Uzzp9pRXjoDqK7"]},"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol":{"keccak256":"0x298baa4260a5ba2b0a0baa2beae061304876ebe1c7c0ea98d9f32e189d141b5b","license":"AGPL-3.0-only","urls":["bzz-raw://91038044c8098c0d5b0ad6e845c37e2745d8e92a37eb5949a42f092265cd75ae","dweb:/ipfs/QmZendXFL4aev48KuBQ2KmSagv7onYGtsHqKaZbcxCzpe5"]},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol":{"keccak256":"0xe1bb4c3a61b7e70641648e84fbe9cd615386b787063c550dabc0acae009ff434","urls":["bzz-raw://d0e39853e4595057958d622530be74565d106c606e99d6f659c7c260ec977fe9","dweb:/ipfs/QmWLvWsWCstZxwjydQBNEPSQ3DmMrTUtMhS7fg6CEsHfbx"]},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol":{"keccak256":"0xaa1eb91fdb6e90504795c4c069920db013fcd2a4c979c17d5670e8723875e2a1","license":"Unlicense","urls":["bzz-raw://d85cdd3721769775b202ad7ba100430d0e2b61c1642e0753bd15600974af9e50","dweb:/ipfs/QmXT5iBLwEMN3Hhwn1SL4zjtbd54zM5cPzPTNQpkV9Eyre"]},"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol":{"keccak256":"0xd0d66ac4dcca2bfb1cd7265e657d9d958782c3bb575769384b913dc7c913c7c0","license":"MIT","urls":["bzz-raw://f0ee40e46efacb647a7e1f1cd9e8fc87a96e625689654de9118fea9cd2335a99","dweb:/ipfs/Qmbp8TXbo9bd7PK3VVgpoftYuEGHxMCy5M9bPBj5GRUKVQ"]},"src/contracts/fraxtal/shared/OwnedV2.sol":{"keccak256":"0x8a2c8367bf46de70e490d08765334183bba588a712a12ca5671c560bbbc4e8c2","license":"GPL-2.0-or-later","urls":["bzz-raw://7fdbea3858e9e7d6cc576eea3fd1ecb610e1017eedcd8f97a6fb7b9fcd04249d","dweb:/ipfs/QmcLTm4VwTTQ6mCjWULjDGrLo9Rvy86NPSbSuwynwTq1Ky"]},"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol":{"keccak256":"0x7f3398284404a2376940cd735506a97391281573c6336716ba76806611dceae6","license":"MIT","urls":["bzz-raw://f3b81ac99667950bcd372726d6a990162170271e62ed5564d85fe344b1fad01c","dweb:/ipfs/QmZ6ZLeFbFk7kieyKkzssPLKr5h4PRYjRzxZUGobBesuqt"]},"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol":{"keccak256":"0x0109eb6a621adf3577dcada01635b14c858d0fb236658b98434980d120a9292f","license":"MIT","urls":["bzz-raw://1d7064404cfcbb7e104b8a4a57c35ef7ee933cc9e02e9378a246fef474587756","dweb:/ipfs/QmXH7Bk8uFY1j5acrtve6BmZkBQedCnTKsVanVvbM3rTN8"]},"src/contracts/fraxtal/shared/interfaces/ISemver.sol":{"keccak256":"0xba34562a8026f59886d2e07d1d58d90b9691d00e0788c6263cef6c22740cab44","license":"MIT","urls":["bzz-raw://0826f998632f83c103c3085bf2e872db79a69022b6d2e0444c83a64ca5283c2a","dweb:/ipfs/QmcJ7PNqkAfKqbjFGRordtAg1v9DvcBSKvdTkVvciLyvQR"]},"src/contracts/shared/core/modules/EIP3009Module.sol":{"keccak256":"0x68c0357226167c19a589682ce6b7291d00091ea53217d696cb338161ef674cb4","urls":["bzz-raw://78a17e324dcb4a8c7577fef3d17f509753ff0cd1d90ac40b8edbb1a28b81bf81","dweb:/ipfs/QmekMj1E8TTgJCdFjJ5YgxrVTMkddiDFA1JcxR2dxsphzA"]},"src/contracts/shared/core/modules/PermitModule.sol":{"keccak256":"0x7c7c9c25d9e2911231016ab9994b824385355fa674cec7e87dc9fc4f9b1a2e7c","urls":["bzz-raw://4f2d7b0c129ede9a986946669aa165a13aac32e14625e9c029924b2dc3315816","dweb:/ipfs/QmT56QCgEEcF5gvaydm4xMrHV3j8DvnLZxx6UmMeM4fqcc"]},"src/contracts/shared/core/modules/SignatureModule.sol":{"keccak256":"0x46655ff89b4db9b4dc691272038b8df31830301296d6b6dd9f252f5ab95ec47a","urls":["bzz-raw://99a1e024c31ce44941c19afb4356a06be7470b513854c8b4151e0faaa5217ded","dweb:/ipfs/QmbMnnmw3mZ1ADHiEhiqJZNsgUgYv3TVnAPRENkw4yQAfp"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_array(t_address)dyn_storage":{"base":"t_address","label":"address[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":184,"label":"_balances","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":190,"label":"_allowances","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"2","type":"t_uint256","astId":192,"label":"_totalSupply","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"3","type":"t_string_storage","astId":194,"label":"_name","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"4","type":"t_string_storage","astId":196,"label":"_symbol","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"5","type":"t_string_storage","astId":3092,"label":"_nameFallback","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"6","type":"t_string_storage","astId":3094,"label":"_versionFallback","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"7","type":"t_mapping(t_address,t_uint256)","astId":1060,"label":"_nonces","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"8","type":"t_address","astId":8093,"label":"owner","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"9","type":"t_address","astId":8095,"label":"nominatedOwner","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"10","type":"t_address","astId":7621,"label":"timelock_address","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"11","type":"t_array(t_address)dyn_storage","astId":7631,"label":"minters_array","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"12","type":"t_mapping(t_address,t_bool)","astId":7636,"label":"minters","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","errors":{"InvalidSignature()":[{"notice":"Error thrown when a signature is invalid"}],"ExpiredAuthorization()":[{"notice":"The ```ExpiredAuthorization``` error is emitted when the authorization is expired"}],"InvalidAuthorization()":[{"notice":"The ```InvalidAuthorization``` error is emitted when the authorization is invalid because its too early"}],"InvalidPayee(address,address)":[{"notice":"The ```InvalidPayee``` error is emitted when the payee does not match sender in receiveWithAuthorization"}],"UsedOrCanceledAuthorization()":[{"notice":"The ```UsedOrCanceledAuthorization``` error is emitted when the authorization nonce is already used or canceled"}]},"events":{"MinterAdded(address)":{"notice":"Emitted when a non-bridge minter is added"},"Burn(address,uint256)":{"notice":"Emitted whenever the bridge burns tokens from an account"},"Mint(address,uint256)":{"notice":"Emitted whenever the bridge mints tokens to an account"},"MinterRemoved(address)":{"notice":"Emitted when a non-bridge minter is removed"},"TimelockChanged(address)":{"notice":"Emitted when the timelock address changes"},"AuthorizationUsed(address,bytes32)":{"notice":"```AuthorizationUsed``` event is emitted when an authorization is used"},"AuthorizationCanceled(address,bytes32)":{"notice":"```AuthorizationCanceled``` event is emitted when an authorization is canceled"},"TokenMinterBurned(address,address,uint256)":{"notice":"Emitted when a non-bridge minter burns tokens"},"TokenMinterMinted(address,address,uint256)":{"notice":"Emitted when a non-bridge minter mints tokens"}},"methods":{"BRIDGE()":{"notice":"Address of the L2 StandardBridge on this network."},"REMOTE_TOKEN()":{"notice":"Address of the corresponding version of this token on the remote chain."},"minters(address)":{"notice":"Mapping of the non-bridge minters"},"addMinter(address)":{"notice":"Adds a non-bridge minter"},"timelock_address()":{"notice":"The timelock address"},"setTimelock(address)":{"notice":"Sets the timelock address"},"burn(address,uint256)":{"notice":"Allows the StandardBridge on this network to burn tokens."},"mint(address,uint256)":{"notice":"Allows the StandardBridge on this network to mint tokens."},"removeMinter(address)":{"notice":"Removes a non-bridge minter"},"minters_array(uint256)":{"notice":"Array of the non-bridge minters"},"supportsInterface(bytes4)":{"notice":"ERC165 interface check function."},"minter_mint(address,uint256)":{"notice":"Used by non-bridge minters to mint new tokens"},"minter_burn_from(address,uint256)":{"notice":"Used by non-bridge minters to burn tokens"},"authorizationState(address,bytes32)":{"notice":"Returns the state of an authorization"},"cancelAuthorization(address,bytes32,bytes)":{"notice":"The ```cancelAuthorization``` function cancels an authorization nonce"},"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```cancelAuthorization``` function cancels an authorization nonce"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"notice":"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"notice":"The ```transferWithAuthorization``` function executes a transfer with a signed authorization"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009"}},"version":1},"devdoc":{"kind":"dev","errors":{"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"InvalidPayee(address,address)":[{"params":{"payee":"The expected payee in the function","caller":"The caller of the function"}}],"ERC2612ExpiredSignature(uint256)":[{"details":"Permit deadline has expired."}],"InvalidAccountNonce(address,uint256)":[{"details":"The nonce used for an `account` is not the expected current nonce."}],"ERC2612InvalidSigner(address,address)":[{"details":"Mismatched signature."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"MinterAdded(address)":{"params":{"minter_address":"Address of the new minter"}},"Burn(address,uint256)":{"params":{"amount":"Amount of tokens burned","account":"Address of the account tokens are being burned from"}},"EIP712DomainChanged()":{"details":"MAY be emitted to signal that the domain could have changed."},"Mint(address,uint256)":{"params":{"amount":"Amount of tokens minted.","account":"Address of the account tokens are being minted for"}},"MinterRemoved(address)":{"params":{"minter_address":"Address of the removed minter"}},"TimelockChanged(address)":{"params":{"timelock_address":"Address of the removed timelock"}},"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."},"AuthorizationUsed(address,bytes32)":{"params":{"nonce":"Nonce of the authorization","authorizer":"Authorizer's address"}},"AuthorizationCanceled(address,bytes32)":{"params":{"nonce":"Nonce of the authorization","authorizer":"Authorizer's address"}},"TokenMinterBurned(address,address,uint256)":{"params":{"to":"The minter doing the burning","from":"The account whose tokens are burned","amount":"Amount of tokens burned"}},"TokenMinterMinted(address,address,uint256)":{"params":{"to":"The account that gets the newly minted tokens","from":"The minter doing the minting","amount":"Amount of tokens minted"}}},"methods":{"name()":{"details":"Returns the name of the token."},"bridge()":{"returns":{"_0":"address The bridge address"},"custom:legacy":"@notice Legacy getter for BRIDGE"},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"l1Token()":{"returns":{"_0":"address The L1 remote token address"},"custom:legacy":"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"l2Bridge()":{"returns":{"_0":"address The bridge address"},"custom:legacy":"@notice Legacy getter for the bridge. Use BRIDGE going forward."},"burn(uint256)":{"details":"Destroys a `value` amount of tokens from the caller. See {ERC20-_burn}."},"remoteToken()":{"returns":{"_0":"address The L1 remote token address"},"custom:legacy":"@notice Legacy getter for REMOTE_TOKEN"},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"eip712Domain()":{"details":"See {IERC-5267}."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times."},"DOMAIN_SEPARATOR()":{"details":"Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}."},"addMinter(address)":{"params":{"minter_address":"Address of minter to add"}},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"setTimelock(address)":{"params":{"_timelock_address":"Address of the timelock"}},"burn(address,uint256)":{"params":{"_from":"Address to burn tokens from.","_amount":"Amount of tokens to burn."}},"mint(address,uint256)":{"params":{"_to":"Address to mint tokens to.","_amount":"Amount of tokens to mint."}},"removeMinter(address)":{"params":{"minter_address":"Address of minter to remove"}},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"burnFrom(address,uint256)":{"details":"Destroys a `value` amount of tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `value`."},"supportsInterface(bytes4)":{"params":{"_interfaceId":"Interface ID to check."},"returns":{"_0":"Whether or not the interface is supported by this contract."}},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"minter_mint(address,uint256)":{"params":{"m_amount":"Amount of tokens to mint","m_address":"Address of the account to mint to"}},"minter_burn_from(address,uint256)":{"params":{"b_amount":"Amount of tokens to burn","b_address":"Address of the account to burn from"}},"authorizationState(address,bytes32)":{"params":{"nonce":"Nonce of the authorization","authorizer":"Authorizer's address"},"details":"Nonces are randomly generated 32-byte data unique to the authorizer's address","returns":{"_0":"True if the nonce is used"}},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."},"cancelAuthorization(address,bytes32,bytes)":{"params":{"nonce":"Nonce of the authorization","signature":"Signature byte array produced by an EOA wallet or a contract wallet","authorizer":"Authorizer's address"},"details":"EOA wallet signatures should be packed in the order of r, s, v"},"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)":{"params":{"r":"ECDSA signature r value","s":"ECDSA signature s value","v":"ECDSA signature v value","nonce":"Nonce of the authorization","authorizer":"Authorizer's address"},"details":"EOA wallet signatures should be packed in the order of r, s, v"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"params":{"to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","signature":"Signature byte array produced by an EOA wallet or a contract wallet","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid"},"details":"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"params":{"to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","signature":"Signature byte array produced by an EOA wallet or a contract wallet","validAfter":"The time after which this is valid (unix time)","validBefore":"The time before which this is valid (unix time)"},"details":"EOA wallet signatures should be packed in the order of r, s, v"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"params":{"r":"ECDSA signature parameters r","s":"ECDSA signature parameters s","v":"ECDSA signature parameter v","to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid"},"details":"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"params":{"r":"ECDSA signature parameters r","s":"ECDSA signature parameters s","v":"ECDSA signature parameter v","to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid"},"details":"EOA wallet signatures should be packed in the order of r, s, vadded in v1.1.0"}},"version":1},"sourceIds":{"src/contracts/fraxtal/shared/OwnedV2.sol":{"id":28},"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol":{"id":24},"src/contracts/shared/core/modules/PermitModule.sol":{"id":33},"src/contracts/fraxtal/shared/interfaces/ISemver.sol":{"id":31},"src/contracts/shared/core/modules/EIP3009Module.sol":{"id":32},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol":{"id":25},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol":{"id":26},"src/contracts/shared/core/modules/SignatureModule.sol":{"id":34},"node_modules/@openzeppelin/contracts-5.2.0/utils/Panic.sol":{"id":10},"node_modules/@openzeppelin/contracts-5.2.0/utils/Nonces.sol":{"id":9},"node_modules/@openzeppelin/contracts-5.2.0/utils/Context.sol":{"id":8},"node_modules/@openzeppelin/contracts-5.2.0/utils/Strings.sol":{"id":13},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/Math.sol":{"id":18},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/ERC20.sol":{"id":2},"node_modules/@openzeppelin/contracts-5.2.0/utils/StorageSlot.sol":{"id":12},"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol":{"id":29},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol":{"id":3},"node_modules/@openzeppelin/contracts-5.2.0/utils/ShortStrings.sol":{"id":11},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/IERC5267.sol":{"id":0},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SafeCast.sol":{"id":19},"node_modules/@openzeppelin/contracts-5.3.0/interfaces/IERC1271.sol":{"id":21},"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol":{"id":30},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SignedMath.sol":{"id":20},"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol":{"id":27},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/ECDSA.sol":{"id":14},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/ECDSA.sol":{"id":22},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/draft-IERC6093.sol":{"id":1},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/EIP712.sol":{"id":15},"node_modules/@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol":{"id":17},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol":{"id":5},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Permit.sol":{"id":7},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/MessageHashUtils.sol":{"id":16},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol":{"id":23},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol":{"id":4},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Metadata.sol":{"id":6}},"additionalInput":null,"stdJsonInput":{"sources":{"src/contracts/fraxtal/shared/OwnedV2.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.8.4;\n\n// https://docs.synthetix.io/contracts/Owned\ncontract OwnedV2 {\n    error OwnerCannotBeZero();\n    error InvalidOwnershipAcceptance();\n    error OnlyOwner();\n\n    address public owner;\n    address public nominatedOwner;\n\n    constructor(address _owner) {\n        // require(_owner != address(0), \"Owner address cannot be 0\");\n        if (_owner == address(0)) revert OwnerCannotBeZero();\n        owner = _owner;\n        emit OwnerChanged(address(0), _owner);\n    }\n\n    function nominateNewOwner(address _owner) external onlyOwner {\n        nominatedOwner = _owner;\n        emit OwnerNominated(_owner);\n    }\n\n    function acceptOwnership() external {\n        // require(msg.sender == nominatedOwner, \"You must be nominated before you can accept ownership\");\n        if (msg.sender != nominatedOwner) revert InvalidOwnershipAcceptance();\n        emit OwnerChanged(owner, nominatedOwner);\n        owner = nominatedOwner;\n        nominatedOwner = address(0);\n    }\n\n    modifier onlyOwner() {\n        // require(msg.sender == owner, \"Only the contract owner may perform this action\");\n        if (msg.sender != owner) revert OnlyOwner();\n        _;\n    }\n\n    event OwnerNominated(address newOwner);\n    event OwnerChanged(address oldOwner, address newOwner);\n}\n"},"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.8.0;\n\n// ====================================================================\n// |     ______                   _______                             |\n// |    / _____________ __  __   / ____(_____  ____ _____  ________   |\n// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \\/ __ `/ __ \\/ ___/ _ \\  |\n// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |\n// | /_/   /_/   \\__,_/_/|_|  /_/   /_/_/ /_/\\__,_/_/ /_/\\___/\\___/   |\n// |                                                                  |\n// ====================================================================\n// ============================= FrxUSD ===============================\n// ====================================================================\n// Frax Finance: https://github.com/FraxFinance\n// Tested for 18-decimal underlying assets only\n\nimport { SfrxUSD2 } from \"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol\";\n\ncontract SfrxUSD is SfrxUSD2 {\n    constructor(address _bridge, address _remoteToken) SfrxUSD2(_bridge, _remoteToken) {}\n}\n"},"src/contracts/shared/core/modules/PermitModule.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { SignatureModule } from \"./SignatureModule.sol\";\n\n/// @dev Ripped from OZ 4.9.4 ERC20Permit.sol with namespaced storage and support of ERC1271 signatures\nabstract contract PermitModule is SignatureModule {\n    //==============================================================================\n    // Storage\n    //==============================================================================\n\n    bytes32 private constant PERMIT_TYPEHASH =\n        keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    //==============================================================================\n    // Functions\n    //==============================================================================\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        permit({\n            owner: owner,\n            spender: spender,\n            value: value,\n            deadline: deadline,\n            signature: abi.encodePacked(r, s, v)\n        });\n    }\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        bytes memory signature\n    ) public virtual {\n        require(block.timestamp <= deadline, \"Permit: expired deadline\");\n\n        _requireIsValidSignatureNow({\n            signer: owner,\n            structHash: keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, __useNonce(owner), deadline)),\n            signature: signature\n        });\n\n        __approve(owner, spender, value);\n    }\n\n    //==============================================================================\n    // Virtual methods to override in child class\n    //==============================================================================\n\n    function __approve(address owner, address spender, uint256 amount) internal virtual;\n\n    function __domainSeparatorV4() internal view virtual returns (bytes32);\n\n    function __useNonce(address owner) internal virtual returns (uint256);\n}\n"},"src/contracts/fraxtal/shared/interfaces/ISemver.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title ISemver\n/// @notice ISemver is a simple contract for ensuring that contracts are\n///         versioned using semantic versioning.\ninterface ISemver {\n    /// @notice Getter for the semantic version of the contract. This is not\n    ///         meant to be used onchain but instead meant to be used by offchain\n    ///         tooling.\n    /// @return Semver contract version as a string.\n    function version() external view returns (string memory);\n}\n"},"src/contracts/shared/core/modules/EIP3009Module.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { SignatureModule } from \"./SignatureModule.sol\";\n\n/// @title Eip3009\n/// @notice Eip3009 provides internal implementations for gas-abstracted transfers under Eip3009 guidelines\n/// @author Frax Finance, inspired by Agora (thanks Drake)\nabstract contract EIP3009Module is SignatureModule {\n    /// @notice keccak256(\"TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\")\n    bytes32 internal constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH =\n        0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267;\n\n    /// @notice keccak256(\"ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)\")\n    bytes32 internal constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH =\n        0xd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8;\n\n    /// @notice keccak256(\"CancelAuthorization(address authorizer,bytes32 nonce)\")\n    bytes32 internal constant CANCEL_AUTHORIZATION_TYPEHASH =\n        0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429;\n\n    //==============================================================================\n    // Storage\n    //==============================================================================\n\n    struct EIP3009ModuleStorage {\n        mapping(address authorizer => mapping(bytes32 nonce => bool used)) isAuthorizationUsed;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"frax.storage.EIP3009Module\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant EIP3009ModuleStorageLocation =\n        0x6607eb842e76408d8b3956685dc6b9da5897a1d9b47edcc993ce266e603fa500;\n\n    function _getEIP3009ModuleStorage() private pure returns (EIP3009ModuleStorage storage $) {\n        assembly {\n            $.slot := EIP3009ModuleStorageLocation\n        }\n    }\n\n    //==============================================================================\n    // Functions\n    //==============================================================================\n\n    /// @notice The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @dev added in v1.1.0\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The block.timestamp after which the authorization is valid\n    /// @param validBefore The block.timestamp before which the authorization is valid\n    /// @param nonce Unique nonce\n    /// @param v ECDSA signature parameter v\n    /// @param r ECDSA signature parameters r\n    /// @param s ECDSA signature parameters s\n    function transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external {\n        // Packs signature pieces into bytes\n        transferWithAuthorization({\n            from: from,\n            to: to,\n            value: value,\n            validAfter: validAfter,\n            validBefore: validBefore,\n            nonce: nonce,\n            signature: abi.encodePacked(r, s, v)\n        });\n    }\n\n    /// @notice The ```transferWithAuthorization``` function executes a transfer with a signed authorization\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The time after which this is valid (unix time)\n    /// @param validBefore The time before which this is valid (unix time)\n    /// @param nonce Unique nonce\n    /// @param signature Signature byte array produced by an EOA wallet or a contract wallet\n    function transferWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) public {\n        // Checks: authorization validity\n        if (block.timestamp <= validAfter) revert InvalidAuthorization();\n        if (block.timestamp >= validBefore) revert ExpiredAuthorization();\n        _requireUnusedAuthorization({ authorizer: from, nonce: nonce });\n\n        // Checks: valid signature\n        _requireIsValidSignatureNow({\n            signer: from,\n            structHash: keccak256(\n                abi.encode(TRANSFER_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce)\n            ),\n            signature: signature\n        });\n\n        // Effects: mark authorization as used and transfer\n        _markAuthorizationAsUsed({ authorizer: from, nonce: nonce });\n        __transfer({ from: from, to: to, amount: value });\n    }\n\n    /// @notice The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer\n    /// @dev This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacks\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The block.timestamp after which the authorization is valid\n    /// @param validBefore The block.timestamp before which the authorization is valid\n    /// @param nonce Unique nonce\n    /// @param v ECDSA signature parameter v\n    /// @param r ECDSA signature parameters r\n    /// @param s ECDSA signature parameters s\n    function receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external {\n        // Packs signature pieces into bytes\n        receiveWithAuthorization({\n            from: from,\n            to: to,\n            value: value,\n            validAfter: validAfter,\n            validBefore: validBefore,\n            nonce: nonce,\n            signature: abi.encodePacked(r, s, v)\n        });\n    }\n\n    /// @notice The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer\n    /// @dev This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacks\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param from Payer's address (Authorizer)\n    /// @param to Payee's address\n    /// @param value Amount to be transferred\n    /// @param validAfter The block.timestamp after which the authorization is valid\n    /// @param validBefore The block.timestamp before which the authorization is valid\n    /// @param nonce Unique nonce\n    /// @param signature Signature byte array produced by an EOA wallet or a contract wallet\n    function receiveWithAuthorization(\n        address from,\n        address to,\n        uint256 value,\n        uint256 validAfter,\n        uint256 validBefore,\n        bytes32 nonce,\n        bytes memory signature\n    ) public {\n        // Checks: authorization validity\n        if (to != msg.sender) revert InvalidPayee({ caller: msg.sender, payee: to });\n        if (block.timestamp <= validAfter) revert InvalidAuthorization();\n        if (block.timestamp >= validBefore) revert ExpiredAuthorization();\n        _requireUnusedAuthorization({ authorizer: from, nonce: nonce });\n\n        // Checks: valid signature\n        _requireIsValidSignatureNow({\n            signer: from,\n            structHash: keccak256(\n                abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce)\n            ),\n            signature: signature\n        });\n\n        // Effects: mark authorization as used and transfer\n        _markAuthorizationAsUsed({ authorizer: from, nonce: nonce });\n        __transfer({ from: from, to: to, amount: value });\n    }\n\n    /// @notice The ```cancelAuthorization``` function cancels an authorization nonce\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param authorizer   Authorizer's address\n    /// @param nonce        Nonce of the authorization\n    /// @param v            ECDSA signature v value\n    /// @param r            ECDSA signature r value\n    /// @param s            ECDSA signature s value\n    function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external {\n        cancelAuthorization({ authorizer: authorizer, nonce: nonce, signature: abi.encodePacked(r, s, v) });\n    }\n\n    /// @notice The ```cancelAuthorization``` function cancels an authorization nonce\n    /// @dev EOA wallet signatures should be packed in the order of r, s, v\n    /// @param authorizer    Authorizer's address\n    /// @param nonce         Nonce of the authorization\n    /// @param signature     Signature byte array produced by an EOA wallet or a contract wallet\n    function cancelAuthorization(address authorizer, bytes32 nonce, bytes memory signature) public {\n        _requireUnusedAuthorization({ authorizer: authorizer, nonce: nonce });\n        _requireIsValidSignatureNow({\n            signer: authorizer,\n            structHash: keccak256(abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce)),\n            signature: signature\n        });\n\n        _getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce] = true;\n        emit AuthorizationCanceled({ authorizer: authorizer, nonce: nonce });\n    }\n\n    //==============================================================================\n    // Internal Checks Functions\n    //==============================================================================\n\n    /// @notice The ```_requireUnusedAuthorization``` checks that an authorization nonce is unused\n    /// @param authorizer    Authorizer's address\n    /// @param nonce         Nonce of the authorization\n    function _requireUnusedAuthorization(address authorizer, bytes32 nonce) private view {\n        if (_getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce]) {\n            revert UsedOrCanceledAuthorization();\n        }\n    }\n\n    //==============================================================================\n    // Internal Effects Functions\n    //==============================================================================\n\n    /// @notice The ```_markAuthorizationAsUsed``` function marks an authorization nonce as used\n    /// @param authorizer    Authorizer's address\n    /// @param nonce         Nonce of the authorization\n    function _markAuthorizationAsUsed(address authorizer, bytes32 nonce) private {\n        _getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce] = true;\n        emit AuthorizationUsed({ authorizer: authorizer, nonce: nonce });\n    }\n\n    //==============================================================================\n    // Views\n    //==============================================================================\n\n    /**\n     * @notice Returns the state of an authorization\n     * @dev Nonces are randomly generated 32-byte data unique to the authorizer's\n     * address\n     * @param authorizer    Authorizer's address\n     * @param nonce         Nonce of the authorization\n     * @return True if the nonce is used\n     */\n    function authorizationState(address authorizer, bytes32 nonce) external view returns (bool) {\n        return _getEIP3009ModuleStorage().isAuthorizationUsed[authorizer][nonce];\n    }\n\n    //==============================================================================\n    // Overridden methods\n    //==============================================================================\n\n    function __transfer(address from, address to, uint256 amount) internal virtual returns (bool);\n\n    //==============================================================================\n    // Events\n    //==============================================================================\n\n    /// @notice ```AuthorizationUsed``` event is emitted when an authorization is used\n    /// @param authorizer Authorizer's address\n    /// @param nonce Nonce of the authorization\n    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);\n\n    /// @notice ```AuthorizationCanceled``` event is emitted when an authorization is canceled\n    /// @param authorizer Authorizer's address\n    /// @param nonce Nonce of the authorization\n    event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);\n\n    //==============================================================================\n    // Errors\n    //==============================================================================\n\n    /// @notice The ```InvalidPayee``` error is emitted when the payee does not match sender in receiveWithAuthorization\n    /// @param caller The caller of the function\n    /// @param payee The expected payee in the function\n    error InvalidPayee(address caller, address payee);\n\n    /// @notice The ```InvalidAuthorization``` error is emitted when the authorization is invalid because its too early\n    error InvalidAuthorization();\n\n    /// @notice The ```ExpiredAuthorization``` error is emitted when the authorization is expired\n    error ExpiredAuthorization();\n\n    /// @notice The ```UsedOrCanceledAuthorization``` error is emitted when the authorization nonce is already used or canceled\n    error UsedOrCanceledAuthorization();\n}\n"},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { ERC20PermitPermissionedOptiMintable } from \"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol\";\n\ncontract SfrxUSD is ERC20PermitPermissionedOptiMintable {\n    function version() public pure virtual override returns (string memory) {\n        return \"1.0.0\";\n    }\n\n    /// @param _creator_address The contract creator\n    /// @param _timelock_address The timelock\n    /// @param _bridge Address of the L2 standard bridge\n    /// @param _remoteToken Address of the corresponding L1 token\n    constructor(\n        address _creator_address,\n        address _timelock_address,\n        address _bridge,\n        address _remoteToken\n    )\n        ERC20PermitPermissionedOptiMintable(\n            _creator_address,\n            _timelock_address,\n            _bridge,\n            _remoteToken,\n            \"Staked Frax USD\",\n            \"sfrxUSD\"\n        )\n    {}\n}\n"},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol":{"content":"//SPDX-License-Identifier: Unlicense\npragma solidity ^0.8.0;\n\nimport { ERC20Permit, ERC20, EIP712, Nonces } from \"@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol\";\nimport { SfrxUSD } from \"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol\";\nimport { PermitModule } from \"src/contracts/shared/core/modules/PermitModule.sol\";\nimport { EIP3009Module, SignatureModule } from \"src/contracts/shared/core/modules/EIP3009Module.sol\";\n\n/// @title SfrxUSD v2.0.0\n/// @notice Frax USD Stablecoin by Frax Finance\n/// @dev v2.0.0 adds ERC-1271 and EIP-3009 support\ncontract SfrxUSD2 is SfrxUSD, EIP3009Module, PermitModule {\n    function version() public pure override returns (string memory) {\n        return \"2.0.0\";\n    }\n\n    constructor(address _bridge, address _remoteToken) SfrxUSD(address(1), address(1), _bridge, _remoteToken) {}\n\n    /*//////////////////////////////////////////////////////////////\n                        Module Overrides\n    //////////////////////////////////////////////////////////////*/\n\n    function __transfer(address from, address to, uint256 amount) internal override returns (bool) {\n        ERC20._transfer(from, to, amount);\n        return true;\n    }\n\n    function __hashTypedDataV4(bytes32 structHash) internal view override(SignatureModule) returns (bytes32) {\n        return EIP712._hashTypedDataV4(structHash);\n    }\n\n    function __approve(address owner, address spender, uint256 amount) internal override(PermitModule) {\n        ERC20._approve(owner, spender, amount);\n    }\n\n    function __useNonce(address owner) internal override(PermitModule) returns (uint256) {\n        return Nonces._useNonce(owner);\n    }\n\n    function __domainSeparatorV4() internal view override(PermitModule) returns (bytes32) {\n        return EIP712._domainSeparatorV4();\n    }\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public override(ERC20Permit, PermitModule) {\n        return\n            PermitModule.permit({ owner: owner, spender: spender, value: value, deadline: deadline, v: v, r: r, s: s });\n    }\n}\n"},"src/contracts/shared/core/modules/SignatureModule.sol":{"content":"pragma solidity ^0.8.0;\n\nimport { SignatureChecker } from \"@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts that use EIP-712 signatures.\n * It provides functionality to initialize the EIP-712 domain separator and verify signatures.\n */\nabstract contract SignatureModule {\n    /// @notice Error thrown when a signature is invalid\n    error InvalidSignature();\n\n    /// @dev Added supportive function to check if the signature is valid\n    function _requireIsValidSignatureNow(address signer, bytes32 structHash, bytes memory signature) internal view {\n        if (\n            !SignatureChecker.isValidSignatureNow({\n                signer: signer,\n                hash: __hashTypedDataV4({ structHash: structHash }),\n                signature: signature\n            })\n        ) revert InvalidSignature();\n    }\n\n    function __hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Nonces.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides tracking nonces for addresses. Nonces will only increment.\n */\nabstract contract Nonces {\n    /**\n     * @dev The nonce used for an `account` is not the expected current nonce.\n     */\n    error InvalidAccountNonce(address account, uint256 currentNonce);\n\n    mapping(address account => uint256) private _nonces;\n\n    /**\n     * @dev Returns the next unused nonce for an address.\n     */\n    function nonces(address owner) public view virtual returns (uint256) {\n        return _nonces[owner];\n    }\n\n    /**\n     * @dev Consumes a nonce.\n     *\n     * Returns the current value and increments nonce.\n     */\n    function _useNonce(address owner) internal virtual returns (uint256) {\n        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be\n        // decremented or reset. This guarantees that the nonce never overflows.\n        unchecked {\n            // It is important to do x++ and not ++x here.\n            return _nonces[owner]++;\n        }\n    }\n\n    /**\n     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.\n     */\n    function _useCheckedNonce(address owner, uint256 nonce) internal virtual {\n        uint256 current = _useNonce(owner);\n        if (nonce != current) {\n            revert InvalidAccountNonce(owner, current);\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (utils/Strings.sol)\n\npragma solidity ^0.8.20;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guaratees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(buffer, add(0x20, offset)))\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            if (c < a) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b > a) return (false, 0);\n            return (true, a - b);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n            // benefit is lost if 'b' is also tested.\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n            if (a == 0) return (true, 0);\n            uint256 c = a * b;\n            if (c / a != b) return (false, 0);\n            return (true, c);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a / b);\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            if (b == 0) return (false, 0);\n            return (true, a % b);\n        }\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2²⁵⁶ + prod0.\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= prod1) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\n        for (uint256 i = 0; i < byteArray.length; ++i) {\n            if (byteArray[i] != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 exp;\n        unchecked {\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\n            value >>= exp;\n            result += exp;\n\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\n            value >>= exp;\n            result += exp;\n\n            result += SafeCast.toUint(value > 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        uint256 isGt;\n        unchecked {\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\n            value >>= isGt * 128;\n            result += isGt * 16;\n\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\n            value >>= isGt * 64;\n            result += isGt * 8;\n\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\n            value >>= isGt * 32;\n            result += isGt * 4;\n\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\n            value >>= isGt * 16;\n            result += isGt * 2;\n\n            result += SafeCast.toUint(value > (1 << 8) - 1);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.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 ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\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 *\n * TIP: Consider using this library along with {SlotDerivation}.\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 Int256Slot {\n        int256 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        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\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        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\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        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IERC165 } from \"@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol\";\n/// @custom:legacy\n/// @title ILegacyMintableERC20\n/// @notice This interface was available on the legacy L2StandardERC20 contract.\n///         It remains available on the OptimismMintableERC20 contract for\n///         backwards compatibility.\n\ninterface ILegacyMintableERC20 is IERC165 {\n    function l1Token() external view returns (address);\n\n    function mint(address _to, uint256 _amount) external;\n\n    function burn(address _from, uint256 _amount) external;\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/ShortStrings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ShortStrings.sol)\n\npragma solidity ^0.8.20;\n\nimport {StorageSlot} from \"./StorageSlot.sol\";\n\n// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |\n// | length  | 0x                                                              BB |\ntype ShortString is bytes32;\n\n/**\n * @dev This library provides functions to convert short memory strings\n * into a `ShortString` type that can be used as an immutable variable.\n *\n * Strings of arbitrary length can be optimized using this library if\n * they are short enough (up to 31 bytes) by packing them with their\n * length (1 byte) in a single EVM word (32 bytes). Additionally, a\n * fallback mechanism can be used for every other case.\n *\n * Usage example:\n *\n * ```solidity\n * contract Named {\n *     using ShortStrings for *;\n *\n *     ShortString private immutable _name;\n *     string private _nameFallback;\n *\n *     constructor(string memory contractName) {\n *         _name = contractName.toShortStringWithFallback(_nameFallback);\n *     }\n *\n *     function name() external view returns (string memory) {\n *         return _name.toStringWithFallback(_nameFallback);\n *     }\n * }\n * ```\n */\nlibrary ShortStrings {\n    // Used as an identifier for strings longer than 31 bytes.\n    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;\n\n    error StringTooLong(string str);\n    error InvalidShortString();\n\n    /**\n     * @dev Encode a string of at most 31 chars into a `ShortString`.\n     *\n     * This will trigger a `StringTooLong` error is the input string is too long.\n     */\n    function toShortString(string memory str) internal pure returns (ShortString) {\n        bytes memory bstr = bytes(str);\n        if (bstr.length > 31) {\n            revert StringTooLong(str);\n        }\n        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));\n    }\n\n    /**\n     * @dev Decode a `ShortString` back to a \"normal\" string.\n     */\n    function toString(ShortString sstr) internal pure returns (string memory) {\n        uint256 len = byteLength(sstr);\n        // using `new string(len)` would work locally but is not memory safe.\n        string memory str = new string(32);\n        assembly (\"memory-safe\") {\n            mstore(str, len)\n            mstore(add(str, 0x20), sstr)\n        }\n        return str;\n    }\n\n    /**\n     * @dev Return the length of a `ShortString`.\n     */\n    function byteLength(ShortString sstr) internal pure returns (uint256) {\n        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;\n        if (result > 31) {\n            revert InvalidShortString();\n        }\n        return result;\n    }\n\n    /**\n     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.\n     */\n    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {\n        if (bytes(value).length < 32) {\n            return toShortString(value);\n        } else {\n            StorageSlot.getStringSlot(store).value = value;\n            return ShortString.wrap(FALLBACK_SENTINEL);\n        }\n    }\n\n    /**\n     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.\n     */\n    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return toString(value);\n        } else {\n            return store;\n        }\n    }\n\n    /**\n     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using\n     * {setWithFallback}.\n     *\n     * WARNING: This will return the \"byte length\" of the string. This may not reflect the actual length in terms of\n     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.\n     */\n    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return byteLength(value);\n        } else {\n            return bytes(store).length;\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/IERC5267.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)\n\npragma solidity ^0.8.20;\n\ninterface IERC5267 {\n    /**\n     * @dev MAY be emitted to signal that the domain could have changed.\n     */\n    event EIP712DomainChanged();\n\n    /**\n     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712\n     * signature.\n     */\n    function eip712Domain()\n        external\n        view\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        );\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev An uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.3.0/interfaces/IERC1271.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/IERC1271.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-1271 standard signature validation method for\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\n */\ninterface IERC1271 {\n    /**\n     * @dev Should return whether the signature provided is valid for the provided data\n     * @param hash      Hash of the data to be signed\n     * @param signature Signature byte array associated with `hash`\n     */\n    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);\n}\n"},"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IERC165 } from \"@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol\";\n\n/// @title IOptimismMintableERC20\n/// @notice This interface is available on the OptimismMintableERC20 contract.\n///         We declare it as a separate interface so that it can be used in\n///         custom implementations of OptimismMintableERC20.\ninterface IOptimismMintableERC20 is IERC165 {\n    function remoteToken() external view returns (address);\n\n    function bridge() external returns (address);\n\n    function mint(address _to, uint256 _amount) external;\n\n    function burn(address _from, uint256 _amount) external;\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport { IERC20 } from \"@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol\";\nimport { ERC20Permit, ERC20 } from \"@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol\";\nimport { ERC20Burnable } from \"@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol\";\nimport { IERC165 } from \"@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol\";\nimport { ILegacyMintableERC20 } from \"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol\";\nimport { IOptimismMintableERC20 } from \"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol\";\nimport { ISemver } from \"src/contracts/fraxtal/shared/interfaces/ISemver.sol\";\nimport { OwnedV2 } from \"src/contracts/fraxtal/shared/OwnedV2.sol\";\n\n/// @title Parent contract for frxETH.sol, but also CrossChainCanonicalV2\n/**\n * @notice Combines Openzeppelin's ERC20Permit and ERC20Burnable with Synthetix's Owned and Optimism's OptimismMintableERC20.\n *     Also includes a list of authorized minters\n */\n/// @dev ERC20PermitPermissionedOptiMintable adheres to EIP-712/EIP-2612 and can use permits\ncontract ERC20PermitPermissionedOptiMintable is\n    ERC20Permit,\n    ERC20Burnable,\n    OwnedV2,\n    IOptimismMintableERC20,\n    ILegacyMintableERC20,\n    ISemver\n{\n    /// @custom:semver 1.0.0\n    function version() public pure virtual returns (string memory) {\n        return \"1.0.0\";\n    }\n\n    /// @notice The timelock address\n    address public timelock_address;\n\n    /// @notice Address of the L2 StandardBridge on this network.\n    address public immutable BRIDGE;\n\n    /// @notice Address of the corresponding version of this token on the remote chain.\n    address public immutable REMOTE_TOKEN;\n\n    /// @notice Array of the non-bridge minters\n    address[] public minters_array;\n\n    /// @notice Mapping of the non-bridge minters\n    /// @dev Mapping is used for faster verification\n    mapping(address => bool) public minters;\n\n    /* ========== CONSTRUCTOR ========== */\n\n    /// @custom:semver 1.0.0\n    /// @param _creator_address The contract creator\n    /// @param _timelock_address The timelock\n    /// @param _bridge Address of the L2 standard bridge\n    /// @param _remoteToken Address of the corresponding L1 token\n    /// @param _name ERC20 name\n    /// @param _symbol ERC20 symbol\n    constructor(\n        address _creator_address,\n        address _timelock_address,\n        address _bridge,\n        address _remoteToken,\n        string memory _name,\n        string memory _symbol\n    ) ERC20(_name, _symbol) ERC20Permit(_name) OwnedV2(_creator_address) {\n        REMOTE_TOKEN = _remoteToken;\n        BRIDGE = _bridge;\n        timelock_address = _timelock_address;\n    }\n\n    /* ========== MODIFIERS ========== */\n\n    /// @notice A modifier that only allows the contract owner or the timelock to call\n    modifier onlyByOwnGov() {\n        require(msg.sender == timelock_address || msg.sender == owner, \"Not owner or timelock\");\n        _;\n    }\n\n    /// @notice A modifier that only allows a non-bridge minter to call\n    modifier onlyMinters() {\n        require(minters[msg.sender] == true, \"Only minters\");\n        _;\n    }\n\n    /// @notice A modifier that only allows the bridge to call\n    modifier onlyBridge() {\n        require(msg.sender == BRIDGE, \"OptimismMintableERC20: only bridge can mint and burn\");\n        _;\n    }\n\n    /* ========== LEGACY VIEWS ========== */\n\n    /// @custom:legacy\n    /// @notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.\n    /// @return address The L1 remote token address\n    function l1Token() public view returns (address) {\n        return REMOTE_TOKEN;\n    }\n\n    /// @custom:legacy\n    /// @notice Legacy getter for the bridge. Use BRIDGE going forward.\n    /// @return address The bridge address\n    function l2Bridge() public view returns (address) {\n        return BRIDGE;\n    }\n\n    /// @custom:legacy\n    /// @notice Legacy getter for REMOTE_TOKEN\n    /// @return address The L1 remote token address\n    function remoteToken() public view returns (address) {\n        return REMOTE_TOKEN;\n    }\n\n    /// @custom:legacy\n    /// @notice Legacy getter for BRIDGE\n    /// @return address The bridge address\n    function bridge() public view returns (address) {\n        return BRIDGE;\n    }\n\n    /// @notice ERC165 interface check function.\n    /// @param _interfaceId Interface ID to check.\n    /// @return Whether or not the interface is supported by this contract.\n    function supportsInterface(bytes4 _interfaceId) external pure virtual returns (bool) {\n        bytes4 iface1 = type(IERC165).interfaceId;\n        // Interface corresponding to the legacy L2StandardERC20.\n        bytes4 iface2 = type(ILegacyMintableERC20).interfaceId;\n        // Interface corresponding to the updated OptimismMintableERC20 (this contract).\n        bytes4 iface3 = type(IOptimismMintableERC20).interfaceId;\n        return _interfaceId == iface1 || _interfaceId == iface2 || _interfaceId == iface3;\n    }\n\n    /* ========== RESTRICTED FUNCTIONS [BRIDGE] ========== */\n\n    /// @notice Allows the StandardBridge on this network to mint tokens.\n    /// @param _to     Address to mint tokens to.\n    /// @param _amount Amount of tokens to mint.\n    function mint(\n        address _to,\n        uint256 _amount\n    ) external virtual override(IOptimismMintableERC20, ILegacyMintableERC20) onlyBridge {\n        _mint(_to, _amount);\n        emit Mint(_to, _amount);\n    }\n\n    /// @notice Allows the StandardBridge on this network to burn tokens.\n    /// @param _from   Address to burn tokens from.\n    /// @param _amount Amount of tokens to burn.\n    function burn(\n        address _from,\n        uint256 _amount\n    ) external virtual override(IOptimismMintableERC20, ILegacyMintableERC20) onlyBridge {\n        _burn(_from, _amount);\n        emit Burn(_from, _amount);\n    }\n\n    /* ========== RESTRICTED FUNCTIONS [NON-BRIDGE MINTERS] ========== */\n\n    /// @notice Used by non-bridge minters to burn tokens\n    /// @param b_address Address of the account to burn from\n    /// @param b_amount Amount of tokens to burn\n    function minter_burn_from(address b_address, uint256 b_amount) public onlyMinters {\n        super.burnFrom(b_address, b_amount);\n        emit TokenMinterBurned(b_address, msg.sender, b_amount);\n    }\n\n    /// @notice Used by non-bridge minters to mint new tokens\n    /// @param m_address Address of the account to mint to\n    /// @param m_amount Amount of tokens to mint\n    function minter_mint(address m_address, uint256 m_amount) public onlyMinters {\n        super._mint(m_address, m_amount);\n        emit TokenMinterMinted(msg.sender, m_address, m_amount);\n    }\n\n    /// @notice Adds a non-bridge minter\n    /// @param minter_address Address of minter to add\n    function addMinter(address minter_address) public onlyByOwnGov {\n        require(minter_address != address(0), \"Zero address detected\");\n\n        require(minters[minter_address] == false, \"Address already exists\");\n        minters[minter_address] = true;\n        minters_array.push(minter_address);\n\n        emit MinterAdded(minter_address);\n    }\n\n    /// @notice Removes a non-bridge minter\n    /// @param minter_address Address of minter to remove\n    function removeMinter(address minter_address) public onlyByOwnGov {\n        require(minter_address != address(0), \"Zero address detected\");\n        require(minters[minter_address] == true, \"Address non-existent\");\n\n        // Delete from the mapping\n        delete minters[minter_address];\n\n        // 'Delete' from the array by setting the address to 0x0\n        for (uint256 i = 0; i < minters_array.length; i++) {\n            if (minters_array[i] == minter_address) {\n                minters_array[i] = address(0); // This will leave a null in the array and keep the indices the same\n                break;\n            }\n        }\n\n        emit MinterRemoved(minter_address);\n    }\n\n    /* ========== RESTRICTED FUNCTIONS [ADMIN-RELATED] ========== */\n\n    /// @notice Sets the timelock address\n    /// @param _timelock_address Address of the timelock\n    function setTimelock(address _timelock_address) public onlyByOwnGov {\n        require(_timelock_address != address(0), \"Zero address detected\");\n        timelock_address = _timelock_address;\n        emit TimelockChanged(_timelock_address);\n    }\n\n    /* ========== EVENTS ========== */\n\n    /// @notice Emitted whenever the bridge burns tokens from an account\n    /// @param account Address of the account tokens are being burned from\n    /// @param amount  Amount of tokens burned\n    event Burn(address indexed account, uint256 amount);\n\n    /// @notice Emitted whenever the bridge mints tokens to an account\n    /// @param account Address of the account tokens are being minted for\n    /// @param amount  Amount of tokens minted.\n    event Mint(address indexed account, uint256 amount);\n\n    /// @notice Emitted when a non-bridge minter is added\n    /// @param minter_address Address of the new minter\n    event MinterAdded(address minter_address);\n\n    /// @notice Emitted when a non-bridge minter is removed\n    /// @param minter_address Address of the removed minter\n    event MinterRemoved(address minter_address);\n\n    /// @notice Emitted when the timelock address changes\n    /// @param timelock_address Address of the removed timelock\n    event TimelockChanged(address timelock_address);\n\n    /// @notice Emitted when a non-bridge minter burns tokens\n    /// @param from The account whose tokens are burned\n    /// @param to The minter doing the burning\n    /// @param amount Amount of tokens burned\n    event TokenMinterBurned(address indexed from, address indexed to, uint256 amount);\n\n    /// @notice Emitted when a non-bridge minter mints tokens\n    /// @param from The minter doing the minting\n    /// @param to The account that gets the newly minted tokens\n    /// @param amount Amount of tokens minted\n    event TokenMinterMinted(address indexed from, address indexed to, uint256 amount);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/EIP712.sol)\n\npragma solidity ^0.8.20;\n\nimport {MessageHashUtils} from \"./MessageHashUtils.sol\";\nimport {ShortStrings, ShortString} from \"../ShortStrings.sol\";\nimport {IERC5267} from \"../../interfaces/IERC5267.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose\n * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract\n * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to\n * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain\n * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the\n * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.\n *\n * @custom:oz-upgrades-unsafe-allow state-variable-immutable\n */\nabstract contract EIP712 is IERC5267 {\n    using ShortStrings for *;\n\n    bytes32 private constant TYPE_HASH =\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n    // invalidate the cached domain separator if the chain id changes.\n    bytes32 private immutable _cachedDomainSeparator;\n    uint256 private immutable _cachedChainId;\n    address private immutable _cachedThis;\n\n    bytes32 private immutable _hashedName;\n    bytes32 private immutable _hashedVersion;\n\n    ShortString private immutable _name;\n    ShortString private immutable _version;\n    string private _nameFallback;\n    string private _versionFallback;\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        _name = name.toShortStringWithFallback(_nameFallback);\n        _version = version.toShortStringWithFallback(_versionFallback);\n        _hashedName = keccak256(bytes(name));\n        _hashedVersion = keccak256(bytes(version));\n\n        _cachedChainId = block.chainid;\n        _cachedDomainSeparator = _buildDomainSeparator();\n        _cachedThis = address(this);\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {\n            return _cachedDomainSeparator;\n        } else {\n            return _buildDomainSeparator();\n        }\n    }\n\n    function _buildDomainSeparator() private view returns (bytes32) {\n        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n\n    /**\n     * @dev See {IERC-5267}.\n     */\n    function eip712Domain()\n        public\n        view\n        virtual\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        )\n    {\n        return (\n            hex\"0f\", // 01111\n            _EIP712Name(),\n            _EIP712Version(),\n            block.chainid,\n            address(this),\n            bytes32(0),\n            new uint256[](0)\n        );\n    }\n\n    /**\n     * @dev The name parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _name which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Name() internal view returns (string memory) {\n        return _name.toStringWithFallback(_nameFallback);\n    }\n\n    /**\n     * @dev The version parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _version which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Version() internal view returns (string memory) {\n        return _version.toStringWithFallback(_versionFallback);\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\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[ERC 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"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/ERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20Permit} from \"./IERC20Permit.sol\";\nimport {ERC20} from \"../ERC20.sol\";\nimport {ECDSA} from \"../../../utils/cryptography/ECDSA.sol\";\nimport {EIP712} from \"../../../utils/cryptography/EIP712.sol\";\nimport {Nonces} from \"../../../utils/Nonces.sol\";\n\n/**\n * @dev Implementation of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\nabstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {\n    bytes32 private constant PERMIT_TYPEHASH =\n        keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    /**\n     * @dev Permit deadline has expired.\n     */\n    error ERC2612ExpiredSignature(uint256 deadline);\n\n    /**\n     * @dev Mismatched signature.\n     */\n    error ERC2612InvalidSigner(address signer, address owner);\n\n    /**\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\"1\"`.\n     *\n     * It's a good idea to use the same `name` that is defined as the ERC-20 token name.\n     */\n    constructor(string memory name) EIP712(name, \"1\") {}\n\n    /**\n     * @inheritdoc IERC20Permit\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        if (block.timestamp > deadline) {\n            revert ERC2612ExpiredSignature(deadline);\n        }\n\n        bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\n\n        bytes32 hash = _hashTypedDataV4(structHash);\n\n        address signer = ECDSA.recover(hash, v, r, s);\n        if (signer != owner) {\n            revert ERC2612InvalidSigner(signer, owner);\n        }\n\n        _approve(owner, spender, value);\n    }\n\n    /**\n     * @inheritdoc IERC20Permit\n     */\n    function nonces(address owner) public view virtual override(IERC20Permit, Nonces) returns (uint256) {\n        return super.nonces(owner);\n    }\n\n    /**\n     * @inheritdoc IERC20Permit\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.20;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing a bytes32 `messageHash` with\n     * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n     * keccak256, although any bytes32 value can be safely used because the final digest will\n     * be re-hashed.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing an arbitrary `message` with\n     * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n        return\n            keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x00` (data with intended validator).\n     *\n     * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n     * `validator` address. Then hashing the result.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\n     *\n     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n     * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            mstore(ptr, hex\"19_01\")\n            mstore(add(ptr, 0x02), domainSeparator)\n            mstore(add(ptr, 0x22), structHash)\n            digest := keccak256(ptr, 0x42)\n        }\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/SignatureChecker.sol)\n\npragma solidity ^0.8.20;\n\nimport {ECDSA} from \"./ECDSA.sol\";\nimport {IERC1271} from \"../../interfaces/IERC1271.sol\";\n\n/**\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA\n * signatures from externally owned accounts (EOAs) as well as ERC-1271 signatures from smart contract wallets like\n * Argent and Safe Wallet (previously Gnosis Safe).\n */\nlibrary SignatureChecker {\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the\n     * signature is validated against that smart contract using ERC-1271, otherwise it's validated using `ECDSA.recover`.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\n        if (signer.code.length == 0) {\n            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);\n            return err == ECDSA.RecoverError.NoError && recovered == signer;\n        } else {\n            return isValidERC1271SignatureNow(signer, hash, signature);\n        }\n    }\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\n     * against the signer smart contract using ERC-1271.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidERC1271SignatureNow(\n        address signer,\n        bytes32 hash,\n        bytes memory signature\n    ) internal view returns (bool) {\n        (bool success, bytes memory result) = signer.staticcall(\n            abi.encodeCall(IERC1271.isValidSignature, (hash, signature))\n        );\n        return (success &&\n            result.length >= 32 &&\n            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)\n\npragma solidity ^0.8.20;\n\nimport {ERC20} from \"../ERC20.sol\";\nimport {Context} from \"../../../utils/Context.sol\";\n\n/**\n * @dev Extension of {ERC20} that allows token holders to destroy both their own\n * tokens and those that they have an allowance for, in a way that can be\n * recognized off-chain (via event analysis).\n */\nabstract contract ERC20Burnable is Context, ERC20 {\n    /**\n     * @dev Destroys a `value` amount of tokens from the caller.\n     *\n     * See {ERC20-_burn}.\n     */\n    function burn(uint256 value) public virtual {\n        _burn(_msgSender(), value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, deducting from\n     * the caller's allowance.\n     *\n     * See {ERC20-_burn} and {ERC20-allowance}.\n     *\n     * Requirements:\n     *\n     * - the caller must have allowance for ``accounts``'s tokens of at least\n     * `value`.\n     */\n    function burnFrom(address account, uint256 value) public virtual {\n        _spendAllowance(account, _msgSender(), value);\n        _burn(account, value);\n    }\n}\n"},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"prague","remappings":["frax-std/=node_modules/frax-standard-solidity/src/","@prb/math/=node_modules/@prb/math/","forge-std/=node_modules/forge-std/src/","ds-test/=node_modules/ds-test/src/","@openzeppelin/=node_modules/@openzeppelin/","solmate/=node_modules/solmate/src/","@fraxfinance/=node_modules/@fraxfinance/","@layerzerolabs/=node_modules/@layerzerolabs/","frax-standard-solidity/=node_modules/frax-standard-solidity/","hardhat-deploy/=node_modules/hardhat-deploy/","solidity-bytes-utils/=node_modules/solidity-bytes-utils/"]}},"stdJsonOutput":{"sources":{"src/contracts/fraxtal/shared/OwnedV2.sol":{"id":28},"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol":{"id":24},"src/contracts/shared/core/modules/PermitModule.sol":{"id":33},"src/contracts/fraxtal/shared/interfaces/ISemver.sol":{"id":31},"src/contracts/shared/core/modules/EIP3009Module.sol":{"id":32},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol":{"id":25},"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol":{"id":26},"src/contracts/shared/core/modules/SignatureModule.sol":{"id":34},"node_modules/@openzeppelin/contracts-5.2.0/utils/Panic.sol":{"id":10},"node_modules/@openzeppelin/contracts-5.2.0/utils/Nonces.sol":{"id":9},"node_modules/@openzeppelin/contracts-5.2.0/utils/Context.sol":{"id":8},"node_modules/@openzeppelin/contracts-5.2.0/utils/Strings.sol":{"id":13},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/Math.sol":{"id":18},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/ERC20.sol":{"id":2},"node_modules/@openzeppelin/contracts-5.2.0/utils/StorageSlot.sol":{"id":12},"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol":{"id":29},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol":{"id":3},"node_modules/@openzeppelin/contracts-5.2.0/utils/ShortStrings.sol":{"id":11},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/IERC5267.sol":{"id":0},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SafeCast.sol":{"id":19},"node_modules/@openzeppelin/contracts-5.3.0/interfaces/IERC1271.sol":{"id":21},"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol":{"id":30},"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SignedMath.sol":{"id":20},"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol":{"id":27},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/ECDSA.sol":{"id":14},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/ECDSA.sol":{"id":22},"node_modules/@openzeppelin/contracts-5.2.0/interfaces/draft-IERC6093.sol":{"id":1},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/EIP712.sol":{"id":15},"node_modules/@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol":{"id":17},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol":{"id":5},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Permit.sol":{"id":7},"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/MessageHashUtils.sol":{"id":16},"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol":{"id":23},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol":{"id":4},"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Metadata.sol":{"id":6}},"contracts":{"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol":{"SfrxUSD":{"abi":[{"type":"constructor","inputs":[{"name":"_bridge","type":"address","internalType":"address"},{"name":"_remoteToken","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"ERC2612ExpiredSignature","type":"error","inputs":[{"name":"deadline","type":"uint256","internalType":"uint256"}]},{"name":"ERC2612InvalidSigner","type":"error","inputs":[{"name":"signer","type":"address","internalType":"address"},{"name":"owner","type":"address","internalType":"address"}]},{"name":"ExpiredAuthorization","type":"error","inputs":[]},{"name":"InvalidAccountNonce","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"currentNonce","type":"uint256","internalType":"uint256"}]},{"name":"InvalidAuthorization","type":"error","inputs":[]},{"name":"InvalidOwnershipAcceptance","type":"error","inputs":[]},{"name":"InvalidPayee","type":"error","inputs":[{"name":"caller","type":"address","internalType":"address"},{"name":"payee","type":"address","internalType":"address"}]},{"name":"InvalidShortString","type":"error","inputs":[]},{"name":"InvalidSignature","type":"error","inputs":[]},{"name":"OnlyOwner","type":"error","inputs":[]},{"name":"OwnerCannotBeZero","type":"error","inputs":[]},{"name":"StringTooLong","type":"error","inputs":[{"name":"str","type":"string","internalType":"string"}]},{"name":"UsedOrCanceledAuthorization","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"AuthorizationCanceled","type":"event","inputs":[{"name":"authorizer","type":"address","indexed":true,"internalType":"address"},{"name":"nonce","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"AuthorizationUsed","type":"event","inputs":[{"name":"authorizer","type":"address","indexed":true,"internalType":"address"},{"name":"nonce","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"Burn","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"EIP712DomainChanged","type":"event","inputs":[],"anonymous":false},{"name":"Mint","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MinterAdded","type":"event","inputs":[{"name":"minter_address","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"MinterRemoved","type":"event","inputs":[{"name":"minter_address","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"OwnerChanged","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":false,"internalType":"address"},{"name":"newOwner","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"OwnerNominated","type":"event","inputs":[{"name":"newOwner","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"TimelockChanged","type":"event","inputs":[{"name":"timelock_address","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"TokenMinterBurned","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"}],"anonymous":false},{"name":"TokenMinterMinted","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"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"BRIDGE","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"REMOTE_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"addMinter","type":"function","inputs":[{"name":"minter_address","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"authorizationState","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"burn","type":"function","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burn","type":"function","inputs":[{"name":"_from","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burnFrom","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelAuthorization","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelAuthorization","type":"function","inputs":[{"name":"authorizer","type":"address","internalType":"address"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"eip712Domain","type":"function","inputs":[],"outputs":[{"name":"fields","type":"bytes1","internalType":"bytes1"},{"name":"name","type":"string","internalType":"string"},{"name":"version","type":"string","internalType":"string"},{"name":"chainId","type":"uint256","internalType":"uint256"},{"name":"verifyingContract","type":"address","internalType":"address"},{"name":"salt","type":"bytes32","internalType":"bytes32"},{"name":"extensions","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"name":"l1Token","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"l2Bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"_to","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"minter_burn_from","type":"function","inputs":[{"name":"b_address","type":"address","internalType":"address"},{"name":"b_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"minter_mint","type":"function","inputs":[{"name":"m_address","type":"address","internalType":"address"},{"name":"m_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"minters","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"minters_array","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"nominateNewOwner","type":"function","inputs":[{"name":"_owner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"nominatedOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"nonces","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"receiveWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"receiveWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"remoteToken","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"removeMinter","type":"function","inputs":[{"name":"minter_address","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setTimelock","type":"function","inputs":[{"name":"_timelock_address","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":"pure"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"timelock_address","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"signature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferWithAuthorization","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"validAfter","type":"uint256","internalType":"uint256"},{"name":"validBefore","type":"uint256","internalType":"uint256"},{"name":"nonce","type":"bytes32","internalType":"bytes32"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"version","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"}],"metadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_bridge\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_remoteToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"allowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"approver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidApprover\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidReceiver\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSpender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"}],\"name\":\"ERC2612ExpiredSignature\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"ERC2612InvalidSigner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExpiredAuthorization\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentNonce\",\"type\":\"uint256\"}],\"name\":\"InvalidAccountNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAuthorization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidOwnershipAcceptance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"InvalidPayee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidShortString\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OwnerCannotBeZero\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"}],\"name\":\"StringTooLong\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UsedOrCanceledAuthorization\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"authorizer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"}],\"name\":\"AuthorizationCanceled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"authorizer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"}],\"name\":\"AuthorizationUsed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Burn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EIP712DomainChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"minter_address\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"minter_address\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldOwner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnerChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnerNominated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"timelock_address\",\"type\":\"address\"}],\"name\":\"TimelockChanged\",\"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\"}],\"name\":\"TokenMinterBurned\",\"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\"}],\"name\":\"TokenMinterMinted\",\"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\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BRIDGE\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REMOTE_TOKEN\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"minter_address\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authorizer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"}],\"name\":\"authorizationState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authorizer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"cancelAuthorization\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authorizer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"cancelAuthorization\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"eip712Domain\",\"outputs\":[{\"internalType\":\"bytes1\",\"name\":\"fields\",\"type\":\"bytes1\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"verifyingContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"uint256[]\",\"name\":\"extensions\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1Token\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2Bridge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"b_address\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"b_amount\",\"type\":\"uint256\"}],\"name\":\"minter_burn_from\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"m_address\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"m_amount\",\"type\":\"uint256\"}],\"name\":\"minter_mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"minters\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"minters_array\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"nominateNewOwner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nominatedOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"permit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validAfter\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validBefore\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"receiveWithAuthorization\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validAfter\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validBefore\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"receiveWithAuthorization\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"remoteToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"minter_address\",\"type\":\"address\"}],\"name\":\"removeMinter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_timelock_address\",\"type\":\"address\"}],\"name\":\"setTimelock\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"_interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"timelock_address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validAfter\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validBefore\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"transferWithAuthorization\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validAfter\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"validBefore\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"nonce\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"transferWithAuthorization\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"ERC20InsufficientAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failure with the `spender`’s `allowance`. Used in transfers.\",\"params\":{\"allowance\":\"Amount of tokens a `spender` is allowed to operate with.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC20InsufficientBalance(address,uint256,uint256)\":[{\"details\":\"Indicates an error related to the current `balance` of a `sender`. Used in transfers.\",\"params\":{\"balance\":\"Current balance for the interacting account.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidApprover(address)\":[{\"details\":\"Indicates a failure with the `approver` of a token to be approved. Used in approvals.\",\"params\":{\"approver\":\"Address initiating an approval operation.\"}}],\"ERC20InvalidReceiver(address)\":[{\"details\":\"Indicates a failure with the token `receiver`. Used in transfers.\",\"params\":{\"receiver\":\"Address to which tokens are being transferred.\"}}],\"ERC20InvalidSender(address)\":[{\"details\":\"Indicates a failure with the token `sender`. Used in transfers.\",\"params\":{\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidSpender(address)\":[{\"details\":\"Indicates a failure with the `spender` to be approved. Used in approvals.\",\"params\":{\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC2612ExpiredSignature(uint256)\":[{\"details\":\"Permit deadline has expired.\"}],\"ERC2612InvalidSigner(address,address)\":[{\"details\":\"Mismatched signature.\"}],\"InvalidAccountNonce(address,uint256)\":[{\"details\":\"The nonce used for an `account` is not the expected current nonce.\"}],\"InvalidPayee(address,address)\":[{\"params\":{\"caller\":\"The caller of the function\",\"payee\":\"The expected payee in the function\"}}]},\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"AuthorizationCanceled(address,bytes32)\":{\"params\":{\"authorizer\":\"Authorizer's address\",\"nonce\":\"Nonce of the authorization\"}},\"AuthorizationUsed(address,bytes32)\":{\"params\":{\"authorizer\":\"Authorizer's address\",\"nonce\":\"Nonce of the authorization\"}},\"Burn(address,uint256)\":{\"params\":{\"account\":\"Address of the account tokens are being burned from\",\"amount\":\"Amount of tokens burned\"}},\"EIP712DomainChanged()\":{\"details\":\"MAY be emitted to signal that the domain could have changed.\"},\"Mint(address,uint256)\":{\"params\":{\"account\":\"Address of the account tokens are being minted for\",\"amount\":\"Amount of tokens minted.\"}},\"MinterAdded(address)\":{\"params\":{\"minter_address\":\"Address of the new minter\"}},\"MinterRemoved(address)\":{\"params\":{\"minter_address\":\"Address of the removed minter\"}},\"TimelockChanged(address)\":{\"params\":{\"timelock_address\":\"Address of the removed timelock\"}},\"TokenMinterBurned(address,address,uint256)\":{\"params\":{\"amount\":\"Amount of tokens burned\",\"from\":\"The account whose tokens are burned\",\"to\":\"The minter doing the burning\"}},\"TokenMinterMinted(address,address,uint256)\":{\"params\":{\"amount\":\"Amount of tokens minted\",\"from\":\"The minter doing the minting\",\"to\":\"The account that gets the newly minted tokens\"}},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"DOMAIN_SEPARATOR()\":{\"details\":\"Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\"},\"addMinter(address)\":{\"params\":{\"minter_address\":\"Address of minter to add\"}},\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"authorizationState(address,bytes32)\":{\"details\":\"Nonces are randomly generated 32-byte data unique to the authorizer's address\",\"params\":{\"authorizer\":\"Authorizer's address\",\"nonce\":\"Nonce of the authorization\"},\"returns\":{\"_0\":\"True if the nonce is used\"}},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"bridge()\":{\"custom:legacy\":\"@notice Legacy getter for BRIDGE\",\"returns\":{\"_0\":\"address The bridge address\"}},\"burn(address,uint256)\":{\"params\":{\"_amount\":\"Amount of tokens to burn.\",\"_from\":\"Address to burn tokens from.\"}},\"burn(uint256)\":{\"details\":\"Destroys a `value` amount of tokens from the caller. See {ERC20-_burn}.\"},\"burnFrom(address,uint256)\":{\"details\":\"Destroys a `value` amount of tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `value`.\"},\"cancelAuthorization(address,bytes32,bytes)\":{\"details\":\"EOA wallet signatures should be packed in the order of r, s, v\",\"params\":{\"authorizer\":\"Authorizer's address\",\"nonce\":\"Nonce of the authorization\",\"signature\":\"Signature byte array produced by an EOA wallet or a contract wallet\"}},\"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)\":{\"details\":\"EOA wallet signatures should be packed in the order of r, s, v\",\"params\":{\"authorizer\":\"Authorizer's address\",\"nonce\":\"Nonce of the authorization\",\"r\":\"ECDSA signature r value\",\"s\":\"ECDSA signature s value\",\"v\":\"ECDSA signature v value\"}},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"eip712Domain()\":{\"details\":\"See {IERC-5267}.\"},\"l1Token()\":{\"custom:legacy\":\"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.\",\"returns\":{\"_0\":\"address The L1 remote token address\"}},\"l2Bridge()\":{\"custom:legacy\":\"@notice Legacy getter for the bridge. Use BRIDGE going forward.\",\"returns\":{\"_0\":\"address The bridge address\"}},\"mint(address,uint256)\":{\"params\":{\"_amount\":\"Amount of tokens to mint.\",\"_to\":\"Address to mint tokens to.\"}},\"minter_burn_from(address,uint256)\":{\"params\":{\"b_address\":\"Address of the account to burn from\",\"b_amount\":\"Amount of tokens to burn\"}},\"minter_mint(address,uint256)\":{\"params\":{\"m_address\":\"Address of the account to mint to\",\"m_amount\":\"Amount of tokens to mint\"}},\"name()\":{\"details\":\"Returns the name of the token.\"},\"nonces(address)\":{\"details\":\"Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times.\"},\"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)\":{\"details\":\"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v\",\"params\":{\"from\":\"Payer's address (Authorizer)\",\"nonce\":\"Unique nonce\",\"signature\":\"Signature byte array produced by an EOA wallet or a contract wallet\",\"to\":\"Payee's address\",\"validAfter\":\"The block.timestamp after which the authorization is valid\",\"validBefore\":\"The block.timestamp before which the authorization is valid\",\"value\":\"Amount to be transferred\"}},\"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)\":{\"details\":\"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v\",\"params\":{\"from\":\"Payer's address (Authorizer)\",\"nonce\":\"Unique nonce\",\"r\":\"ECDSA signature parameters r\",\"s\":\"ECDSA signature parameters s\",\"to\":\"Payee's address\",\"v\":\"ECDSA signature parameter v\",\"validAfter\":\"The block.timestamp after which the authorization is valid\",\"validBefore\":\"The block.timestamp before which the authorization is valid\",\"value\":\"Amount to be transferred\"}},\"remoteToken()\":{\"custom:legacy\":\"@notice Legacy getter for REMOTE_TOKEN\",\"returns\":{\"_0\":\"address The L1 remote token address\"}},\"removeMinter(address)\":{\"params\":{\"minter_address\":\"Address of minter to remove\"}},\"setTimelock(address)\":{\"params\":{\"_timelock_address\":\"Address of the timelock\"}},\"supportsInterface(bytes4)\":{\"params\":{\"_interfaceId\":\"Interface ID to check.\"},\"returns\":{\"_0\":\"Whether or not the interface is supported by this contract.\"}},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`.\"},\"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)\":{\"details\":\"EOA wallet signatures should be packed in the order of r, s, v\",\"params\":{\"from\":\"Payer's address (Authorizer)\",\"nonce\":\"Unique nonce\",\"signature\":\"Signature byte array produced by an EOA wallet or a contract wallet\",\"to\":\"Payee's address\",\"validAfter\":\"The time after which this is valid (unix time)\",\"validBefore\":\"The time before which this is valid (unix time)\",\"value\":\"Amount to be transferred\"}},\"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)\":{\"details\":\"EOA wallet signatures should be packed in the order of r, s, vadded in v1.1.0\",\"params\":{\"from\":\"Payer's address (Authorizer)\",\"nonce\":\"Unique nonce\",\"r\":\"ECDSA signature parameters r\",\"s\":\"ECDSA signature parameters s\",\"to\":\"Payee's address\",\"v\":\"ECDSA signature parameter v\",\"validAfter\":\"The block.timestamp after which the authorization is valid\",\"validBefore\":\"The block.timestamp before which the authorization is valid\",\"value\":\"Amount to be transferred\"}}},\"version\":1},\"userdoc\":{\"errors\":{\"ExpiredAuthorization()\":[{\"notice\":\"The ```ExpiredAuthorization``` error is emitted when the authorization is expired\"}],\"InvalidAuthorization()\":[{\"notice\":\"The ```InvalidAuthorization``` error is emitted when the authorization is invalid because its too early\"}],\"InvalidPayee(address,address)\":[{\"notice\":\"The ```InvalidPayee``` error is emitted when the payee does not match sender in receiveWithAuthorization\"}],\"InvalidSignature()\":[{\"notice\":\"Error thrown when a signature is invalid\"}],\"UsedOrCanceledAuthorization()\":[{\"notice\":\"The ```UsedOrCanceledAuthorization``` error is emitted when the authorization nonce is already used or canceled\"}]},\"events\":{\"AuthorizationCanceled(address,bytes32)\":{\"notice\":\"```AuthorizationCanceled``` event is emitted when an authorization is canceled\"},\"AuthorizationUsed(address,bytes32)\":{\"notice\":\"```AuthorizationUsed``` event is emitted when an authorization is used\"},\"Burn(address,uint256)\":{\"notice\":\"Emitted whenever the bridge burns tokens from an account\"},\"Mint(address,uint256)\":{\"notice\":\"Emitted whenever the bridge mints tokens to an account\"},\"MinterAdded(address)\":{\"notice\":\"Emitted when a non-bridge minter is added\"},\"MinterRemoved(address)\":{\"notice\":\"Emitted when a non-bridge minter is removed\"},\"TimelockChanged(address)\":{\"notice\":\"Emitted when the timelock address changes\"},\"TokenMinterBurned(address,address,uint256)\":{\"notice\":\"Emitted when a non-bridge minter burns tokens\"},\"TokenMinterMinted(address,address,uint256)\":{\"notice\":\"Emitted when a non-bridge minter mints tokens\"}},\"kind\":\"user\",\"methods\":{\"BRIDGE()\":{\"notice\":\"Address of the L2 StandardBridge on this network.\"},\"REMOTE_TOKEN()\":{\"notice\":\"Address of the corresponding version of this token on the remote chain.\"},\"addMinter(address)\":{\"notice\":\"Adds a non-bridge minter\"},\"authorizationState(address,bytes32)\":{\"notice\":\"Returns the state of an authorization\"},\"burn(address,uint256)\":{\"notice\":\"Allows the StandardBridge on this network to burn tokens.\"},\"cancelAuthorization(address,bytes32,bytes)\":{\"notice\":\"The ```cancelAuthorization``` function cancels an authorization nonce\"},\"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)\":{\"notice\":\"The ```cancelAuthorization``` function cancels an authorization nonce\"},\"mint(address,uint256)\":{\"notice\":\"Allows the StandardBridge on this network to mint tokens.\"},\"minter_burn_from(address,uint256)\":{\"notice\":\"Used by non-bridge minters to burn tokens\"},\"minter_mint(address,uint256)\":{\"notice\":\"Used by non-bridge minters to mint new tokens\"},\"minters(address)\":{\"notice\":\"Mapping of the non-bridge minters\"},\"minters_array(uint256)\":{\"notice\":\"Array of the non-bridge minters\"},\"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)\":{\"notice\":\"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer\"},\"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)\":{\"notice\":\"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer\"},\"removeMinter(address)\":{\"notice\":\"Removes a non-bridge minter\"},\"setTimelock(address)\":{\"notice\":\"Sets the timelock address\"},\"supportsInterface(bytes4)\":{\"notice\":\"ERC165 interface check function.\"},\"timelock_address()\":{\"notice\":\"The timelock address\"},\"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)\":{\"notice\":\"The ```transferWithAuthorization``` function executes a transfer with a signed authorization\"},\"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)\":{\"notice\":\"The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol\":\"SfrxUSD\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@fraxfinance/=node_modules/@fraxfinance/\",\":@layerzerolabs/=node_modules/@layerzerolabs/\",\":@openzeppelin/=node_modules/@openzeppelin/\",\":@prb/math/=node_modules/@prb/math/\",\":ds-test/=node_modules/ds-test/src/\",\":forge-std/=node_modules/forge-std/src/\",\":frax-standard-solidity/=node_modules/frax-standard-solidity/\",\":frax-std/=node_modules/frax-standard-solidity/src/\",\":hardhat-deploy/=node_modules/hardhat-deploy/\",\":solidity-bytes-utils/=node_modules/solidity-bytes-utils/\",\":solmate/=node_modules/solmate/src/\"]},\"sources\":{\"node_modules/@openzeppelin/contracts-5.2.0/interfaces/IERC5267.sol\":{\"keccak256\":\"0x92aa1df62dc3d33f1656d63bede0923e0df0b706ad4137c8b10b0a8fe549fd92\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c5c0f29195ad64cbe556da8e257dac8f05f78c53f90323c0d2accf8e6922d33a\",\"dweb:/ipfs/QmQ61TED8uaCZwcbh8KkgRSsCav7x7HbcGHwHts3U4DmUP\"]},\"node_modules/@openzeppelin/contracts-5.2.0/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b\",\"dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz\"]},\"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/ERC20.sol\":{\"keccak256\":\"0x6ef9389a2c07bc40d8a7ba48914724ab2c108fac391ce12314f01321813e6368\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7a5cb39b1e6df68f4dd9a5e76e853d745a74ffb3dfd7df4ae4d2ace6992a171\",\"dweb:/ipfs/QmPbzKR19rdM8X3PLQjsmHRepUKhvoZnedSR63XyGtXZib\"]},\"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Burnable.sol\":{\"keccak256\":\"0x2659248df25e34000ed214b3dc8da2160bc39874c992b477d9e2b1b3283dc073\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c345af1b0e7ea28d1216d6a04ab28f5534a5229b9edf9ca3cd0e84950ae58d26\",\"dweb:/ipfs/QmY63jtSrYpLRe8Gj1ep2vMDCKxGNNG3hnNVKBVnrs2nmA\"]},\"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/ERC20Permit.sol\":{\"keccak256\":\"0xaa7f0646f49ebe2606eeca169f85c56451bbaeeeb06265fa076a03369a25d1d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ee931d4e832385765967efe6366dcc6d00d6a2d794f9c66ee38283c03882de9c\",\"dweb:/ipfs/QmR6SkuJGYxpQeLz38rBdghqaWqEPfzUsL9kBoXgEXKtbD\"]},\"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf\",\"dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r\"]},\"node_modules/@openzeppelin/contracts-5.2.0/token/ERC20/extensions/IERC20Permit.sol\":{\"keccak256\":\"0x27dbc90e5136ffe46c04f7596fc2dbcc3acebd8d504da3d93fdb8496e6de04f6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0ea8b92e4245d75a5579c10f22f118f7b4ba07c57341f181f0b2a85ff8663de3\",\"dweb:/ipfs/Qme3Ss5ByjmkxxkMdLpyu7fQ1PCtjNFH1wEFszt2BZePiG\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/Nonces.sol\":{\"keccak256\":\"0x0082767004fca261c332e9ad100868327a863a88ef724e844857128845ab350f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://132dce9686a54e025eb5ba5d2e48208f847a1ec3e60a3e527766d7bf53fb7f9e\",\"dweb:/ipfs/QmXn1a2nUZMpu2z6S88UoTfMVtY2YNh86iGrzJDYmMkKeZ\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/Panic.sol\":{\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a\",\"dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/ShortStrings.sol\":{\"keccak256\":\"0x7d94fa0af099a2172eb01f9c8a8a443cbe7e0e43654841563e4e09968efdb549\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://65e38fb76b6add407d4557753ae83dd1268e8261195dbe5c19a580d5ba6e4e9a\",\"dweb:/ipfs/QmTkGSJtaQrqjcyWM4AgemeEmKgtDydKPPVRajsUJRQSrK\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/StorageSlot.sol\":{\"keccak256\":\"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b\",\"dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/Strings.sol\":{\"keccak256\":\"0x44f87e91783e88415bde66f1a63f6c7f0076f2d511548820407d5c95643ac56c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://13a51bc2b23827744dcf5bad10c69e72528cf015a6fe48c93632cdb2c0eb1251\",\"dweb:/ipfs/QmZwPA47Yqgje1qtkdEFEja8ntTahMStYzKf5q3JRnaR7d\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/ECDSA.sol\":{\"keccak256\":\"0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9\",\"dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/EIP712.sol\":{\"keccak256\":\"0x10eb97d047f8d84fe263a02bb4a656ac6674f6679d74532cc37546289e073a9d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3e41287d40b0c46982f1083d40d32de2761f009c5c51627fe79a7feb0ab1cf5c\",\"dweb:/ipfs/Qme7dbh6HX3ZvUJdbQAcVqXkmyXyfcLiUZRhhon3cU6K8p\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/cryptography/MessageHashUtils.sol\":{\"keccak256\":\"0x4515543bc4c78561f6bea83ecfdfc3dead55bd59858287d682045b11de1ae575\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://60601f91440125727244fffd2ba84da7caafecaae0fd887c7ccfec678e02b61e\",\"dweb:/ipfs/QmZnKPBtVDiQS9Dp8gZ4sa3ZeTrWVfqF7yuUd6Y8hwm1Rs\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621\",\"dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/math/Math.sol\":{\"keccak256\":\"0xa00be322d7db5786750ce0ac7e2f5b633ac30a5ed5fa1ced1e74acfc19acecea\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6c84e822f87cbdc4082533b626667b6928715bb2b1e8e7eb96954cebb9e38c8d\",\"dweb:/ipfs/QmZmy9dgxLTerBAQDuuHqbL6EpgRxddqgv5KmwpXYVbKz1\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SafeCast.sol\":{\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8\",\"dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy\"]},\"node_modules/@openzeppelin/contracts-5.2.0/utils/math/SignedMath.sol\":{\"keccak256\":\"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03\",\"dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ\"]},\"node_modules/@openzeppelin/contracts-5.3.0/interfaces/IERC1271.sol\":{\"keccak256\":\"0x3d4cd07258d675b6dfa3d9dfd623a77b38fb9935f4a5381ff4bc969948720976\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://30abb60a4d98ad9a33de4fa5e9072342e12df3a79e9c71b5f59ce049ae8cd535\",\"dweb:/ipfs/QmT6NXJDjsf8H14nPYQsFELDB8q5ZTmG9cjdX2bEQJW7ST\"]},\"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/ECDSA.sol\":{\"keccak256\":\"0x69f54c02b7d81d505910ec198c11ed4c6a728418a868b906b4a0cf29946fda84\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8e25e4bdb7ae1f21d23bfee996e22736fc0ab44cfabedac82a757b1edc5623b9\",\"dweb:/ipfs/QmQdWQvB6JCP9ZMbzi8EvQ1PTETqkcTWrbcVurS7DKpa5n\"]},\"node_modules/@openzeppelin/contracts-5.3.0/utils/cryptography/SignatureChecker.sol\":{\"keccak256\":\"0xbdc3bb48ccedb818cd75a6d74a16df55a822e9f6d3cc54c59f576f10aab67b5f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2284f25f2478f419d7781573b17a89d0e7c5589a865d55e2d6ed5163aee23aa8\",\"dweb:/ipfs/QmNsr2625APBQiNKpYnX5VcSnYgfUHR9Uzzp9pRXjoDqK7\"]},\"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol\":{\"keccak256\":\"0x298baa4260a5ba2b0a0baa2beae061304876ebe1c7c0ea98d9f32e189d141b5b\",\"license\":\"AGPL-3.0-only\",\"urls\":[\"bzz-raw://91038044c8098c0d5b0ad6e845c37e2745d8e92a37eb5949a42f092265cd75ae\",\"dweb:/ipfs/QmZendXFL4aev48KuBQ2KmSagv7onYGtsHqKaZbcxCzpe5\"]},\"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD.sol\":{\"keccak256\":\"0xe1bb4c3a61b7e70641648e84fbe9cd615386b787063c550dabc0acae009ff434\",\"urls\":[\"bzz-raw://d0e39853e4595057958d622530be74565d106c606e99d6f659c7c260ec977fe9\",\"dweb:/ipfs/QmWLvWsWCstZxwjydQBNEPSQ3DmMrTUtMhS7fg6CEsHfbx\"]},\"src/contracts/fraxtal/sfrxUSD/versioning/SfrxUSD2.sol\":{\"keccak256\":\"0xaa1eb91fdb6e90504795c4c069920db013fcd2a4c979c17d5670e8723875e2a1\",\"license\":\"Unlicense\",\"urls\":[\"bzz-raw://d85cdd3721769775b202ad7ba100430d0e2b61c1642e0753bd15600974af9e50\",\"dweb:/ipfs/QmXT5iBLwEMN3Hhwn1SL4zjtbd54zM5cPzPTNQpkV9Eyre\"]},\"src/contracts/fraxtal/shared/ERC20PermitPermissionedOptiMintable.sol\":{\"keccak256\":\"0xd0d66ac4dcca2bfb1cd7265e657d9d958782c3bb575769384b913dc7c913c7c0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f0ee40e46efacb647a7e1f1cd9e8fc87a96e625689654de9118fea9cd2335a99\",\"dweb:/ipfs/Qmbp8TXbo9bd7PK3VVgpoftYuEGHxMCy5M9bPBj5GRUKVQ\"]},\"src/contracts/fraxtal/shared/OwnedV2.sol\":{\"keccak256\":\"0x8a2c8367bf46de70e490d08765334183bba588a712a12ca5671c560bbbc4e8c2\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://7fdbea3858e9e7d6cc576eea3fd1ecb610e1017eedcd8f97a6fb7b9fcd04249d\",\"dweb:/ipfs/QmcLTm4VwTTQ6mCjWULjDGrLo9Rvy86NPSbSuwynwTq1Ky\"]},\"src/contracts/fraxtal/shared/interfaces/ILegacyMintableERC20.sol\":{\"keccak256\":\"0x7f3398284404a2376940cd735506a97391281573c6336716ba76806611dceae6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f3b81ac99667950bcd372726d6a990162170271e62ed5564d85fe344b1fad01c\",\"dweb:/ipfs/QmZ6ZLeFbFk7kieyKkzssPLKr5h4PRYjRzxZUGobBesuqt\"]},\"src/contracts/fraxtal/shared/interfaces/IOptimismMintableERC20.sol\":{\"keccak256\":\"0x0109eb6a621adf3577dcada01635b14c858d0fb236658b98434980d120a9292f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1d7064404cfcbb7e104b8a4a57c35ef7ee933cc9e02e9378a246fef474587756\",\"dweb:/ipfs/QmXH7Bk8uFY1j5acrtve6BmZkBQedCnTKsVanVvbM3rTN8\"]},\"src/contracts/fraxtal/shared/interfaces/ISemver.sol\":{\"keccak256\":\"0xba34562a8026f59886d2e07d1d58d90b9691d00e0788c6263cef6c22740cab44\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0826f998632f83c103c3085bf2e872db79a69022b6d2e0444c83a64ca5283c2a\",\"dweb:/ipfs/QmcJ7PNqkAfKqbjFGRordtAg1v9DvcBSKvdTkVvciLyvQR\"]},\"src/contracts/shared/core/modules/EIP3009Module.sol\":{\"keccak256\":\"0x68c0357226167c19a589682ce6b7291d00091ea53217d696cb338161ef674cb4\",\"urls\":[\"bzz-raw://78a17e324dcb4a8c7577fef3d17f509753ff0cd1d90ac40b8edbb1a28b81bf81\",\"dweb:/ipfs/QmekMj1E8TTgJCdFjJ5YgxrVTMkddiDFA1JcxR2dxsphzA\"]},\"src/contracts/shared/core/modules/PermitModule.sol\":{\"keccak256\":\"0x7c7c9c25d9e2911231016ab9994b824385355fa674cec7e87dc9fc4f9b1a2e7c\",\"urls\":[\"bzz-raw://4f2d7b0c129ede9a986946669aa165a13aac32e14625e9c029924b2dc3315816\",\"dweb:/ipfs/QmT56QCgEEcF5gvaydm4xMrHV3j8DvnLZxx6UmMeM4fqcc\"]},\"src/contracts/shared/core/modules/SignatureModule.sol\":{\"keccak256\":\"0x46655ff89b4db9b4dc691272038b8df31830301296d6b6dd9f252f5ab95ec47a\",\"urls\":[\"bzz-raw://99a1e024c31ce44941c19afb4356a06be7470b513854c8b4151e0faaa5217ded\",\"dweb:/ipfs/QmbMnnmw3mZ1ADHiEhiqJZNsgUgYv3TVnAPRENkw4yQAfp\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"InvalidSignature()":[{"notice":"Error thrown when a signature is invalid"}],"ExpiredAuthorization()":[{"notice":"The ```ExpiredAuthorization``` error is emitted when the authorization is expired"}],"InvalidAuthorization()":[{"notice":"The ```InvalidAuthorization``` error is emitted when the authorization is invalid because its too early"}],"InvalidPayee(address,address)":[{"notice":"The ```InvalidPayee``` error is emitted when the payee does not match sender in receiveWithAuthorization"}],"UsedOrCanceledAuthorization()":[{"notice":"The ```UsedOrCanceledAuthorization``` error is emitted when the authorization nonce is already used or canceled"}]},"events":{"MinterAdded(address)":{"notice":"Emitted when a non-bridge minter is added"},"Burn(address,uint256)":{"notice":"Emitted whenever the bridge burns tokens from an account"},"Mint(address,uint256)":{"notice":"Emitted whenever the bridge mints tokens to an account"},"MinterRemoved(address)":{"notice":"Emitted when a non-bridge minter is removed"},"TimelockChanged(address)":{"notice":"Emitted when the timelock address changes"},"AuthorizationUsed(address,bytes32)":{"notice":"```AuthorizationUsed``` event is emitted when an authorization is used"},"AuthorizationCanceled(address,bytes32)":{"notice":"```AuthorizationCanceled``` event is emitted when an authorization is canceled"},"TokenMinterBurned(address,address,uint256)":{"notice":"Emitted when a non-bridge minter burns tokens"},"TokenMinterMinted(address,address,uint256)":{"notice":"Emitted when a non-bridge minter mints tokens"}},"methods":{"BRIDGE()":{"notice":"Address of the L2 StandardBridge on this network."},"REMOTE_TOKEN()":{"notice":"Address of the corresponding version of this token on the remote chain."},"minters(address)":{"notice":"Mapping of the non-bridge minters"},"addMinter(address)":{"notice":"Adds a non-bridge minter"},"timelock_address()":{"notice":"The timelock address"},"setTimelock(address)":{"notice":"Sets the timelock address"},"burn(address,uint256)":{"notice":"Allows the StandardBridge on this network to burn tokens."},"mint(address,uint256)":{"notice":"Allows the StandardBridge on this network to mint tokens."},"removeMinter(address)":{"notice":"Removes a non-bridge minter"},"minters_array(uint256)":{"notice":"Array of the non-bridge minters"},"supportsInterface(bytes4)":{"notice":"ERC165 interface check function."},"minter_mint(address,uint256)":{"notice":"Used by non-bridge minters to mint new tokens"},"minter_burn_from(address,uint256)":{"notice":"Used by non-bridge minters to burn tokens"},"authorizationState(address,bytes32)":{"notice":"Returns the state of an authorization"},"cancelAuthorization(address,bytes32,bytes)":{"notice":"The ```cancelAuthorization``` function cancels an authorization nonce"},"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```cancelAuthorization``` function cancels an authorization nonce"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"notice":"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"notice":"The ```transferWithAuthorization``` function executes a transfer with a signed authorization"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"notice":"The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009"}},"version":1},"devdoc":{"kind":"dev","errors":{"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"InvalidPayee(address,address)":[{"params":{"payee":"The expected payee in the function","caller":"The caller of the function"}}],"ERC2612ExpiredSignature(uint256)":[{"details":"Permit deadline has expired."}],"InvalidAccountNonce(address,uint256)":[{"details":"The nonce used for an `account` is not the expected current nonce."}],"ERC2612InvalidSigner(address,address)":[{"details":"Mismatched signature."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"MinterAdded(address)":{"params":{"minter_address":"Address of the new minter"}},"Burn(address,uint256)":{"params":{"amount":"Amount of tokens burned","account":"Address of the account tokens are being burned from"}},"EIP712DomainChanged()":{"details":"MAY be emitted to signal that the domain could have changed."},"Mint(address,uint256)":{"params":{"amount":"Amount of tokens minted.","account":"Address of the account tokens are being minted for"}},"MinterRemoved(address)":{"params":{"minter_address":"Address of the removed minter"}},"TimelockChanged(address)":{"params":{"timelock_address":"Address of the removed timelock"}},"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."},"AuthorizationUsed(address,bytes32)":{"params":{"nonce":"Nonce of the authorization","authorizer":"Authorizer's address"}},"AuthorizationCanceled(address,bytes32)":{"params":{"nonce":"Nonce of the authorization","authorizer":"Authorizer's address"}},"TokenMinterBurned(address,address,uint256)":{"params":{"to":"The minter doing the burning","from":"The account whose tokens are burned","amount":"Amount of tokens burned"}},"TokenMinterMinted(address,address,uint256)":{"params":{"to":"The account that gets the newly minted tokens","from":"The minter doing the minting","amount":"Amount of tokens minted"}}},"methods":{"name()":{"details":"Returns the name of the token."},"bridge()":{"returns":{"_0":"address The bridge address"},"custom:legacy":"@notice Legacy getter for BRIDGE"},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"l1Token()":{"returns":{"_0":"address The L1 remote token address"},"custom:legacy":"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"l2Bridge()":{"returns":{"_0":"address The bridge address"},"custom:legacy":"@notice Legacy getter for the bridge. Use BRIDGE going forward."},"burn(uint256)":{"details":"Destroys a `value` amount of tokens from the caller. See {ERC20-_burn}."},"remoteToken()":{"returns":{"_0":"address The L1 remote token address"},"custom:legacy":"@notice Legacy getter for REMOTE_TOKEN"},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"eip712Domain()":{"details":"See {IERC-5267}."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times."},"DOMAIN_SEPARATOR()":{"details":"Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}."},"addMinter(address)":{"params":{"minter_address":"Address of minter to add"}},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"setTimelock(address)":{"params":{"_timelock_address":"Address of the timelock"}},"burn(address,uint256)":{"params":{"_from":"Address to burn tokens from.","_amount":"Amount of tokens to burn."}},"mint(address,uint256)":{"params":{"_to":"Address to mint tokens to.","_amount":"Amount of tokens to mint."}},"removeMinter(address)":{"params":{"minter_address":"Address of minter to remove"}},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"burnFrom(address,uint256)":{"details":"Destroys a `value` amount of tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `value`."},"supportsInterface(bytes4)":{"params":{"_interfaceId":"Interface ID to check."},"returns":{"_0":"Whether or not the interface is supported by this contract."}},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"minter_mint(address,uint256)":{"params":{"m_amount":"Amount of tokens to mint","m_address":"Address of the account to mint to"}},"minter_burn_from(address,uint256)":{"params":{"b_amount":"Amount of tokens to burn","b_address":"Address of the account to burn from"}},"authorizationState(address,bytes32)":{"params":{"nonce":"Nonce of the authorization","authorizer":"Authorizer's address"},"details":"Nonces are randomly generated 32-byte data unique to the authorizer's address","returns":{"_0":"True if the nonce is used"}},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."},"cancelAuthorization(address,bytes32,bytes)":{"params":{"nonce":"Nonce of the authorization","signature":"Signature byte array produced by an EOA wallet or a contract wallet","authorizer":"Authorizer's address"},"details":"EOA wallet signatures should be packed in the order of r, s, v"},"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)":{"params":{"r":"ECDSA signature r value","s":"ECDSA signature s value","v":"ECDSA signature v value","nonce":"Nonce of the authorization","authorizer":"Authorizer's address"},"details":"EOA wallet signatures should be packed in the order of r, s, v"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"params":{"to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","signature":"Signature byte array produced by an EOA wallet or a contract wallet","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid"},"details":"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)":{"params":{"to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","signature":"Signature byte array produced by an EOA wallet or a contract wallet","validAfter":"The time after which this is valid (unix time)","validBefore":"The time before which this is valid (unix time)"},"details":"EOA wallet signatures should be packed in the order of r, s, v"},"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"params":{"r":"ECDSA signature parameters r","s":"ECDSA signature parameters s","v":"ECDSA signature parameter v","to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid"},"details":"This has an additional check to ensure that the payee's address matches the caller of this function to prevent front-running attacksEOA wallet signatures should be packed in the order of r, s, v"},"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)":{"params":{"r":"ECDSA signature parameters r","s":"ECDSA signature parameters s","v":"ECDSA signature parameter v","to":"Payee's address","from":"Payer's address (Authorizer)","nonce":"Unique nonce","value":"Amount to be transferred","validAfter":"The block.timestamp after which the authorization is valid","validBefore":"The block.timestamp before which the authorization is valid"},"details":"EOA wallet signatures should be packed in the order of r, s, vadded in v1.1.0"}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_array(t_address)dyn_storage":{"base":"t_address","label":"address[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":184,"label":"_balances","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":190,"label":"_allowances","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"2","type":"t_uint256","astId":192,"label":"_totalSupply","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"3","type":"t_string_storage","astId":194,"label":"_name","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"4","type":"t_string_storage","astId":196,"label":"_symbol","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"5","type":"t_string_storage","astId":3092,"label":"_nameFallback","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"6","type":"t_string_storage","astId":3094,"label":"_versionFallback","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"7","type":"t_mapping(t_address,t_uint256)","astId":1060,"label":"_nonces","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"8","type":"t_address","astId":8093,"label":"owner","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"9","type":"t_address","astId":8095,"label":"nominatedOwner","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"10","type":"t_address","astId":7621,"label":"timelock_address","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"11","type":"t_array(t_address)dyn_storage","astId":7631,"label":"minters_array","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"},{"slot":"12","type":"t_mapping(t_address,t_bool)","astId":7636,"label":"minters","offset":0,"contract":"src/contracts/fraxtal/sfrxUSD/SfrxUSD.sol:SfrxUSD"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"967:122:24:-:0;;;1002:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1062:7;1071:12;808:1:26;820;824:7;833:12;742:16:25;772:17;803:7;824:12;2356:385:27;;;;;;;;;;;;;-1:-1:-1;;;2356:385:27;;;;;;;;;;;;;;;;-1:-1:-1;;;2356:385:27;;;2607:16;2592:5;1616:4:5;3328:431:15;;;;;;;;;;;;;-1:-1:-1;;;3328:431:15;;;2564:5:27;2571:7;1675:5:2;1667;:13;;;;;;:::i;:::-;-1:-1:-1;1690:7:2;:17;1700:7;1690;:17;:::i;:::-;-1:-1:-1;3401:45:15;;-1:-1:-1;3401:4:15;;-1:-1:-1;3432:13:15;3401:30;:45::i;:::-;3393:53;;3467:51;:7;3501:16;3467:33;:51::i;:::-;3456:62;;3542:22;;;;;;;;;;3528:36;;3591:25;;;;;;3574:42;;3644:13;3627:30;;3692:23;4226:11;;4239:14;;4204:80;;;2079:95;4204:80;;;3699:25:35;3740:18;;;3733:34;;;;3783:18;;;3776:34;4255:13:15;3826:18:35;;;3819:34;4278:4:15;3869:19:35;;;3862:61;4168:7:15;;3671:19:35;;4204:80:15;;;;;;;;;;;;4194:91;;;;;;4187:98;;4113:179;;3692:23;3667:48;;-1:-1:-1;;3747:4:15;3725:27;;-1:-1:-1;;;;;;409:20:28;;405:52;;438:19;;-1:-1:-1;;;438:19:28;;;;;;;;;;;405:52;467:5;:14;;-1:-1:-1;;;;;;467:14:28;-1:-1:-1;;;;;467:14:28;;;;;;;;496:32;;;-1:-1:-1;3309:51:35;;3391:2;3376:18;;3369:60;;;;496:32:28;;3282:18:35;496:32:28;;;;;;;-1:-1:-1;;;;;;;;2635:27:27;;::::3;;::::0;2672:16;;::::3;;::::0;2698::::3;:36:::0;;-1:-1:-1;;;;;;2698:36:27::3;::::0;;;::::3;::::0;;;::::3;::::0;;-1:-1:-1;967:122:24;;-1:-1:-1;;;;;;;;967:122:24;2887:340:11;2983:11;3032:2;3016:5;3010:19;:24;3006:215;;;3057:20;3071:5;3057:13;:20::i;:::-;3050:27;;;;3006:215;3134:5;3108:46;3149:5;3134;3108:46;:::i;:::-;-1:-1:-1;1390:66:11;;-1:-1:-1;3006:215:11;2887:340;;;;:::o;1708:286::-;1773:11;1796:17;1822:3;1796:30;;1854:2;1840:4;:11;:16;1836:72;;;1893:3;1879:18;;-1:-1:-1;;;1879:18:11;;;;;;;;:::i;:::-;;;;;;;;1836:72;1974:11;;1957:13;1974:4;1957:13;:::i;:::-;1949:36;;1708:286;-1:-1:-1;;;1708:286:11:o;14:177:35:-;93:13;;-1:-1:-1;;;;;135:31:35;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;494:127::-;555:10;550:3;546:20;543:1;536:31;586:4;583:1;576:15;610:4;607:1;600:15;626:380;705:1;701:12;;;;748;;;769:61;;823:4;815:6;811:17;801:27;;769:61;876:2;868:6;865:14;845:18;842:38;839:161;;922:10;917:3;913:20;910:1;903:31;957:4;954:1;947:15;985:4;982:1;975:15;839:161;;626:380;;;:::o;1137:518::-;1239:2;1234:3;1231:11;1228:421;;;1275:5;1272:1;1265:16;1319:4;1316:1;1306:18;1389:2;1377:10;1373:19;1370:1;1366:27;1360:4;1356:38;1425:4;1413:10;1410:20;1407:47;;;-1:-1:-1;1448:4:35;1407:47;1503:2;1498:3;1494:12;1491:1;1487:20;1481:4;1477:31;1467:41;;1558:81;1576:2;1569:5;1566:13;1558:81;;;1635:1;1621:16;;1602:1;1591:13;1558:81;;;1562:3;;1228:421;1137:518;;;:::o;1831:1299::-;1951:10;;-1:-1:-1;;;;;1973:30:35;;1970:56;;;2006:18;;:::i;:::-;2035:97;2125:6;2085:38;2117:4;2111:11;2085:38;:::i;:::-;2079:4;2035:97;:::i;:::-;2181:4;2212:2;2201:14;;2229:1;2224:649;;;;2917:1;2934:6;2931:89;;;-1:-1:-1;2986:19:35;;;2980:26;2931:89;-1:-1:-1;;1788:1:35;1784:11;;;1780:24;1776:29;1766:40;1812:1;1808:11;;;1763:57;3033:81;;2194:930;;2224:649;1084:1;1077:14;;;1121:4;1108:18;;-1:-1:-1;;2260:20:35;;;2378:222;2392:7;2389:1;2386:14;2378:222;;;2474:19;;;2468:26;2453:42;;2581:4;2566:20;;;;2534:1;2522:14;;;;2408:12;2378:222;;;2382:3;2628:6;2619:7;2616:19;2613:201;;;2689:19;;;2683:26;-1:-1:-1;;2772:1:35;2768:14;;;2784:3;2764:24;2760:37;2756:42;2741:58;2726:74;;2613:201;-1:-1:-1;;;;2860:1:35;2844:14;;;2840:22;2827:36;;-1:-1:-1;1831:1299:35:o;3934:418::-;4083:2;4072:9;4065:21;4046:4;4115:6;4109:13;4158:6;4153:2;4142:9;4138:18;4131:34;4217:6;4212:2;4204:6;4200:15;4195:2;4184:9;4180:18;4174:50;4273:1;4268:2;4259:6;4248:9;4244:22;4240:31;4233:42;4343:2;4336;4332:7;4327:2;4319:6;4315:15;4311:29;4300:9;4296:45;4292:54;4284:62;;;3934:418;;;;:::o;4357:297::-;4475:12;;4522:4;4511:16;;;4505:23;;4475:12;4540:16;;4537:111;;;-1:-1:-1;;4614:4:35;4610:17;;;;4607:1;4603:25;4599:38;4588:50;;4357:297;-1:-1:-1;4357:297:35:o;:::-;967:122:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"967:122:24:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4511:519:27;;;;;;:::i;:::-;;:::i;:::-;;;470:14:35;;463:22;445:41;;433:2;418:18;4511:519:27;;;;;;;;1714:37;;;;;;;;-1:-1:-1;;;;;661:32:35;;;643:51;;631:2;616:18;1714:37:27;497:203:35;1779:89:2;;;:::i;:::-;;;;;;;:::i;3998:186::-;;;;;;:::i;:::-;;:::i;541:138:28:-;;;;;;:::i;:::-;;:::i;:::-;;2849:97:2;2927:12;;2849:97;;;2044:25:35;;;2032:2;2017:18;2849:97:2;1898:177:35;4776:244:2;;;;;;:::i;:::-;;:::i;7267:684:27:-;;;;;;:::i;:::-;;:::i;2707:82:2:-;;;2780:2;2601:36:35;;2589:2;2574:18;2707:82:2;2459:184:35;2659:112:5;;;:::i;5272:218:27:-;;;;;;:::i;:::-;;:::i;618:87:4:-;;;;;;:::i;:::-;;:::i;260:29:28:-;;;;;-1:-1:-1;;;;;260:29:28;;;640:95:26;714:14;;;;;;;;;;;;-1:-1:-1;;;714:14:26;;;;640:95;;8614:220:32;;;;;;:::i;:::-;;:::i;6519:191:27:-;;;;;;:::i;:::-;;:::i;3004:116:2:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3095:18:2;3069:7;3095:18;;;;;;;;;;;;3004:116;6144:199:27;;;;;;:::i;:::-;;:::i;685:348:28:-;;;:::i;1021:158:4:-;;;;;;:::i;:::-;;:::i;2409:143:5:-;;;;;;:::i;:::-;;:::i;5144:557:15:-;;;:::i;:::-;;;;;;;;;;;;;:::i;7107:1079:32:-;;;;;;:::i;:::-;;:::i;234:20:28:-;;;;;-1:-1:-1;;;;;234:20:28;;;1981:93:2;;;:::i;6812:347:27:-;;;;;;:::i;:::-;;:::i;5671:224::-;;;;;;:::i;:::-;;:::i;1164:517:33:-;;;;;;:::i;:::-;;:::i;3315:178:2:-;;;;;;:::i;:::-;;:::i;3841:80:27:-;3908:6;3841:80;;9205:554:32;;;;;;:::i;:::-;;:::i;8126:245:27:-;;;;;;:::i;:::-;;:::i;3612:85::-;3678:12;3612:85;;3943:995:32;;;;;;:::i;:::-;;:::i;1818:360:26:-;;;;;;:::i;:::-;;:::i;1806:30:27:-;;;;;;:::i;:::-;;:::i;1484:31::-;;;;;-1:-1:-1;;;;;1484:31:27;;;3551:140:2;;;;;;:::i;:::-;-1:-1:-1;;;;;3657:18:2;;;3631:7;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3551:140;2779:569:32;;;;;;:::i;:::-;;:::i;11562:181::-;;;;;;:::i;:::-;-1:-1:-1;;;;;11671:58:32;;;;11648:4;11671:58;;;-1:-1:-1;;;;;;;;;;;11671:58:32;;;;;;;;:65;;;;;;;;;;;11562:181;1588:31:27;;;;;5761:567:32;;;;;;:::i;:::-;;:::i;1946:39:27:-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;4511:519;4590:4;-1:-1:-1;;;;;;;;;;;;;;;4949:22:27;;;;;:48;;-1:-1:-1;;;;;;;4975:22:27;;;;;;;4949:48;:74;;;-1:-1:-1;;;;;;;5001:22:27;;;;;;;4949:74;4942:81;4511:519;-1:-1:-1;;;;;4511:519:27:o;1779:89:2:-;1824:13;1856:5;1849:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89;:::o;3998:186::-;4071:4;735:10:8;4125:31:2;735:10:8;4141:7:2;4150:5;4125:8;:31::i;:::-;4173:4;4166:11;;;3998:186;;;;;:::o;541:138:28:-;1180:5;;-1:-1:-1;;;;;1180:5:28;1166:10;:19;1162:43;;1194:11;;-1:-1:-1;;;1194:11:28;;;;;;;;;;;1162:43;612:14:::1;:23:::0;;-1:-1:-1;;;;;;612:23:28::1;-1:-1:-1::0;;;;;612:23:28;::::1;::::0;;::::1;::::0;;;650:22:::1;::::0;643:51:35;;;650:22:28::1;::::0;631:2:35;616:18;650:22:28::1;;;;;;;;541:138:::0;:::o;4776:244:2:-;4863:4;735:10:8;4919:37:2;4935:4;735:10:8;4950:5:2;4919:15;:37::i;:::-;4966:26;4976:4;4982:2;4986:5;4966:9;:26::i;:::-;5009:4;5002:11;;;4776:244;;;;;;:::o;7267:684:27:-;2933:16;;-1:-1:-1;;;;;2933:16:27;2919:10;:30;;:53;;-1:-1:-1;2967:5:27;;-1:-1:-1;;;;;2967:5:27;2953:10;:19;2919:53;2911:87;;;;-1:-1:-1;;;2911:87:27;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;7351:28:27;::::1;7343:62;;;;-1:-1:-1::0;;;7343:62:27::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7423:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:31;;:23:::0;:31:::1;7415:64;;;::::0;-1:-1:-1;;;7415:64:27;;11842:2:35;7415:64:27::1;::::0;::::1;11824:21:35::0;11881:2;11861:18;;;11854:30;-1:-1:-1;;;11900:18:35;;;11893:50;11960:18;;7415:64:27::1;11640:344:35::0;7415:64:27::1;-1:-1:-1::0;;;;;7532:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;7525:30;;-1:-1:-1;;7525:30:27::1;::::0;;7631:269:::1;7655:13;:20:::0;7651:24;::::1;7631:269;;;7720:14;-1:-1:-1::0;;;;;7700:34:27::1;:13;7714:1;7700:16;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;7700:16:27::1;:34:::0;7696:194:::1;;7781:1;7754:13;7768:1;7754:16;;;;;;;;:::i;:::-;;;;;;;;;:29;;;;;-1:-1:-1::0;;;;;7754:29:27::1;;;;;-1:-1:-1::0;;;;;7754:29:27::1;;;;;;7870:5;;7696:194;7677:3;;7631:269;;;-1:-1:-1::0;7915:29:27::1;::::0;-1:-1:-1;;;;;661:32:35;;643:51;;7915:29:27::1;::::0;631:2:35;616:18;7915:29:27::1;497:203:35::0;2659:112:5;2718:7;2744:20;:18;:20::i;:::-;2737:27;;2659:112;:::o;5272:218:27:-;3306:10;-1:-1:-1;;;;;3320:6:27;3306:20;;3298:85;;;;-1:-1:-1;;;3298:85:27;;;;;;;:::i;:::-;5431:19:::1;5437:3;5442:7;5431:5;:19::i;:::-;5470:3;-1:-1:-1::0;;;;;5465:18:27::1;;5475:7;5465:18;;;;2044:25:35::0;;2032:2;2017:18;;1898:177;5465:18:27::1;;;;;;;;5272:218:::0;;:::o;618:87:4:-;672:26;735:10:8;692:5:4;672;:26::i;:::-;618:87;:::o;8614:220:32:-;8728:99;8762:10;8781:5;8816:1;8819;8822;8799:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;8728:19;:99::i;:::-;8614:220;;;;;:::o;6519:191:27:-;3143:10;3135:19;;;;:7;:19;;;;;;;;:27;;:19;:27;3127:52;;;;-1:-1:-1;;;3127:52:27;;13087:2:35;3127:52:27;;;13069:21:35;13126:2;13106:18;;;13099:30;-1:-1:-1;;;13145:18:35;;;13138:42;13197:18;;3127:52:27;12885:336:35;3127:52:27;6606:32:::1;6618:9;6629:8;6606:11;:32::i;:::-;6653:50;::::0;2044:25:35;;;-1:-1:-1;;;;;6653:50:27;::::1;::::0;6671:10:::1;::::0;6653:50:::1;::::0;2032:2:35;2017:18;6653:50:27::1;;;;;;;;6519:191:::0;;:::o;6144:199::-;3143:10;3135:19;;;;:7;:19;;;;;;;;:27;;:19;:27;3127:52;;;;-1:-1:-1;;;3127:52:27;;13087:2:35;3127:52:27;;;13069:21:35;13126:2;13106:18;;;13099:30;-1:-1:-1;;;13145:18:35;;;13138:42;13197:18;;3127:52:27;12885:336:35;3127:52:27;6236:35:::1;6251:9;6262:8;6236:14;:35::i;:::-;6286:50;::::0;2044:25:35;;;6315:10:27::1;::::0;-1:-1:-1;;;;;6286:50:27;::::1;::::0;::::1;::::0;2032:2:35;2017:18;6286:50:27::1;1898:177:35::0;685:348:28;856:14;;-1:-1:-1;;;;;856:14:28;842:10;:28;838:69;;879:28;;-1:-1:-1;;;879:28:28;;;;;;;;;;;838:69;935:5;;942:14;;922:35;;;-1:-1:-1;;;;;935:5:28;;;13400:51:35;;942:14:28;;;;13482:2:35;13467:18;;13460:60;922:35:28;;13373:18:35;922:35:28;;;;;;;975:14;;;967:5;:22;;-1:-1:-1;;;;;;967:22:28;;;-1:-1:-1;;;;;975:14:28;;967:22;;;;999:27;;;685:348::o;1021:158:4:-;1096:45;1112:7;735:10:8;1135:5:4;1096:15;:45::i;:::-;1151:21;1157:7;1166:5;1151;:21::i;:::-;1021:158;;:::o;2409:143:5:-;-1:-1:-1;;;;;624:14:9;;2500:7:5;624:14:9;;;:7;:14;;;;;;2526:19:5;538:107:9;5144:557:15;5242:13;5269:18;5301:21;5336:15;5365:25;5404:12;5430:27;5533:13;:11;:13::i;:::-;5560:16;:14;:16::i;:::-;5668;;;5652:1;5668:16;;;;;;;;;-1:-1:-1;;;5482:212:15;;;-1:-1:-1;5482:212:15;;-1:-1:-1;5590:13:15;;-1:-1:-1;5625:4:15;;-1:-1:-1;5652:1:15;-1:-1:-1;5668:16:15;-1:-1:-1;5482:212:15;-1:-1:-1;5144:557:15:o;7107:1079:32:-;-1:-1:-1;;;;;7387:16:32;;7393:10;7387:16;7383:76;;7412:47;;-1:-1:-1;;;7412:47:32;;7435:10;7412:47;;;13400:51:35;-1:-1:-1;;;;;13487:32:35;;13467:18;;;13460:60;13373:18;;7412:47:32;13226:300:35;7383:76:32;7492:10;7473:15;:29;7469:64;;7511:22;;-1:-1:-1;;;7511:22:32;;;;;;;;;;;7469:64;7566:11;7547:15;:30;7543:65;;7586:22;;-1:-1:-1;;;7586:22:32;;;;;;;;;;;7543:65;7618:63;7660:4;7673:5;7618:27;:63::i;:::-;7727:262;7777:4;837:66;7845:35;;7882:4;7888:2;7892:5;7899:10;7911:11;7924:5;7834:96;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;7807:137;;;;;;7969:9;7727:27;:262::i;:::-;8060:60;8099:4;8112:5;8060:24;:60::i;:::-;8130:49;8149:4;8159:2;8171:5;8130:10;:49::i;:::-;;7107:1079;;;;;;;:::o;1981:93:2:-;2028:13;2060:7;2053:14;;;;;:::i;6812:347:27:-;2933:16;;-1:-1:-1;;;;;2933:16:27;2919:10;:30;;:53;;-1:-1:-1;2967:5:27;;-1:-1:-1;;;;;2967:5:27;2953:10;:19;2919:53;2911:87;;;;-1:-1:-1;;;2911:87:27;;;;;;;:::i;:::-;-1:-1:-1;;;;;6893:28:27;::::1;6885:62;;;;-1:-1:-1::0;;;6885:62:27::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6966:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;;::::1;;:32;6958:67;;;::::0;-1:-1:-1;;;6958:67:27;;14397:2:35;6958:67:27::1;::::0;::::1;14379:21:35::0;14436:2;14416:18;;;14409:30;-1:-1:-1;;;14455:18:35;;;14448:52;14517:18;;6958:67:27::1;14195:346:35::0;6958:67:27::1;-1:-1:-1::0;;;;;7035:23:27;::::1;;::::0;;;:7:::1;:23;::::0;;;;;;;:30;;-1:-1:-1;;7035:30:27::1;7061:4;7035:30:::0;;::::1;::::0;;;7075:13:::1;:34:::0;;;;::::1;::::0;;;;;;;;::::1;::::0;;-1:-1:-1;;;;;;7075:34:27::1;::::0;::::1;::::0;;7125:27;;643:51:35;;;7125:27:27::1;::::0;616:18:35;7125:27:27::1;497:203:35::0;5671:224:27;3306:10;-1:-1:-1;;;;;3320:6:27;3306:20;;3298:85;;;;-1:-1:-1;;;3298:85:27;;;;;;;:::i;:::-;5832:21:::1;5838:5;5845:7;5832:5;:21::i;:::-;5873:5;-1:-1:-1::0;;;;;5868:20:27::1;;5880:7;5868:20;;;;2044:25:35::0;;2032:2;2017:18;;1898:177;1164:517:33;1367:8;1348:15;:27;;1340:64;;;;-1:-1:-1;;;1340:64:33;;14748:2:35;1340:64:33;;;14730:21:35;14787:2;14767:18;;;14760:30;14826:26;14806:18;;;14799:54;14870:18;;1340:64:33;14546:348:35;1340:64:33;1415:216;1465:5;480:95;1534:5;1541:7;1550:5;1557:17;1568:5;1557:10;:17::i;:::-;1506:79;;;;;;15186:25:35;;;;-1:-1:-1;;;;;15247:32:35;;;15227:18;;;15220:60;15316:32;;;;15296:18;;;15289:60;15365:18;;;15358:34;15408:19;;;15401:35;15452:19;;;15445:35;;;15158:19;;1506:79:33;14899:587:35;1415:216:33;1642:32;1652:5;1659:7;1668:5;1642:9;:32::i;3315:178:2:-;3384:4;735:10:8;3438:27:2;735:10:8;3455:2:2;3459:5;3438:9;:27::i;9205:554:32:-;9310:69;9352:10;9371:5;9310:27;:69::i;:::-;9485:60;;;1059:66;9485:60;;;15693:25:35;-1:-1:-1;;;;;15754:32:35;;15734:18;;;15727:60;;;;15803:18;;;15796:34;;;9389:202:32;;9439:10;;15666:18:35;;9485:60:32;15491:345:35;9389:202:32;-1:-1:-1;;;;;9602:58:32;;:46;:58;;;-1:-1:-1;;;;;;;;;;;9602:58:32;;;;;;;;:65;;;;;;;;;:72;;-1:-1:-1;;9602:72:32;9670:4;9602:72;;;9689:63;9602:65;;:58;9689:63;;;9205:554;;;:::o;8126:245:27:-;2933:16;;-1:-1:-1;;;;;2933:16:27;2919:10;:30;;:53;;-1:-1:-1;2967:5:27;;-1:-1:-1;;;;;2967:5:27;2953:10;:19;2919:53;2911:87;;;;-1:-1:-1;;;2911:87:27;;;;;;;:::i;:::-;-1:-1:-1;;;;;8212:31:27;::::1;8204:65;;;;-1:-1:-1::0;;;8204:65:27::1;;;;;;;:::i;:::-;8279:16;:36:::0;;-1:-1:-1;;;;;;8279:36:27::1;-1:-1:-1::0;;;;;8279:36:27;::::1;::::0;;::::1;::::0;;;8330:34:::1;::::0;643:51:35;;;8330:34:27::1;::::0;631:2:35;616:18;8330:34:27::1;497:203:35::0;3943:995:32;4243:10;4224:15;:29;4220:64;;4262:22;;-1:-1:-1;;;4262:22:32;;;;;;;;;;;4220:64;4317:11;4298:15;:30;4294:65;;4337:22;;-1:-1:-1;;;4337:22:32;;;;;;;;;;;4294:65;4369:63;4411:4;4424:5;4369:27;:63::i;:::-;4478:263;4528:4;546:66;4596:36;;4634:4;4640:2;4644:5;4651:10;4663:11;4676:5;4585:97;;;;;;;;;;;;;;:::i;1818:360:26:-;2064:107;2093:5;2109:7;2125:5;2142:8;2155:1;2161;2167;2064:19;:107::i;:::-;1818:360;;;;;;;:::o;1806:30:27:-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1806:30:27;;-1:-1:-1;1806:30:27;:::o;2779:569:32:-;3084:257;3130:4;3152:2;3175:5;3206:10;3243:11;3275:5;3322:1;3325;3328;3305:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3084;:257::i;:::-;2779:569;;;;;;;;;:::o;5761:567::-;6065:256;6110:4;6132:2;6155:5;6186:10;6223:11;6255:5;6302:1;6305;6308;6285:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;6065:24;:256::i;8726:128:2:-;8810:37;8819:5;8826:7;8835:5;8842:4;8810:8;:37::i;:::-;8726:128;;;:::o;10415:476::-;-1:-1:-1;;;;;3657:18:2;;;10514:24;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;10580:36:2;;10576:309;;;10655:5;10636:16;:24;10632:130;;;10687:60;;-1:-1:-1;;;10687:60:2;;-1:-1:-1;;;;;16061:32:35;;10687:60:2;;;16043:51:35;16110:18;;;16103:34;;;16153:18;;;16146:34;;;16016:18;;10687:60:2;15841:345:35;10632:130:2;10803:57;10812:5;10819:7;10847:5;10828:16;:24;10854:5;10803:8;:57::i;:::-;10504:387;10415:476;;;:::o;5393:300::-;-1:-1:-1;;;;;5476:18:2;;5472:86;;5517:30;;-1:-1:-1;;;5517:30:2;;5544:1;5517:30;;;643:51:35;616:18;;5517:30:2;497:203:35;5472:86:2;-1:-1:-1;;;;;5571:16:2;;5567:86;;5610:32;;-1:-1:-1;;;5610:32:2;;5639:1;5610:32;;;643:51:35;616:18;;5610:32:2;497:203:35;5567:86:2;5662:24;5670:4;5676:2;5680:5;5662:7;:24::i;3845:262:15:-;3898:7;3929:4;-1:-1:-1;;;;;3938:11:15;3921:28;;:63;;;;;3970:14;3953:13;:31;3921:63;3917:184;;;-1:-1:-1;4007:22:15;;3845:262::o;3917:184::-;4067:23;4204:80;;;2079:95;4204:80;;;16677:25:35;4226:11:15;16718:18:35;;;16711:34;;;;4239:14:15;16761:18:35;;;16754:34;4255:13:15;16804:18:35;;;16797:34;4278:4:15;16847:19:35;;;16840:61;4168:7:15;;16649:19:35;;4204:80:15;;;;;;;;;;;;4194:91;;;;;;4187:98;;4113:179;;7458:208:2;-1:-1:-1;;;;;7528:21:2;;7524:91;;7572:32;;-1:-1:-1;;;7572:32:2;;7601:1;7572:32;;;643:51:35;616:18;;7572:32:2;497:203:35;7524:91:2;7624:35;7640:1;7644:7;7653:5;7624:7;:35::i;7984:206::-;-1:-1:-1;;;;;8054:21:2;;8050:89;;8098:30;;-1:-1:-1;;;8098:30:2;;8125:1;8098:30;;;643:51:35;616:18;;8098:30:2;497:203:35;8050:89:2;8148:35;8156:7;8173:1;8177:5;8148:7;:35::i;6021:126:15:-;6067:13;6099:41;:5;6126:13;6099:26;:41::i;6473:135::-;6522:13;6554:47;:8;6584:16;6554:29;:47::i;10174:233:32:-;-1:-1:-1;;;;;;;;;;;;;;;;10273:58:32;;:46;:58;;;;;;;;;;;:65;;;;;;;;;;10269:132;;;10361:29;;-1:-1:-1;;;10361:29:32;;;;;;;;;;;538:373:34;677:191;740:6;770:45;802:10;770:17;:45::i;:::-;844:9;677:36;:191::i;:::-;659:245;;886:18;;-1:-1:-1;;;886:18:34;;;;;;;;;;;10821:240:32;-1:-1:-1;;;;;10908:58:32;;:46;:58;;;-1:-1:-1;;;;;;;;;;;10908:58:32;;;;;;;;:65;;;;;;;;;:72;;-1:-1:-1;;10908:72:32;10976:4;10908:72;;;10995:59;10908:65;;:58;10995:59;;;10821:240;;:::o;1035:166:26:-;1124:4;1140:33;1156:4;1162:2;1166:6;1140:15;:33::i;:::-;-1:-1:-1;1190:4:26;1035:166;;;;;:::o;1537:132::-;-1:-1:-1;;;;;1121:14:9;;1613:7:26;1121:14:9;;;:7;:14;;;;;:16;;;;;;;;1639:23:26;759:395:9;1377:154:26;1486:38;1501:5;1508:7;1517:6;1486:14;:38::i;770:388:33:-;969:182;997:5;1025:7;1053:5;1082:8;1132:1;1135;1138;1115:25;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;969:6;:182::i;9701:432:2:-;-1:-1:-1;;;;;9813:19:2;;9809:89;;9855:32;;-1:-1:-1;;;9855:32:2;;9884:1;9855:32;;;643:51:35;616:18;;9855:32:2;497:203:35;9809:89:2;-1:-1:-1;;;;;9911:21:2;;9907:90;;9955:31;;-1:-1:-1;;;9955:31:2;;9983:1;9955:31;;;643:51:35;616:18;;9955:31:2;497:203:35;9907:90:2;-1:-1:-1;;;;;10006:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;10051:76;;;;10101:7;-1:-1:-1;;;;;10085:31:2;10094:5;-1:-1:-1;;;;;10085:31:2;;10110:5;10085:31;;;;2044:25:35;;2032:2;2017:18;;1898:177;10085:31:2;;;;;;;;9701:432;;;;:::o;6008:1107::-;-1:-1:-1;;;;;6097:18:2;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:2;;-1:-1:-1;6093:540:2;;-1:-1:-1;;;;;6307:15:2;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;-1:-1:-1;;;6386:50:2;;-1:-1:-1;;;;;16061:32:35;;6386:50:2;;;16043:51:35;16110:18;;;16103:34;;;16153:18;;;16146:34;;;16016:18;;6386:50:2;15841:345:35;6336:115:2;-1:-1:-1;;;;;6571:15:2;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;-1:-1:-1;;;;;6647:16:2;;6643:425;;6810:12;:21;;;;;;;6643:425;;;-1:-1:-1;;;;;7021:13:2;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;-1:-1:-1;;;;;7083:25:2;7092:4;-1:-1:-1;;;;;7083:25:2;;7102:5;7083:25;;;;2044::35;;2032:2;2017:18;;1898:177;7083:25:2;;;;;;;;6008:1107;;;:::o;3358:267:11:-;3452:13;1390:66;3481:46;;3477:142;;3550:15;3559:5;3550:8;:15::i;:::-;3543:22;;;;3477:142;3603:5;3596:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1207:164:26;1303:7;1329:35;1353:10;1329:23;:35::i;1041:429:23:-;1147:4;1167:6;-1:-1:-1;;;;;1167:18:23;;1189:1;1167:23;1163:301;;1207:17;1226:22;1254:33;1271:4;1277:9;1254:16;:33::i;:::-;-1:-1:-1;1206:81:23;;-1:-1:-1;1206:81:23;-1:-1:-1;1315:26:23;1308:3;:33;;;;;;;;:::i;:::-;;:56;;;;;1358:6;-1:-1:-1;;;;;1345:19:23;:9;-1:-1:-1;;;;;1345:19:23;;1308:56;1301:63;;;;;;1163:301;1402:51;1429:6;1437:4;1443:9;1402:26;:51::i;:::-;1395:58;;;;2078:378:11;2137:13;2162:11;2176:16;2187:4;2176:10;:16::i;:::-;2300:14;;;2311:2;2300:14;;;;;;;;;2162:30;;-1:-1:-1;2280:17:11;;2300:14;;;;;;;;;-1:-1:-1;;;2363:16:11;;;-1:-1:-1;2408:4:11;2399:14;;2392:28;;;;-1:-1:-1;2363:16:11;2078:378::o;4917:176:15:-;4994:7;5020:66;5053:20;:18;:20::i;:::-;5075:10;3501:4:16;3495:11;-1:-1:-1;;;3519:23:16;;3571:4;3562:14;;3555:39;;;;3623:4;3614:14;;3607:34;3679:4;3664:20;;;3326:374;2129:778:22;2232:17;2251:16;2269:14;2299:9;:16;2319:2;2299:22;2295:606;;2604:4;2589:20;;2583:27;2653:4;2638:20;;2632:27;2710:4;2695:20;;2689:27;2337:9;2681:36;2751:25;2762:4;2681:36;2583:27;2632;2751:10;:25::i;:::-;2744:32;;;;;;;;;;;2295:606;-1:-1:-1;;2872:16:22;;2823:1;;-1:-1:-1;2827:35:22;;2295:606;2129:778;;;;;:::o;1877:458:23:-;2020:4;2037:12;2051:19;2074:6;-1:-1:-1;;;;;2074:17:23;2148:4;2154:9;2105:60;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;2105:60:23;;;;;;;;;;;;;;-1:-1:-1;;;;;2105:60:23;-1:-1:-1;;;2105:60:23;;;2074:101;;;2105:60;2074:101;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2036:139;;;;2193:7;:42;;;;;2233:2;2216:6;:13;:19;;2193:42;:134;;;;-1:-1:-1;2251:29:23;;-1:-1:-1;;;2292:34:23;2251:29;;;;;;;;;;;;:::i;:::-;:76;2193:134;2185:143;1877:458;-1:-1:-1;;;;;;1877:458:23:o;2528:245:11:-;2589:7;2661:4;2625:40;;2688:2;2679:11;;2675:69;;;2713:20;;-1:-1:-1;;;2713:20:11;;;;;;;;;;;5203:1551:22;5329:17;;;6283:66;6270:79;;6266:164;;;-1:-1:-1;6381:1:22;;-1:-1:-1;6385:30:22;;-1:-1:-1;6417:1:22;6365:54;;6266:164;6541:24;;;6524:14;6541:24;;;;;;;;;18060:25:35;;;18133:4;18121:17;;18101:18;;;18094:45;;;;18155:18;;;18148:34;;;18198:18;;;18191:34;;;6541:24:22;;18032:19:35;;6541:24:22;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6541:24:22;;-1:-1:-1;;6541:24:22;;;-1:-1:-1;;;;;;;6579:20:22;;6575:113;;-1:-1:-1;6631:1:22;;-1:-1:-1;6635:29:22;;-1:-1:-1;6631:1:22;;-1:-1:-1;6615:62:22;;6575:113;6706:6;-1:-1:-1;6714:20:22;;-1:-1:-1;6714:20:22;;-1:-1:-1;5203:1551:22;;;;;;;;;:::o;14:286:35:-;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:35;;209:43;;199:71;;266:1;263;256:12;705:289;747:3;785:5;779:12;812:6;807:3;800:19;868:6;861:4;854:5;850:16;843:4;838:3;834:14;828:47;920:1;913:4;904:6;899:3;895:16;891:27;884:38;983:4;976:2;972:7;967:2;959:6;955:15;951:29;946:3;942:39;938:50;931:57;;;705:289;;;;:::o;999:220::-;1148:2;1137:9;1130:21;1111:4;1168:45;1209:2;1198:9;1194:18;1186:6;1168:45;:::i;1224:173::-;1292:20;;-1:-1:-1;;;;;1341:31:35;;1331:42;;1321:70;;1387:1;1384;1377:12;1321:70;1224:173;;;:::o;1402:300::-;1470:6;1478;1531:2;1519:9;1510:7;1506:23;1502:32;1499:52;;;1547:1;1544;1537:12;1499:52;1570:29;1589:9;1570:29;:::i;:::-;1560:39;1668:2;1653:18;;;;1640:32;;-1:-1:-1;;;1402:300:35:o;1707:186::-;1766:6;1819:2;1807:9;1798:7;1794:23;1790:32;1787:52;;;1835:1;1832;1825:12;1787:52;1858:29;1877:9;1858:29;:::i;2080:374::-;2157:6;2165;2173;2226:2;2214:9;2205:7;2201:23;2197:32;2194:52;;;2242:1;2239;2232:12;2194:52;2265:29;2284:9;2265:29;:::i;:::-;2255:39;;2313:38;2347:2;2336:9;2332:18;2313:38;:::i;:::-;2080:374;;2303:48;;-1:-1:-1;;;2420:2:35;2405:18;;;;2392:32;;2080:374::o;2830:226::-;2889:6;2942:2;2930:9;2921:7;2917:23;2913:32;2910:52;;;2958:1;2955;2948:12;2910:52;-1:-1:-1;3003:23:35;;2830:226;-1:-1:-1;2830:226:35:o;3061:156::-;3127:20;;3187:4;3176:16;;3166:27;;3156:55;;3207:1;3204;3197:12;3222:612;3315:6;3323;3331;3339;3347;3400:3;3388:9;3379:7;3375:23;3371:33;3368:53;;;3417:1;3414;3407:12;3368:53;3440:29;3459:9;3440:29;:::i;:::-;3430:39;-1:-1:-1;3538:2:35;3523:18;;3510:32;;-1:-1:-1;3585:36:35;3617:2;3602:18;;3585:36;:::i;:::-;3222:612;;;;-1:-1:-1;3575:46:35;;3694:2;3679:18;;3666:32;;-1:-1:-1;3797:3:35;3782:19;3769:33;;3222:612;-1:-1:-1;;3222:612:35:o;3839:1238::-;4245:3;4240;4236:13;4228:6;4224:26;4213:9;4206:45;4287:3;4282:2;4271:9;4267:18;4260:31;4187:4;4314:46;4355:3;4344:9;4340:19;4332:6;4314:46;:::i;:::-;4408:9;4400:6;4396:22;4391:2;4380:9;4376:18;4369:50;4442:33;4468:6;4460;4442:33;:::i;:::-;4506:2;4491:18;;4484:34;;;-1:-1:-1;;;;;4555:32:35;;4549:3;4534:19;;4527:61;4575:3;4604:19;;4597:35;;;4669:22;;;4663:3;4648:19;;4641:51;4741:13;;4763:22;;;4813:2;4839:15;;;;-1:-1:-1;4801:15:35;;;;-1:-1:-1;4882:169:35;4896:6;4893:1;4890:13;4882:169;;;4957:13;;4945:26;;5000:2;5026:15;;;;4991:12;;;;4918:1;4911:9;4882:169;;;-1:-1:-1;5068:3:35;;3839:1238;-1:-1:-1;;;;;;;;;;;3839:1238:35:o;5082:127::-;5143:10;5138:3;5134:20;5131:1;5124:31;5174:4;5171:1;5164:15;5198:4;5195:1;5188:15;5214:725;5256:5;5309:3;5302:4;5294:6;5290:17;5286:27;5276:55;;5327:1;5324;5317:12;5276:55;5367:6;5354:20;5397:18;5389:6;5386:30;5383:56;;;5419:18;;:::i;:::-;5468:2;5462:9;5560:2;5522:17;;-1:-1:-1;;5518:31:35;;;5551:2;5514:40;5510:54;5498:67;;5595:18;5580:34;;5616:22;;;5577:62;5574:88;;;5642:18;;:::i;:::-;5678:2;5671:22;5702;;;5743:19;;;5764:4;5739:30;5736:39;-1:-1:-1;5733:59:35;;;5788:1;5785;5778:12;5733:59;5852:6;5845:4;5837:6;5833:17;5826:4;5818:6;5814:17;5801:58;5907:1;5879:19;;;5900:4;5875:30;5868:41;;;;5883:6;5214:725;-1:-1:-1;;;5214:725:35:o;5944:946::-;6066:6;6074;6082;6090;6098;6106;6114;6167:3;6155:9;6146:7;6142:23;6138:33;6135:53;;;6184:1;6181;6174:12;6135:53;6207:29;6226:9;6207:29;:::i;:::-;6197:39;;6255:38;6289:2;6278:9;6274:18;6255:38;:::i;:::-;6245:48;-1:-1:-1;6362:2:35;6347:18;;6334:32;;-1:-1:-1;6463:2:35;6448:18;;6435:32;;-1:-1:-1;6566:3:35;6551:19;;6538:33;;-1:-1:-1;6670:3:35;6655:19;;6642:33;;-1:-1:-1;6752:3:35;6737:19;;6724:33;6780:18;6769:30;;6766:50;;;6812:1;6809;6802:12;6766:50;6835:49;6876:7;6867:6;6856:9;6852:22;6835:49;:::i;:::-;6825:59;;;5944:946;;;;;;;;;;:::o;6895:704::-;6999:6;7007;7015;7023;7031;7084:3;7072:9;7063:7;7059:23;7055:33;7052:53;;;7101:1;7098;7091:12;7052:53;7124:29;7143:9;7124:29;:::i;:::-;7114:39;;7172:38;7206:2;7195:9;7191:18;7172:38;:::i;:::-;7162:48;-1:-1:-1;7279:2:35;7264:18;;7251:32;;-1:-1:-1;7380:2:35;7365:18;;7352:32;;-1:-1:-1;7461:3:35;7446:19;;7433:33;7489:18;7478:30;;7475:50;;;7521:1;7518;7511:12;7475:50;7544:49;7585:7;7576:6;7565:9;7561:22;7544:49;:::i;:::-;7534:59;;;6895:704;;;;;;;;:::o;7604:508::-;7690:6;7698;7706;7759:2;7747:9;7738:7;7734:23;7730:32;7727:52;;;7775:1;7772;7765:12;7727:52;7798:29;7817:9;7798:29;:::i;:::-;7788:39;-1:-1:-1;7896:2:35;7881:18;;7868:32;;-1:-1:-1;7975:2:35;7960:18;;7947:32;8002:18;7991:30;;7988:50;;;8034:1;8031;8024:12;7988:50;8057:49;8098:7;8089:6;8078:9;8074:22;8057:49;:::i;:::-;8047:59;;;7604:508;;;;;:::o;8117:808::-;8228:6;8236;8244;8252;8260;8268;8276;8329:3;8317:9;8308:7;8304:23;8300:33;8297:53;;;8346:1;8343;8336:12;8297:53;8369:29;8388:9;8369:29;:::i;:::-;8359:39;;8417:38;8451:2;8440:9;8436:18;8417:38;:::i;:::-;8407:48;-1:-1:-1;8524:2:35;8509:18;;8496:32;;-1:-1:-1;8625:2:35;8610:18;;8597:32;;-1:-1:-1;8674:37:35;8706:3;8691:19;;8674:37;:::i;:::-;8117:808;;;;-1:-1:-1;8117:808:35;;;;8664:47;8784:3;8769:19;;8756:33;;-1:-1:-1;8888:3:35;8873:19;;;8860:33;;8117:808;-1:-1:-1;;8117:808:35:o;8930:260::-;8998:6;9006;9059:2;9047:9;9038:7;9034:23;9030:32;9027:52;;;9075:1;9072;9065:12;9027:52;9098:29;9117:9;9098:29;:::i;:::-;9088:39;;9146:38;9180:2;9169:9;9165:18;9146:38;:::i;:::-;9136:48;;8930:260;;;;;:::o;9195:1050::-;9324:6;9332;9340;9348;9356;9364;9372;9380;9388;9441:3;9429:9;9420:7;9416:23;9412:33;9409:53;;;9458:1;9455;9448:12;9409:53;9481:29;9500:9;9481:29;:::i;:::-;9471:39;;9529:38;9563:2;9552:9;9548:18;9529:38;:::i;:::-;9519:48;-1:-1:-1;9636:2:35;9621:18;;9608:32;;-1:-1:-1;9737:2:35;9722:18;;9709:32;;-1:-1:-1;9840:3:35;9825:19;;9812:33;;-1:-1:-1;9944:3:35;9929:19;;9916:33;;-1:-1:-1;9994:37:35;10026:3;10011:19;;9994:37;:::i;:::-;9195:1050;;;;-1:-1:-1;9195:1050:35;;;;;;;;-1:-1:-1;9984:47:35;;10104:3;10089:19;;10076:33;;-1:-1:-1;10208:3:35;10193:19;10180:33;;9195:1050;-1:-1:-1;9195:1050:35:o;10555:380::-;10634:1;10630:12;;;;10677;;;10698:61;;10752:4;10744:6;10740:17;10730:27;;10698:61;10805:2;10797:6;10794:14;10774:18;10771:38;10768:161;;10851:10;10846:3;10842:20;10839:1;10832:31;10886:4;10883:1;10876:15;10914:4;10911:1;10904:15;10768:161;;10555:380;;;:::o;10940:345::-;11142:2;11124:21;;;11181:2;11161:18;;;11154:30;-1:-1:-1;;;11215:2:35;11200:18;;11193:51;11276:2;11261:18;;10940:345::o;11290:::-;11492:2;11474:21;;;11531:2;11511:18;;;11504:30;-1:-1:-1;;;11565:2:35;11550:18;;11543:51;11626:2;11611:18;;11290:345::o;11989:127::-;12050:10;12045:3;12041:20;12038:1;12031:31;12081:4;12078:1;12071:15;12105:4;12102:1;12095:15;12121:416;12323:2;12305:21;;;12362:2;12342:18;;;12335:30;12401:34;12396:2;12381:18;;12374:62;-1:-1:-1;;;12467:2:35;12452:18;;12445:50;12527:3;12512:19;;12121:416::o;12542:338::-;12723:19;;;12767:2;12758:12;;12751:28;;;;12835:3;12813:16;-1:-1:-1;;;;;;12809:36:35;12804:2;12795:12;;12788:58;12871:2;12862:12;;12542:338::o;13531:659::-;13846:25;;;-1:-1:-1;;;;;13907:32:35;;;13902:2;13887:18;;13880:60;13976:32;;;;13971:2;13956:18;;13949:60;14040:2;14025:18;;14018:34;;;;14083:3;14068:19;;14061:35;13927:3;14112:19;;14105:35;;;;14171:3;14156:19;;14149:35;13833:3;13818:19;;13531:659::o;16191:222::-;16256:9;;;16277:10;;;16274:133;;;16329:10;16324:3;16320:20;16317:1;16310:31;16364:4;16361:1;16354:15;16392:4;16389:1;16382:15;16912:127;16973:10;16968:3;16964:20;16961:1;16954:31;17004:4;17001:1;16994:15;17028:4;17025:1;17018:15;17044:289;17219:6;17208:9;17201:25;17262:2;17257;17246:9;17242:18;17235:30;17182:4;17282:45;17323:2;17312:9;17308:18;17300:6;17282:45;:::i;:::-;17274:53;17044:289;-1:-1:-1;;;;17044:289:35:o;17338:301::-;17467:3;17505:6;17499:13;17551:6;17544:4;17536:6;17532:17;17527:3;17521:37;17613:1;17577:16;;17602:13;;;-1:-1:-1;17577:16:35;17338:301;-1:-1:-1;17338:301:35:o;17644:184::-;17714:6;17767:2;17755:9;17746:7;17742:23;17738:32;17735:52;;;17783:1;17780;17773:12;17735:52;-1:-1:-1;17806:16:35;;17644:184;-1:-1:-1;17644:184:35:o","linkReferences":{},"immutableReferences":{"3076":[{"start":5367,"length":32}],"3078":[{"start":5325,"length":32}],"3080":[{"start":5283,"length":32}],"3082":[{"start":5448,"length":32}],"3084":[{"start":5488,"length":32}],"3087":[{"start":5679,"length":32}],"3090":[{"start":5724,"length":32}],"7624":[{"start":1261,"length":32},{"start":1597,"length":32},{"start":2575,"length":32},{"start":4005,"length":32}],"7627":[{"start":679,"length":32},{"start":1337,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"acceptOwnership()","signatureHash4":"0x79ba5097","signatureHash32":"0x79ba5097e5519a381a52113cdcc59540d13f73fd9d26abc0453484a096cc96f2"},{"signature":"addMinter(address)","signatureHash4":"0x983b2d56","signatureHash32":"0x983b2d560bdd6b422e26073d9516b4646e2f1008810070c0d32b3a79aaa7bfcb"},{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"authorizationState(address,bytes32)","signatureHash4":"0xe94a0102","signatureHash32":"0xe94a01021b10fecb63ece0bf4b7b317de9b2ed3f95ec63d5cf2ec09837349b6a"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"bridge()","signatureHash4":"0xe78cea92","signatureHash32":"0xe78cea9276765c085f40dfc1acfb8c748bac2eb031044e073a06f8562ad2ba65"},{"signature":"BRIDGE()","signatureHash4":"0xee9a31a2","signatureHash32":"0xee9a31a2cb6c4e1a108a4a67391630acc74557bc8b2129bc49ef46b277810c42"},{"signature":"burn(address,uint256)","signatureHash4":"0x9dc29fac","signatureHash32":"0x9dc29fac0ba6d4fc521c69c2b0c636d612e3343bc39ed934429b8876b0d12cba"},{"signature":"burnFrom(address,uint256)","signatureHash4":"0x79cc6790","signatureHash32":"0x79cc679044ee9a2021f0a26c0fdec02ac39179cd005bb971a471b7f9f17c576c"},{"signature":"burn(uint256)","signatureHash4":"0x42966c68","signatureHash32":"0x42966c689b5afe9b9b3f8a7103b2a19980d59629bfd6a20a60972312ed41d836"},{"signature":"cancelAuthorization(address,bytes32,bytes)","signatureHash4":"0xb7b72899","signatureHash32":"0xb7b72899416d28dfc782ee211deb51fbe3fed063e9870420bbc9cccc4bb92dff"},{"signature":"cancelAuthorization(address,bytes32,uint8,bytes32,bytes32)","signatureHash4":"0x5a049a70","signatureHash32":"0x5a049a7028da11cfeb40b878a857a28ca100bffc9061ac4b1bd4f8b3b1519d81"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"DOMAIN_SEPARATOR()","signatureHash4":"0x3644e515","signatureHash32":"0x3644e5157256d68e3eeedd2ead302507a9c4ffaff665547d2c3623a1e9e7edf4"},{"signature":"eip712Domain()","signatureHash4":"0x84b0196e","signatureHash32":"0x84b0196e4b78e1918928c3b71e1f57a2bfc6d4a368fe07990ccc1367172719fb"},{"signature":"l1Token()","signatureHash4":"0xc01e1bd6","signatureHash32":"0xc01e1bd6212b650615429a817de7fdd3b8129e26fe14d7af04abc0f7938b6524"},{"signature":"l2Bridge()","signatureHash4":"0xae1f6aaf","signatureHash32":"0xae1f6aafc9bf00ee23f65a47aec3e701b5332b15de243985c0e7aad934fbd4f3"},{"signature":"mint(address,uint256)","signatureHash4":"0x40c10f19","signatureHash32":"0x40c10f19c047ae7dfa66d6312b683d2ea3dfbcb4159e96b967c5f4b0a86f2842"},{"signature":"minter_burn_from(address,uint256)","signatureHash4":"0x7941bc89","signatureHash32":"0x7941bc89caae52233ed86af15b4930e7f5589b6d1af6503c867b800915e94c97"},{"signature":"minter_mint(address,uint256)","signatureHash4":"0x6a257ebc","signatureHash32":"0x6a257ebca492ad46d5203cc175da971bf1657722caec8b8f560041a508fa20ee"},{"signature":"minters(address)","signatureHash4":"0xf46eccc4","signatureHash32":"0xf46eccc402b44d9ce1af4da593481651b579b67f96bf4fa42ffd1cd02cb607e6"},{"signature":"minters_array(uint256)","signatureHash4":"0xd73ced04","signatureHash32":"0xd73ced04519edd8ac761d0f3852e73077ba9a0d9275f2b3823a9dd4f6cf0c460"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"nominatedOwner()","signatureHash4":"0x53a47bb7","signatureHash32":"0x53a47bb79acf26a4de73afba7a6fff829a2380759ade7bd8a4ca127bc3007c7f"},{"signature":"nominateNewOwner(address)","signatureHash4":"0x1627540c","signatureHash32":"0x1627540cc178caab4661e580a239b00ea32d3aa8a814cb2d31a0bf0dd1f1912a"},{"signature":"nonces(address)","signatureHash4":"0x7ecebe00","signatureHash32":"0x7ecebe00bc8d5df94a191da8e29b79e67a22b668e14b756a81ef2f5fa215cb0c"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"permit(address,address,uint256,uint256,bytes)","signatureHash4":"0x9fd5a6cf","signatureHash32":"0x9fd5a6cfd207f3e5388ccd6e1d9553f6e4afcfab1a85fed0329b9fae4139729b"},{"signature":"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)","signatureHash4":"0xd505accf","signatureHash32":"0xd505accfee7b46ac3ce97322c21f328b64073d188137e16f7ef87f8de076b51c"},{"signature":"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)","signatureHash4":"0x88b7ab63","signatureHash32":"0x88b7ab637aab73fe4e8f6fc8239e6f4181b53b059ba1653e04733fedaae54b62"},{"signature":"receiveWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)","signatureHash4":"0xef55bec6","signatureHash32":"0xef55bec64c1b5e56fa55bf6fadef0c52f48dd76ef00b8c9aa8f691622a47968b"},{"signature":"remoteToken()","signatureHash4":"0xd6c0b2c4","signatureHash32":"0xd6c0b2c4d7fd1c589fefd4962a0d738630107cb39528e6d90d41ea80a18cdd71"},{"signature":"REMOTE_TOKEN()","signatureHash4":"0x033964be","signatureHash32":"0x033964bec26d1249411942f23a2f2bb73ee16fc0e305eb62c142229369de6f45"},{"signature":"removeMinter(address)","signatureHash4":"0x3092afd5","signatureHash32":"0x3092afd5301157b753073c7ad0be8f571723d525a965784cda36e0fef2c3a548"},{"signature":"setTimelock(address)","signatureHash4":"0xbdacb303","signatureHash32":"0xbdacb30307800cfcc634ddf0105e72067f913751739987c6890e8687e50c40af"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"timelock_address()","signatureHash4":"0xdc6663c7","signatureHash32":"0xdc6663c7382126ebe6a7f3cb1e4c4d3fc67e60d3044ad4dadcdc918b12ced95f"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,bytes)","signatureHash4":"0xcf092995","signatureHash32":"0xcf0929959cbb5cf6cbabf0040caaba467e6b80f7f57b4b347a4937d343b75f4d"},{"signature":"transferWithAuthorization(address,address,uint256,uint256,uint256,bytes32,uint8,bytes32,bytes32)","signatureHash4":"0xe3ee160e","signatureHash32":"0xe3ee160ec5755e52a4395e859cd6f0106f00d60ec090d99a386e4b56cc89934f"},{"signature":"version()","signatureHash4":"0x54fd4d50","signatureHash32":"0x54fd4d50fce680dbc2593d9e893064bfa880e5642d0036394e1a1849f7fc0749"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"AuthorizationCanceled(address,bytes32)","signatureHash4":"0x1cdd46ff","signatureHash32":"0x1cdd46ff242716cdaa72d159d339a485b3438398348d68f09d7c8c0a59353d81"},{"signature":"AuthorizationUsed(address,bytes32)","signatureHash4":"0x98de5035","signatureHash32":"0x98de503528ee59b575ef0c0a2576a82497bfc029a5685b209e9ec333479b10a5"},{"signature":"Burn(address,uint256)","signatureHash4":"0xcc16f5db","signatureHash32":"0xcc16f5dbb4873280815c1ee09dbd06736cffcc184412cf7a71a0fdb75d397ca5"},{"signature":"EIP712DomainChanged()","signatureHash4":"0x0a6387c9","signatureHash32":"0x0a6387c9ea3628b88a633bb4f3b151770f70085117a15f9bf3787cda53f13d31"},{"signature":"Mint(address,uint256)","signatureHash4":"0x0f6798a5","signatureHash32":"0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885"},{"signature":"MinterAdded(address)","signatureHash4":"0x6ae17283","signatureHash32":"0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6"},{"signature":"MinterRemoved(address)","signatureHash4":"0xe94479a9","signatureHash32":"0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692"},{"signature":"OwnerChanged(address,address)","signatureHash4":"0xb532073b","signatureHash32":"0xb532073b38c83145e3e5135377a08bf9aab55bc0fd7c1179cd4fb995d2a5159c"},{"signature":"OwnerNominated(address)","signatureHash4":"0x906a1c6b","signatureHash32":"0x906a1c6bd7e3091ea86693dd029a831c19049ce77f1dce2ce0bab1cacbabce22"},{"signature":"TimelockChanged(address)","signatureHash4":"0xf02fdf7b","signatureHash32":"0xf02fdf7b40fb25784d39342249bbb15cee2bc0288f75ded1cf8ad2e63d4d91aa"},{"signature":"TokenMinterBurned(address,address,uint256)","signatureHash4":"0xdc7fd22b","signatureHash32":"0xdc7fd22bc401e7c6b9be2c2736286a2a42ea0c6307bc97ff0fb12bd0abd2c747"},{"signature":"TokenMinterMinted(address,address,uint256)","signatureHash4":"0xe0dcb47e","signatureHash32":"0xe0dcb47e0eb67e20e87f3e34aab31c669ecec7466e8b7fb329d586dadebac6b6"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[{"signature":"ERC20InsufficientAllowance(address,uint256,uint256)","signatureHash4":"0xfb8f41b2","signatureHash32":"0xfb8f41b23e99d2101d86da76cdfa87dd51c82ed07d3cb62cbc473e469dbc75c3"},{"signature":"ERC20InsufficientBalance(address,uint256,uint256)","signatureHash4":"0xe450d38c","signatureHash32":"0xe450d38cd8d9f7d95077d567d60ed49c7254716e6ad08fc9872816c97e0ffec6"},{"signature":"ERC20InvalidApprover(address)","signatureHash4":"0xe602df05","signatureHash32":"0xe602df05cc75712490294c6c104ab7c17f4030363910a7a2626411c6d3118847"},{"signature":"ERC20InvalidReceiver(address)","signatureHash4":"0xec442f05","signatureHash32":"0xec442f055133b72f3b2f9f0bb351c406b178527de2040a7d1feb4e058771f613"},{"signature":"ERC20InvalidSender(address)","signatureHash4":"0x96c6fd1e","signatureHash32":"0x96c6fd1edd0cd6ef7ff0ecc0facdf53148dc0048b57fe58af65755250a7a96bd"},{"signature":"ERC20InvalidSpender(address)","signatureHash4":"0x94280d62","signatureHash32":"0x94280d62c347d8d9f4d59a76ea321452406db88df38e0c9da304f58b57b373a2"},{"signature":"ERC2612ExpiredSignature(uint256)","signatureHash4":"0x62791302","signatureHash32":"0x627913023c184eaad13735d5a3d2657ae76ec9a872a70e0fc57522ef1a114d58"},{"signature":"ERC2612InvalidSigner(address,address)","signatureHash4":"0x4b800e46","signatureHash32":"0x4b800e463b323b1d856edf9dec70329a639d13874a57f5c28219ff57128756db"},{"signature":"ExpiredAuthorization()","signatureHash4":"0xa899ef93","signatureHash32":"0xa899ef9330d7252b4f8992745bacf96526bca81d0a6f4a669cd09b1898b91870"},{"signature":"InvalidAccountNonce(address,uint256)","signatureHash4":"0x752d88c0","signatureHash32":"0x752d88c0de02638abf10e8e31861e4c68dc1f3a1e7d840e580683f2c282bfc7a"},{"signature":"InvalidAuthorization()","signatureHash4":"0x2ce87eeb","signatureHash32":"0x2ce87eeb2b89bf1c5137bc694ec3aad7751d1546b05fa0949ca894e308760b6f"},{"signature":"InvalidOwnershipAcceptance()","signatureHash4":"0xd74b334e","signatureHash32":"0xd74b334ecdfa5332d7066f5356c66ee0590376461543ec89353e78186df75b0c"},{"signature":"InvalidPayee(address,address)","signatureHash4":"0xfea94442","signatureHash32":"0xfea944420db392de8be7a3372996404e506528fff02fa39c766de90bd7951dc0"},{"signature":"InvalidShortString()","signatureHash4":"0xb3512b0c","signatureHash32":"0xb3512b0c6163e5f0bafab72bb631b9d58cd7a731b082f910338aa21c83d5c274"},{"signature":"InvalidSignature()","signatureHash4":"0x8baa579f","signatureHash32":"0x8baa579fce362245063d36f11747a89dd489c54795634fc673cc0e0db51fedc5"},{"signature":"OnlyOwner()","signatureHash4":"0x5fc483c5","signatureHash32":"0x5fc483c5fcd3811670a93392f365a32f0fc9e73013bbed53888646cfd592055f"},{"signature":"OwnerCannotBeZero()","signatureHash4":"0x9b15e16f","signatureHash32":"0x9b15e16f5043ff5921bba9f4024e6ff9aeb372ee80078ea5c0dc2ebd43b4cf1b"},{"signature":"StringTooLong(string)","signatureHash4":"0x305a27a9","signatureHash32":"0x305a27a93f8e33b7392df0a0f91d6fc63847395853c45991eec52dbf24d72381"},{"signature":"UsedOrCanceledAuthorization()","signatureHash4":"0x1dbc01d4","signatureHash32":"0x1dbc01d49645953737f63295440438bad181bbb30ee9ec28fc918ccf7fc6596e"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"252","address":"0xBa026E978eb1B11d72aDABf33B7cF6f3E321Ca83"}