{"matchId":"30006297","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-05-26T20:06:01Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"501:4749:12:-:0;;;1211:334;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1263:10;;1269:95:2;;1322:31;;-1:-1:-1;;;1322:31:2;;1350:1;1322:31;;;640:51:13;613:18;;1322:31:2;;;;;;;;1269:95;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;1857:1:8;2061:7;:21;-1:-1:-1;;;;;1293:20:12;::::1;1285:55;;;::::0;-1:-1:-1;;;1285:55:12;;904:2:13;1285:55:12::1;::::0;::::1;886:21:13::0;943:2;923:18;;;916:30;982:24;962:18;;;955:52;1024:18;;1285:55:12::1;702:346:13::0;1285:55:12::1;-1:-1:-1::0;;;;;1358:20:12;::::1;1350:55;;;::::0;-1:-1:-1;;;1350:55:12;;1255:2:13;1350:55:12::1;::::0;::::1;1237:21:13::0;1294:2;1274:18;;;1267:30;1333:24;1313:18;;;1306:52;1375:18;;1350:55:12::1;1053:346:13::0;1350:55:12::1;-1:-1:-1::0;;;;;1424:22:12;;::::1;;::::0;1456:21;::::1;;::::0;1496:42:::1;2232:4:0;1527:10:12;1496;:42::i;:::-;;1211:334:::0;;501:4749;;2912:187:2;2985:16;3004:6;;-1:-1:-1;;;;;3020:17:2;;;-1:-1:-1;;;;;;3020:17:2;;;;;;3052:40;;3004:6;;;;;;;3052:40;;2985:16;3052:40;2975:124;2912:187;:::o;6179:316:0:-;6256:4;2954:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;2954:29:0;;;;;;;;;;;;6272:217;;6315:12;;;;6347:4;6315:12;;;;;;;;-1:-1:-1;;;;;6315:29:0;;;;;;;;;;:36;;-1:-1:-1;;6315:36:0;;;;;;;6370:40;;735:10:7;;6315:12:0;;6370:40;;6315:12;6370:40;-1:-1:-1;6431:4:0;6424:11;;6272:217;-1:-1:-1;6473:5:0;6272:217;6179:316;;;;:::o;14:177:13:-;93:13;;-1:-1:-1;;;;;135:31:13;;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;1053:346::-;501:4749:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220e055013225ada0547ecf4cd0b01b5b43164858ca1551f56b1281fd8a41f7971264736f6c634300081c0033","offset":5068}},"transformations":[{"type":"insert","offset":5121,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000c603ef9cab5e4131c52f6b8bcf06cc0568c32a2400000000000000000000000040ff3dea2eec93a7b71879874dc4407918da77a6"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"501:4749:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2565:202:0;;;;;;:::i;:::-;;:::i;:::-;;;470:14:13;;463:22;445:41;;433:2;418:18;2565:202:0;;;;;;;;929:50:12;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;1040:25:13;;;1096:2;1081:18;;1074:34;;;;1013:18;929:50:12;866:248:13;3810:120:0;;;;;;:::i;:::-;3875:7;3901:12;;;:6;:12;;;;;;;;:22;;;3810:120;;;;1496:25:13;;;1484:2;1469:18;3810:120:0;1350:177:13;4226:136:0;;;;;;:::i;:::-;;:::i;:::-;;5328:245;;;;;;:::i;:::-;;:::i;4522:226:12:-;;;;;;:::i;:::-;;:::i;2293:101:2:-;;;:::i;4954:294:12:-;;;;;;:::i;:::-;;:::i;741:29::-;;;;;;;;-1:-1:-1;;;;;2459:32:13;;;2441:51;;2429:2;2414:18;741:29:12;2280:218:13;1638:85:2;1684:7;1710:6;-1:-1:-1;;;;;1710:6:2;1638:85;;2854:136:0;;;;;;:::i;:::-;;:::i;2187:49::-;;2232:4;2187:49;;3224:1085:12;;;;;;:::i;:::-;;:::i;776:28::-;;;;;4642:138:0;;;;;;:::i;:::-;;:::i;2223:759:12:-;;;;;;:::i;:::-;;:::i;1655:449::-;;;;;;:::i;:::-;;:::i;2543:215:2:-;;;;;;:::i;:::-;;:::i;664:66:12:-;;-1:-1:-1;;;;;;;;;;;664:66:12;;618:40;;;;;;;;;;;;;;;-1:-1:-1;;;618:40:12;;;;;;;;;;;;:::i;2565:202:0:-;2650:4;-1:-1:-1;;;;;;2673:47:0;;-1:-1:-1;;;2673:47:0;;:87;;-1:-1:-1;;;;;;;;;;862:40:9;;;2724:36:0;2666:94;2565:202;-1:-1:-1;;2565:202:0:o;4226:136::-;3875:7;3901:12;;;:6;:12;;;;;;;;:22;;2464:16;2475:4;2464:10;:16::i;:::-;4330:25:::1;4341:4;4347:7;4330:10;:25::i;:::-;;4226:136:::0;;;:::o;5328:245::-;-1:-1:-1;;;;;5421:34:0;;735:10:7;5421:34:0;5417:102;;5478:30;;-1:-1:-1;;;5478:30:0;;;;;;;;;;;5417:102;5529:37;5541:4;5547:18;5529:11;:37::i;:::-;;5328:245;;:::o;4522:226:12:-;1531:13:2;:11;:13::i;:::-;4608:7:12::1;4604:138;;;4631:34;-1:-1:-1::0;;;;;;;;;;;4656:8:12::1;4631:9;:34::i;:::-;4522:226:::0;;:::o;4604:138::-:1;4696:35;-1:-1:-1::0;;;;;;;;;;;4722:8:12::1;4696:10;:35::i;2293:101:2:-:0;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;4954:294:12:-;-1:-1:-1;;;;;5084:23:12;;5015:14;5084:23;;;:14;:23;;;;;;;;5061:46;;;;;;;;;;;;;;;;;;;;;5015:14;;5121:15;:34;5117:78;;-1:-1:-1;5179:1:12;;;;-1:-1:-1;4954:294:12;-1:-1:-1;;4954:294:12:o;5117:78::-;5212:11;;5225:15;;;;;5212:11;;5225:15;;-1:-1:-1;4954:294:12;-1:-1:-1;;4954:294:12:o;2854:136:0:-;2931:4;2954:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;2954:29:0;;;;;;;;;;;;;;;2854:136::o;3224:1085:12:-;2500:21:8;:19;:21::i;:::-;3387:10:12::1;3376:7;1684::2::0;1710:6;-1:-1:-1;;;;;1710:6:2;;1638:85;3376:7:12::1;-1:-1:-1::0;;;;;3376:21:12::1;;:59;;;;3401:34;-1:-1:-1::0;;;;;;;;;;;3424:10:12::1;3401:7;:34::i;:::-;3355:129;;;::::0;-1:-1:-1;;;3355:129:12;;4323:2:13;3355:129:12::1;::::0;::::1;4305:21:13::0;4362:2;4342:18;;;4335:30;4401:25;4381:18;;;4374:53;4444:18;;3355:129:12::1;;;;;;;;;-1:-1:-1::0;;;;;3502:16:12;::::1;3494:55;;;::::0;-1:-1:-1;;;3494:55:12;;4675:2:13;3494:55:12::1;::::0;::::1;4657:21:13::0;4714:2;4694:18;;;4687:30;4753:28;4733:18;;;4726:56;4799:18;;3494:55:12::1;4473:350:13::0;3494:55:12::1;3576:1;3567:6;:10;3559:43;;;;-1:-1:-1::0;;;3559:43:12::1;;;;;;;:::i;:::-;3633:15;3620:10;:28;3612:69;;;::::0;-1:-1:-1;;;3612:69:12;;5379:2:13;3612:69:12::1;::::0;::::1;5361:21:13::0;5418:2;5398:18;;;5391:30;5457;5437:18;;;5430:58;5505:18;;3612:69:12::1;5177:352:13::0;3612:69:12::1;3775:53;::::0;-1:-1:-1;;;3775:53:12;;3794:10:::1;3775:53;::::0;::::1;5736:51:13::0;3814:4:12::1;5803:18:13::0;;;5796:60;5872:18;;;5865:34;;;3775:5:12::1;-1:-1:-1::0;;;;;3775:18:12::1;::::0;::::1;::::0;5709::13;;3775:53:12::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3754:124;;;;-1:-1:-1::0;;;3754:124:12::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;3991:18:12;::::1;;::::0;;;:14:::1;:18;::::0;;;;:29:::1;;::::0;3978:42;::::1;3974:115;;;-1:-1:-1::0;;;;;4036:18:12;::::1;;::::0;;;:14:::1;:18;::::0;;;;:29:::1;;:42:::0;;;3974:115:::1;-1:-1:-1::0;;;;;4126:18:12;::::1;;::::0;;;:14:::1;:18;::::0;;;;:25;:34:::1;::::0;4154:6;;4126:34:::1;:::i;:::-;-1:-1:-1::0;;;;;4098:18:12;;::::1;;::::0;;;:14:::1;:18;::::0;;;;;;:62;;;;4214:22;;-1:-1:-1;;;4214:22:12;;::::1;::::0;::::1;6949:51:13::0;;;;7016:18;;;7009:34;;;4214:5:12::1;:10;::::0;::::1;::::0;6922:18:13;;4214:22:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;4260:42:12::1;::::0;;1040:25:13;;;1096:2;1081:18;;1074:34;;;-1:-1:-1;;;;;4260:42:12;::::1;::::0;-1:-1:-1;4260:42:12::1;::::0;-1:-1:-1;1013:18:13;4260:42:12::1;;;;;;;2542:20:8::0;1857:1;3068:7;:21;2888:208;4642:138:0;3875:7;3901:12;;;:6;:12;;;;;;;;:22;;2464:16;2475:4;2464:10;:16::i;:::-;4747:26:::1;4759:4;4765:7;4747:11;:26::i;2223:759:12:-:0;2500:21:8;:19;:21::i;:::-;2304:1:12::1;2295:6;:10;2287:43;;;;-1:-1:-1::0;;;2287:43:12::1;;;;;;;:::i;:::-;2430:10;2392:20;2415:26:::0;;;:14:::1;:26;::::0;;;;;;;;2392:49;;;;::::1;::::0;;;;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;2455:15;;;;:52:::1;;;2492:4;:15;;;2474;:33;2455:52;2451:215;;;2588:11:::0;;2548:27:::1;::::0;-1:-1:-1;;;2548:27:12;;2564:10:::1;2548:27;::::0;::::1;2441:51:13::0;2578:6:12;;2548:5:::1;-1:-1:-1::0;;;;;2548:15:12::1;::::0;::::1;::::0;2414:18:13;;2548:27:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;;;;:::i;:::-;:51;;2523:132;;;::::0;-1:-1:-1;;;2523:132:12;;7578:2:13;2523:132:12::1;::::0;::::1;7560:21:13::0;7617:2;7597:18;;;7590:30;-1:-1:-1;;;7636:18:13;;;7629:52;7698:18;;2523:132:12::1;7376:346:13::0;2523:132:12::1;2725:34;::::0;-1:-1:-1;;;2725:34:12;;2740:10:::1;2725:34;::::0;::::1;6949:51:13::0;7016:18;;;7009:34;;;2725:5:12::1;-1:-1:-1::0;;;;;2725:14:12::1;::::0;::::1;::::0;6922:18:13;;2725:34:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;2838:34:12::1;::::0;-1:-1:-1;;;2838:34:12;;2853:10:::1;2838:34;::::0;::::1;6949:51:13::0;7016:18;;;7009:34;;;2838:5:12::1;-1:-1:-1::0;;;;;2838:14:12::1;::::0;-1:-1:-1;2838:14:12::1;::::0;-1:-1:-1;6922:18:13;;2838:34:12::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2817:105;;;;-1:-1:-1::0;;;2817:105:12::1;;;;;;;:::i;:::-;2946:29;::::0;1496:25:13;;;2956:10:12::1;::::0;2946:29:::1;::::0;1484:2:13;1469:18;2946:29:12::1;;;;;;;2277:705;2542:20:8::0;1857:1;3068:7;:21;2888:208;2542:20;2223:759:12;:::o;1655:449::-;2500:21:8;:19;:21::i;:::-;1734:1:12::1;1725:6;:10;1717:43;;;;-1:-1:-1::0;;;1717:43:12::1;;;;;;;:::i;:::-;1853:53;::::0;-1:-1:-1;;;1853:53:12;;1872:10:::1;1853:53;::::0;::::1;5736:51:13::0;1892:4:12::1;5803:18:13::0;;;5796:60;5872:18;;;5865:34;;;1853:5:12::1;-1:-1:-1::0;;;;;1853:18:12::1;::::0;::::1;::::0;5709::13;;1853:53:12::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1832:124;;;;-1:-1:-1::0;;;1832:124:12::1;;;;;;;:::i;:::-;2016:30;::::0;-1:-1:-1;;;2016:30:12;;2027:10:::1;2016:30;::::0;::::1;6949:51:13::0;7016:18;;;7009:34;;;2016:5:12::1;-1:-1:-1::0;;;;;2016:10:12::1;::::0;::::1;::::0;6922:18:13;;2016:30:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;2070:27:12::1;::::0;1496:25:13;;;2078:10:12::1;::::0;-1:-1:-1;2070:27:12::1;::::0;-1:-1:-1;1484:2:13;1469:18;2070:27:12::1;;;;;;;2542:20:8::0;1857:1;3068:7;:21;2888:208;2543:215:2;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:2;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:2;;2700:1:::1;2672:31;::::0;::::1;2441:51:13::0;2414:18;;2672:31:2::1;2280:218:13::0;2623:91:2::1;2723:28;2742:8;2723:18;:28::i;3199:103:0:-:0;3265:30;3276:4;735:10:7;3265::0;:30::i;6179:316::-;6256:4;6277:22;6285:4;6291:7;6277;:22::i;:::-;6272:217;;6315:12;;;;6347:4;6315:12;;;;;;;;-1:-1:-1;;;;;6315:29:0;;;;;;;;;;:36;;-1:-1:-1;;6315:36:0;;;;;;;6370:40;;735:10:7;;6315:12:0;;6370:40;;6315:12;6370:40;-1:-1:-1;6431:4:0;6424:11;;6272:217;-1:-1:-1;6473:5:0;6466:12;;6732:317;6810:4;6830:22;6838:4;6844:7;6830;:22::i;:::-;6826:217;;;6900:5;6868:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;6868:29:0;;;;;;;;;;:37;;-1:-1:-1;;6868:37:0;;;6924:40;735:10:7;;6868:12:0;;6924:40;;6900:5;6924:40;-1:-1:-1;6985:4:0;6978:11;;1796:162:2;1684:7;1710:6;-1:-1:-1;;;;;1710:6:2;735:10:7;1855:23:2;1851:101;;1901:40;;-1:-1:-1;;;1901:40:2;;735:10:7;1901:40:2;;;2441:51:13;2414:18;;1901:40:2;2280:218:13;2912:187:2;2985:16;3004:6;;-1:-1:-1;;;;;3020:17:2;;;-1:-1:-1;;;;;;3020:17:2;;;;;;3052:40;;3004:6;;;;;;;3052:40;;2985:16;3052:40;2975:124;2912:187;:::o;2575:307:8:-;1899:1;2702:7;;:18;2698:86;;2743:30;;-1:-1:-1;;;2743:30:8;;;;;;;;;;;2698:86;1899:1;2858:17;;2575:307::o;3432:197:0:-;3520:22;3528:4;3534:7;3520;:22::i;:::-;3515:108;;3565:47;;-1:-1:-1;;;3565:47:0;;-1:-1:-1;;;;;6967:32:13;;3565:47:0;;;6949:51:13;7016:18;;;7009:34;;;6922:18;;3565:47:0;6775:274:13;14:286;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:13;;209:43;;199:71;;266:1;263;256:12;199:71;289:5;14:286;-1:-1:-1;;;14:286:13:o;497:173::-;565:20;;-1:-1:-1;;;;;614:31:13;;604:42;;594:70;;660:1;657;650:12;594:70;497:173;;;:::o;675:186::-;734:6;787:2;775:9;766:7;762:23;758:32;755:52;;;803:1;800;793:12;755:52;826:29;845:9;826:29;:::i;1119:226::-;1178:6;1231:2;1219:9;1210:7;1206:23;1202:32;1199:52;;;1247:1;1244;1237:12;1199:52;-1:-1:-1;1292:23:13;;1119:226;-1:-1:-1;1119:226:13:o;1532:300::-;1600:6;1608;1661:2;1649:9;1640:7;1636:23;1632:32;1629:52;;;1677:1;1674;1667:12;1629:52;1722:23;;;-1:-1:-1;1788:38:13;1822:2;1807:18;;1788:38;:::i;:::-;1778:48;;1532:300;;;;;:::o;1837:118::-;1923:5;1916:13;1909:21;1902:5;1899:32;1889:60;;1945:1;1942;1935:12;1960:315;2025:6;2033;2086:2;2074:9;2065:7;2061:23;2057:32;2054:52;;;2102:1;2099;2092:12;2054:52;2125:29;2144:9;2125:29;:::i;:::-;2115:39;;2204:2;2193:9;2189:18;2176:32;2217:28;2239:5;2217:28;:::i;:::-;2264:5;2254:15;;;1960:315;;;;;:::o;2711:420::-;2788:6;2796;2804;2857:2;2845:9;2836:7;2832:23;2828:32;2825:52;;;2873:1;2870;2863:12;2825:52;2896:29;2915:9;2896:29;:::i;:::-;2886:39;2994:2;2979:18;;2966:32;;-1:-1:-1;3095:2:13;3080:18;;;3067:32;;2711:420;-1:-1:-1;;;2711:420:13:o;3589:527::-;3738:2;3727:9;3720:21;3701:4;3770:6;3764:13;3813:6;3808:2;3797:9;3793:18;3786:34;3838:1;3848:140;3862:6;3859:1;3856:13;3848:140;;;3973:2;3957:14;;;3953:23;;3947:30;3942:2;3923:17;;;3919:26;3912:66;3877:10;3848:140;;;3852:3;4037:1;4032:2;4023:6;4012:9;4008:22;4004:31;3997:42;4107:2;4100;4096:7;4091:2;4083:6;4079:15;4075:29;4064:9;4060:45;4056:54;4048:62;;;3589:527;;;;:::o;4828:344::-;5030:2;5012:21;;;5069:2;5049:18;;;5042:30;-1:-1:-1;;;5103:2:13;5088:18;;5081:50;5163:2;5148:18;;4828:344::o;5910:245::-;5977:6;6030:2;6018:9;6009:7;6005:23;6001:32;5998:52;;;6046:1;6043;6036:12;5998:52;6078:9;6072:16;6097:28;6119:5;6097:28;:::i;6160:348::-;6362:2;6344:21;;;6401:2;6381:18;;;6374:30;6440:26;6435:2;6420:18;;6413:54;6499:2;6484:18;;6160:348::o;6513:127::-;6574:10;6569:3;6565:20;6562:1;6555:31;6605:4;6602:1;6595:15;6629:4;6626:1;6619:15;6645:125;6710:9;;;6731:10;;;6728:36;;;6744:18;;:::i;7054:184::-;7124:6;7177:2;7165:9;7156:7;7152:23;7148:32;7145:52;;;7193:1;7190;7183:12;7145:52;-1:-1:-1;7216:16:13;;7054:184;-1:-1:-1;7054:184:13:o;7243:128::-;7310:9;;;7331:11;;;7328:37;;;7345:18;;:::i","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220e055013225ada0547ecf4cd0b01b5b43164858ca1551f56b1281fd8a41f7971264736f6c634300081c0033","offset":4363}},"immutableReferences":{"1527":[{"start":546,"length":32},{"start":1602,"length":32},{"start":2599,"length":32},{"start":2887,"length":32}],"1530":[{"start":672,"length":32},{"start":1909,"length":32},{"start":2249,"length":32},{"start":2473,"length":32},{"start":3060,"length":32}]},"transformations":[{"id":"1527","type":"replace","offset":546,"reason":"immutable"},{"id":"1527","type":"replace","offset":1602,"reason":"immutable"},{"id":"1527","type":"replace","offset":2599,"reason":"immutable"},{"id":"1527","type":"replace","offset":2887,"reason":"immutable"},{"id":"1530","type":"replace","offset":672,"reason":"immutable"},{"id":"1530","type":"replace","offset":1909,"reason":"immutable"},{"id":"1530","type":"replace","offset":2249,"reason":"immutable"},{"id":"1530","type":"replace","offset":2473,"reason":"immutable"},{"id":"1530","type":"replace","offset":3060,"reason":"immutable"}],"transformationValues":{"immutables":{"1527":"0x000000000000000000000000c603ef9cab5e4131c52f6b8bcf06cc0568c32a24","1530":"0x00000000000000000000000040ff3dea2eec93a7b71879874dc4407918da77a6"}}},"deployment":{"transactionHash":"0x2a8976994a6a67624af227f3b7b7355686f17fa86ee7b03cfb496a448b9f977a","blockNumber":"55830509","transactionIndex":"48","deployer":"0xF683ab3aC7dCb195a8dF52D7F5fD796e81A75075"},"sources":{"@openzeppelin/contracts/access/AccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"./IAccessControl.sol\";\nimport {Context} from \"../utils/Context.sol\";\nimport {ERC165} from \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address account => bool) hasRole;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 role => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with an {AccessControlUnauthorizedAccount} error including the required role.\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n        return _roles[role].hasRole[account];\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n     * is missing `role`.\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert AccessControlUnauthorizedAccount(account, role);\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n        if (callerConfirmation != _msgSender()) {\n            revert AccessControlBadConfirmation();\n        }\n\n        _revokeRole(role, callerConfirmation);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (!hasRole(role, account)) {\n            _roles[role].hasRole[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (hasRole(role, account)) {\n            _roles[role].hasRole[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n}\n"},"@openzeppelin/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (access/IAccessControl.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev External interface of AccessControl declared to support ERC-165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev The `account` is missing a role.\n     */\n    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n    /**\n     * @dev The caller of a function is not the expected one.\n     *\n     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n     */\n    error AccessControlBadConfirmation();\n\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted to signal this.\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).\n     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},"@openzeppelin/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.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     * Both values are immutable: they can only be set once during 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"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/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"},"contracts/SPUSD.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/access/AccessControl.sol\";\n\n/**\n * @title SPUSD - SoulPeg USD\n * @notice Tradeable wrapper token for soul-bound sUSDC\n * @dev Only authorized wrapper contract can mint/burn\n */\ncontract SPUSD is ERC20, AccessControl {\n    bytes32 public constant MINTER_ROLE = keccak256(\"MINTER_ROLE\");\n    bytes32 public constant BURNER_ROLE = keccak256(\"BURNER_ROLE\");\n    \n    // 1 billion max supply cap for safety\n    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 10**18;\n    \n    constructor() ERC20(\"SoulPeg USD\", \"SPUSD\") {\n        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);\n    }\n    \n    /**\n     * @notice Mint new SPUSD tokens\n     * @dev Only callable by MINTER_ROLE (wrapper contract)\n     * @param to Address to mint tokens to\n     * @param amount Amount to mint\n     */\n    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {\n        require(totalSupply() + amount <= MAX_SUPPLY, \"SPUSD: Max supply exceeded\");\n        _mint(to, amount);\n    }\n    \n    /**\n     * @notice Burn SPUSD tokens from an address\n     * @dev Only callable by BURNER_ROLE (wrapper contract)\n     * @param from Address to burn tokens from\n     * @param amount Amount to burn\n     */\n    function burnFrom(address from, uint256 amount) external onlyRole(BURNER_ROLE) {\n        _burn(from, amount);\n    }\n    \n}"},"contracts/StUSDCWrapper.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/access/AccessControl.sol\";\nimport \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"./SPUSD.sol\";\n\n/**\n * @title StUSDCWrapper V2\n * @notice Wrapper contract for converting between sUSDC and SPUSD with lock support\n * @dev Handles wrap/unwrap operations and locked tokens for investors\n */\ncontract StUSDCWrapper is Ownable, AccessControl, ReentrancyGuard {\n    // Version identifier to change bytecode\n    string public constant VERSION = \"2.0.0\";\n    bytes32 public constant OPERATOR_ROLE = keccak256(\"OPERATOR_ROLE\");\n    \n    IERC20 public immutable sUSDC;\n    SPUSD public immutable spusd;\n    \n    // Locked token tracking\n    struct LockInfo {\n        uint256 amount;\n        uint256 unlockTime;\n    }\n    \n    mapping(address => LockInfo) public lockedBalances;\n    \n    // Events\n    event Wrapped(address indexed user, uint256 amount);\n    event Unwrapped(address indexed user, uint256 amount);\n    event LockedTokensMinted(address indexed to, uint256 amount, uint256 unlockTime);\n    \n    constructor(address _sUSDC, address _spusd) Ownable(msg.sender) {\n        require(_sUSDC != address(0), \"Wrapper: Invalid sUSDC\");\n        require(_spusd != address(0), \"Wrapper: Invalid SPUSD\");\n        \n        sUSDC = IERC20(_sUSDC);\n        spusd = SPUSD(_spusd);\n        \n        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);\n    }\n    \n    /**\n     * @notice Wrap sUSDC to get SPUSD\n     * @param amount Amount of sUSDC to wrap\n     */\n    function wrap(uint256 amount) external nonReentrant {\n        require(amount > 0, \"Wrapper: Zero amount\");\n        \n        // Transfer sUSDC from user to this contract\n        require(\n            sUSDC.transferFrom(msg.sender, address(this), amount),\n            \"Wrapper: Transfer failed\"\n        );\n        \n        // Mint equivalent SPUSD to user\n        spusd.mint(msg.sender, amount);\n        \n        emit Wrapped(msg.sender, amount);\n    }\n    \n    /**\n     * @notice Unwrap SPUSD to get back sUSDC\n     * @param amount Amount of SPUSD to unwrap\n     */\n    function unwrap(uint256 amount) external nonReentrant {\n        require(amount > 0, \"Wrapper: Zero amount\");\n        \n        // Check if user has locked tokens\n        LockInfo memory lock = lockedBalances[msg.sender];\n        if (lock.amount > 0 && block.timestamp < lock.unlockTime) {\n            require(\n                spusd.balanceOf(msg.sender) - amount >= lock.amount,\n                \"Wrapper: Tokens locked\"\n            );\n        }\n        \n        // Burn SPUSD directly from user\n        spusd.burnFrom(msg.sender, amount);\n        \n        // Transfer sUSDC back to user\n        require(\n            sUSDC.transfer(msg.sender, amount),\n            \"Wrapper: Transfer failed\"\n        );\n        \n        emit Unwrapped(msg.sender, amount);\n    }\n    \n    /**\n     * @notice Mint locked SPUSD tokens for investors\n     * @dev Only owner can call this\n     * @param to Recipient address\n     * @param amount Amount to mint\n     * @param unlockTime Timestamp when tokens unlock\n     */\n    function wrapAndLock(\n        address to,\n        uint256 amount,\n        uint256 unlockTime\n    ) external nonReentrant {\n        require(\n            owner() == msg.sender || hasRole(OPERATOR_ROLE, msg.sender),\n            \"Wrapper: Not authorized\"\n        );\n        require(to != address(0), \"Wrapper: Invalid recipient\");\n        require(amount > 0, \"Wrapper: Zero amount\");\n        require(unlockTime > block.timestamp, \"Wrapper: Invalid unlock time\");\n        \n        // Transfer sUSDC from owner to this contract\n        require(\n            sUSDC.transferFrom(msg.sender, address(this), amount),\n            \"Wrapper: Transfer failed\"\n        );\n        \n        // Update locked balance - use max to prevent reducing existing lock\n        if (unlockTime > lockedBalances[to].unlockTime) {\n            lockedBalances[to].unlockTime = unlockTime;\n        }\n        lockedBalances[to].amount = lockedBalances[to].amount + amount;\n        \n        // Mint SPUSD to recipient\n        spusd.mint(to, amount);\n        \n        emit LockedTokensMinted(to, amount, unlockTime);\n    }\n    \n    /**\n     * @notice Grant or revoke OPERATOR_ROLE\n     * @dev Only owner can call this\n     * @param operator Address to grant/revoke role\n     * @param granted True to grant, false to revoke\n     */\n    function setOperator(address operator, bool granted) external onlyOwner {\n        if (granted) {\n            grantRole(OPERATOR_ROLE, operator);\n        } else {\n            revokeRole(OPERATOR_ROLE, operator);\n        }\n    }\n    \n    /**\n     * @notice Check if address has locked tokens\n     * @param account Address to check\n     * @return locked Amount of locked tokens\n     * @return unlockTime When tokens unlock\n     */\n    function getLockInfo(address account) external view returns (uint256 locked, uint256 unlockTime) {\n        LockInfo memory lock = lockedBalances[account];\n        if (block.timestamp >= lock.unlockTime) {\n            return (0, 0);\n        }\n        return (lock.amount, lock.unlockTime);\n    }\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"},"name":"StUSDCWrapper","fullyQualifiedName":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},"abi":[{"type":"constructor","inputs":[{"name":"_sUSDC","type":"address","internalType":"address"},{"name":"_spusd","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AccessControlBadConfirmation","type":"error","inputs":[]},{"name":"AccessControlUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"neededRole","type":"bytes32","internalType":"bytes32"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"LockedTokensMinted","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"unlockTime","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleAdminChanged","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"previousAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"newAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"RoleGranted","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleRevoked","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Unwrapped","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Wrapped","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"OPERATOR_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"getLockInfo","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"locked","type":"uint256","internalType":"uint256"},{"name":"unlockTime","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getRoleAdmin","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"grantRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"hasRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"lockedBalances","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"unlockTime","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"callerConfirmation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"revokeRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"sUSDC","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IERC20"}],"stateMutability":"view"},{"name":"setOperator","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"granted","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"spusd","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract SPUSD"}],"stateMutability":"view"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unwrap","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"wrap","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"wrapAndLock","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"unlockTime","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_sUSDC","type":"address"},{"internalType":"address","name":"_spusd","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"unlockTime","type":"uint256"}],"name":"LockedTokensMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unwrapped","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Wrapped","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getLockInfo","outputs":[{"internalType":"uint256","name":"locked","type":"uint256"},{"internalType":"uint256","name":"unlockTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lockedBalances","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"unlockTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sUSDC","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"granted","type":"bool"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"spusd","outputs":[{"internalType":"contract SPUSD","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unwrap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"wrap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"unlockTime","type":"uint256"}],"name":"wrapAndLock","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"details":"Handles wrap/unwrap operations and locked tokens for investors","errors":{"AccessControlBadConfirmation()":[{"details":"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}."}],"AccessControlUnauthorizedAccount(address,bytes32)":[{"details":"The `account` is missing a role."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}]},"events":{"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this."},"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"}},"kind":"dev","methods":{"getLockInfo(address)":{"params":{"account":"Address to check"},"returns":{"locked":"Amount of locked tokens","unlockTime":"When tokens unlock"}},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"setOperator(address,bool)":{"details":"Only owner can call this","params":{"granted":"True to grant, false to revoke","operator":"Address to grant/revoke role"}},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"unwrap(uint256)":{"params":{"amount":"Amount of SPUSD to unwrap"}},"wrap(uint256)":{"params":{"amount":"Amount of sUSDC to wrap"}},"wrapAndLock(address,uint256,uint256)":{"details":"Only owner can call this","params":{"amount":"Amount to mint","to":"Recipient address","unlockTime":"Timestamp when tokens unlock"}}},"title":"StUSDCWrapper V2","version":1},"userdoc":{"kind":"user","methods":{"getLockInfo(address)":{"notice":"Check if address has locked tokens"},"setOperator(address,bool)":{"notice":"Grant or revoke OPERATOR_ROLE"},"unwrap(uint256)":{"notice":"Unwrap SPUSD to get back sUSDC"},"wrap(uint256)":{"notice":"Wrap sUSDC to get SPUSD"},"wrapAndLock(address,uint256,uint256)":{"notice":"Mint locked SPUSD tokens for investors"}},"notice":"Wrapper contract for converting between sUSDC and SPUSD with lock support","version":1}},"settings":{"compilationTarget":{"contracts/StUSDCWrapper.sol":"StUSDCWrapper"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"@openzeppelin/contracts/access/AccessControl.sol":{"keccak256":"0xc1bebdee8943bd5e9ef1e0f2e63296aa1dd4171a66b9e74d0286220e891e1458","license":"MIT","urls":["bzz-raw://928cf2f0042c606f3dcb21bd8a272573f462a215cd65285d2d6b407f31e9bd67","dweb:/ipfs/QmWGxjckno6sfjHPX5naPnsfsyisgy4PJDf46eLw9umfpx"]},"@openzeppelin/contracts/access/IAccessControl.sol":{"keccak256":"0x4d9a2b261b56a1e4a37bb038151dec98b952fed16de2bdfdda27e38e2b12b530","license":"MIT","urls":["bzz-raw://f724110f7aeb6151af800ab8c12e6060b29bda9e013f0ccb331eb754d6a7cbf0","dweb:/ipfs/QmUcjzCZpxtUPdEThtAzE1f9LvuJiUGZxTdH9N6bHrb5Cf"]},"@openzeppelin/contracts/access/Ownable.sol":{"keccak256":"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb","license":"MIT","urls":["bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6","dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a"]},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"keccak256":"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b","license":"MIT","urls":["bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b","dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz"]},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"keccak256":"0x41f6b3b9e030561e7896dbef372b499cc8d418a80c3884a4d65a68f2fdc7493a","license":"MIT","urls":["bzz-raw://80b0992a11b2fd1f75ced2971696d07bbd1d19ce6761dd50d8b6d48aa435f42a","dweb:/ipfs/QmZDe5xd2gXHjVEjv9t8C1KQ68K5T8qFwdinwQgmP3rF3x"]},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7","license":"MIT","urls":["bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db","dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"]},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330","license":"MIT","urls":["bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf","dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r"]},"@openzeppelin/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"keccak256":"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3","license":"MIT","urls":["bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a","dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA"]},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"keccak256":"0xddce8e17e3d3f9ed818b4f4c4478a8262aab8b11ed322f1bf5ed705bb4bd97fa","license":"MIT","urls":["bzz-raw://8084aa71a4cc7d2980972412a88fe4f114869faea3fefa5436431644eb5c0287","dweb:/ipfs/Qmbqfs5dRdPvHVKY8kTaeyc65NdqXRQwRK7h9s5UJEhD1p"]},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8","license":"MIT","urls":["bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621","dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL"]},"contracts/SPUSD.sol":{"keccak256":"0x370cb03c3fdc69fee3f01e22f77e6413e4f985f05ed7108839285ee634ad90b4","license":"MIT","urls":["bzz-raw://2e6e2db2ea0bdb52551c65db4ea32ee4b8282741b1305c631e3f1e2bb3fc1dc4","dweb:/ipfs/QmZGTnjK2GtzfUCaPFBi9dGTs1eKxigH3igKYWWLWrrS8T"]},"contracts/StUSDCWrapper.sol":{"keccak256":"0x3d89d4fc211a185234e90eeb12b072ab4537ec2d75c5df1810a242a548ef8bf2","license":"MIT","urls":["bzz-raw://50b584e31943ab495f917496ef2d3d3ea5b9913df8e16ae50b278e21a42b7d7b","dweb:/ipfs/QmX317Lqt2wKWw1KUtbdgyLZLJ8frLSKBi1J6kiQpscCbN"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_struct(RoleData)21_storage":{"label":"struct AccessControl.RoleData","members":[{"slot":"0","type":"t_mapping(t_address,t_bool)","astId":18,"label":"hasRole","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"1","type":"t_bytes32","astId":20,"label":"adminRole","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"}],"encoding":"inplace","numberOfBytes":"64"},"t_struct(LockInfo)1535_storage":{"label":"struct StUSDCWrapper.LockInfo","members":[{"slot":"0","type":"t_uint256","astId":1532,"label":"amount","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"1","type":"t_uint256","astId":1534,"label":"unlockTime","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"}],"encoding":"inplace","numberOfBytes":"64"},"t_mapping(t_bytes32,t_struct(RoleData)21_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct AccessControl.RoleData)","value":"t_struct(RoleData)21_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_struct(LockInfo)1535_storage)":{"key":"t_address","label":"mapping(address => struct StUSDCWrapper.LockInfo)","value":"t_struct(LockInfo)1535_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":387,"label":"_owner","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"1","type":"t_mapping(t_bytes32,t_struct(RoleData)21_storage)","astId":26,"label":"_roles","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"2","type":"t_uint256","astId":1323,"label":"_status","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"3","type":"t_mapping(t_address,t_struct(LockInfo)1535_storage)","astId":1540,"label":"lockedBalances","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Wrapper contract for converting between sUSDC and SPUSD with lock support","methods":{"wrap(uint256)":{"notice":"Wrap sUSDC to get SPUSD"},"unwrap(uint256)":{"notice":"Unwrap SPUSD to get back sUSDC"},"getLockInfo(address)":{"notice":"Check if address has locked tokens"},"setOperator(address,bool)":{"notice":"Grant or revoke OPERATOR_ROLE"},"wrapAndLock(address,uint256,uint256)":{"notice":"Mint locked SPUSD tokens for investors"}},"version":1},"devdoc":{"kind":"dev","title":"StUSDCWrapper V2","errors":{"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"AccessControlBadConfirmation()":[{"details":"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"AccessControlUnauthorizedAccount(address,bytes32)":[{"details":"The `account` is missing a role."}]},"events":{"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this."}},"details":"Handles wrap/unwrap operations and locked tokens for investors","methods":{"owner()":{"details":"Returns the address of the current owner."},"wrap(uint256)":{"params":{"amount":"Amount of sUSDC to wrap"}},"unwrap(uint256)":{"params":{"amount":"Amount of SPUSD to unwrap"}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"getLockInfo(address)":{"params":{"account":"Address to check"},"returns":{"locked":"Amount of locked tokens","unlockTime":"When tokens unlock"}},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"setOperator(address,bool)":{"params":{"granted":"True to grant, false to revoke","operator":"Address to grant/revoke role"},"details":"Only owner can call this"},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event."},"wrapAndLock(address,uint256,uint256)":{"params":{"to":"Recipient address","amount":"Amount to mint","unlockTime":"Timestamp when tokens unlock"},"details":"Only owner can call this"}},"version":1},"sourceIds":{"contracts/SPUSD.sol":{"id":11},"contracts/StUSDCWrapper.sol":{"id":12},"@openzeppelin/contracts/utils/Context.sol":{"id":7},"@openzeppelin/contracts/access/Ownable.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":4},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":5},"@openzeppelin/contracts/access/AccessControl.sol":{"id":0},"@openzeppelin/contracts/access/IAccessControl.sol":{"id":1},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":8},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":3},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":9},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":10},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":6}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/SPUSD.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/access/AccessControl.sol\";\n\n/**\n * @title SPUSD - SoulPeg USD\n * @notice Tradeable wrapper token for soul-bound sUSDC\n * @dev Only authorized wrapper contract can mint/burn\n */\ncontract SPUSD is ERC20, AccessControl {\n    bytes32 public constant MINTER_ROLE = keccak256(\"MINTER_ROLE\");\n    bytes32 public constant BURNER_ROLE = keccak256(\"BURNER_ROLE\");\n    \n    // 1 billion max supply cap for safety\n    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 10**18;\n    \n    constructor() ERC20(\"SoulPeg USD\", \"SPUSD\") {\n        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);\n    }\n    \n    /**\n     * @notice Mint new SPUSD tokens\n     * @dev Only callable by MINTER_ROLE (wrapper contract)\n     * @param to Address to mint tokens to\n     * @param amount Amount to mint\n     */\n    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {\n        require(totalSupply() + amount <= MAX_SUPPLY, \"SPUSD: Max supply exceeded\");\n        _mint(to, amount);\n    }\n    \n    /**\n     * @notice Burn SPUSD tokens from an address\n     * @dev Only callable by BURNER_ROLE (wrapper contract)\n     * @param from Address to burn tokens from\n     * @param amount Amount to burn\n     */\n    function burnFrom(address from, uint256 amount) external onlyRole(BURNER_ROLE) {\n        _burn(from, amount);\n    }\n    \n}"},"contracts/StUSDCWrapper.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/access/AccessControl.sol\";\nimport \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"./SPUSD.sol\";\n\n/**\n * @title StUSDCWrapper V2\n * @notice Wrapper contract for converting between sUSDC and SPUSD with lock support\n * @dev Handles wrap/unwrap operations and locked tokens for investors\n */\ncontract StUSDCWrapper is Ownable, AccessControl, ReentrancyGuard {\n    // Version identifier to change bytecode\n    string public constant VERSION = \"2.0.0\";\n    bytes32 public constant OPERATOR_ROLE = keccak256(\"OPERATOR_ROLE\");\n    \n    IERC20 public immutable sUSDC;\n    SPUSD public immutable spusd;\n    \n    // Locked token tracking\n    struct LockInfo {\n        uint256 amount;\n        uint256 unlockTime;\n    }\n    \n    mapping(address => LockInfo) public lockedBalances;\n    \n    // Events\n    event Wrapped(address indexed user, uint256 amount);\n    event Unwrapped(address indexed user, uint256 amount);\n    event LockedTokensMinted(address indexed to, uint256 amount, uint256 unlockTime);\n    \n    constructor(address _sUSDC, address _spusd) Ownable(msg.sender) {\n        require(_sUSDC != address(0), \"Wrapper: Invalid sUSDC\");\n        require(_spusd != address(0), \"Wrapper: Invalid SPUSD\");\n        \n        sUSDC = IERC20(_sUSDC);\n        spusd = SPUSD(_spusd);\n        \n        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);\n    }\n    \n    /**\n     * @notice Wrap sUSDC to get SPUSD\n     * @param amount Amount of sUSDC to wrap\n     */\n    function wrap(uint256 amount) external nonReentrant {\n        require(amount > 0, \"Wrapper: Zero amount\");\n        \n        // Transfer sUSDC from user to this contract\n        require(\n            sUSDC.transferFrom(msg.sender, address(this), amount),\n            \"Wrapper: Transfer failed\"\n        );\n        \n        // Mint equivalent SPUSD to user\n        spusd.mint(msg.sender, amount);\n        \n        emit Wrapped(msg.sender, amount);\n    }\n    \n    /**\n     * @notice Unwrap SPUSD to get back sUSDC\n     * @param amount Amount of SPUSD to unwrap\n     */\n    function unwrap(uint256 amount) external nonReentrant {\n        require(amount > 0, \"Wrapper: Zero amount\");\n        \n        // Check if user has locked tokens\n        LockInfo memory lock = lockedBalances[msg.sender];\n        if (lock.amount > 0 && block.timestamp < lock.unlockTime) {\n            require(\n                spusd.balanceOf(msg.sender) - amount >= lock.amount,\n                \"Wrapper: Tokens locked\"\n            );\n        }\n        \n        // Burn SPUSD directly from user\n        spusd.burnFrom(msg.sender, amount);\n        \n        // Transfer sUSDC back to user\n        require(\n            sUSDC.transfer(msg.sender, amount),\n            \"Wrapper: Transfer failed\"\n        );\n        \n        emit Unwrapped(msg.sender, amount);\n    }\n    \n    /**\n     * @notice Mint locked SPUSD tokens for investors\n     * @dev Only owner can call this\n     * @param to Recipient address\n     * @param amount Amount to mint\n     * @param unlockTime Timestamp when tokens unlock\n     */\n    function wrapAndLock(\n        address to,\n        uint256 amount,\n        uint256 unlockTime\n    ) external nonReentrant {\n        require(\n            owner() == msg.sender || hasRole(OPERATOR_ROLE, msg.sender),\n            \"Wrapper: Not authorized\"\n        );\n        require(to != address(0), \"Wrapper: Invalid recipient\");\n        require(amount > 0, \"Wrapper: Zero amount\");\n        require(unlockTime > block.timestamp, \"Wrapper: Invalid unlock time\");\n        \n        // Transfer sUSDC from owner to this contract\n        require(\n            sUSDC.transferFrom(msg.sender, address(this), amount),\n            \"Wrapper: Transfer failed\"\n        );\n        \n        // Update locked balance - use max to prevent reducing existing lock\n        if (unlockTime > lockedBalances[to].unlockTime) {\n            lockedBalances[to].unlockTime = unlockTime;\n        }\n        lockedBalances[to].amount = lockedBalances[to].amount + amount;\n        \n        // Mint SPUSD to recipient\n        spusd.mint(to, amount);\n        \n        emit LockedTokensMinted(to, amount, unlockTime);\n    }\n    \n    /**\n     * @notice Grant or revoke OPERATOR_ROLE\n     * @dev Only owner can call this\n     * @param operator Address to grant/revoke role\n     * @param granted True to grant, false to revoke\n     */\n    function setOperator(address operator, bool granted) external onlyOwner {\n        if (granted) {\n            grantRole(OPERATOR_ROLE, operator);\n        } else {\n            revokeRole(OPERATOR_ROLE, operator);\n        }\n    }\n    \n    /**\n     * @notice Check if address has locked tokens\n     * @param account Address to check\n     * @return locked Amount of locked tokens\n     * @return unlockTime When tokens unlock\n     */\n    function getLockInfo(address account) external view returns (uint256 locked, uint256 unlockTime) {\n        LockInfo memory lock = lockedBalances[account];\n        if (block.timestamp >= lock.unlockTime) {\n            return (0, 0);\n        }\n        return (lock.amount, lock.unlockTime);\n    }\n}"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.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     * Both values are immutable: they can only be set once during 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"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/access/AccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.20;\n\nimport {IAccessControl} from \"./IAccessControl.sol\";\nimport {Context} from \"../utils/Context.sol\";\nimport {ERC165} from \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address account => bool) hasRole;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 role => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with an {AccessControlUnauthorizedAccount} error including the required role.\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n        return _roles[role].hasRole[account];\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\n     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\n     * is missing `role`.\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert AccessControlUnauthorizedAccount(account, role);\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) public virtual {\n        if (callerConfirmation != _msgSender()) {\n            revert AccessControlBadConfirmation();\n        }\n\n        _revokeRole(role, callerConfirmation);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (!hasRole(role, account)) {\n            _roles[role].hasRole[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\n        if (hasRole(role, account)) {\n            _roles[role].hasRole[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n            return true;\n        } else {\n            return false;\n        }\n    }\n}\n"},"@openzeppelin/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (access/IAccessControl.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev External interface of AccessControl declared to support ERC-165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev The `account` is missing a role.\n     */\n    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\n\n    /**\n     * @dev The caller of a function is not the expected one.\n     *\n     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\n     */\n    error AccessControlBadConfirmation();\n\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted to signal this.\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).\n     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `callerConfirmation`.\n     */\n    function renounceRole(bytes32 role, address callerConfirmation) external;\n}\n"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"@openzeppelin/contracts/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"},"@openzeppelin/contracts/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":{"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"}},"stdJsonOutput":{"sources":{"contracts/SPUSD.sol":{"id":11},"contracts/StUSDCWrapper.sol":{"id":12},"@openzeppelin/contracts/utils/Context.sol":{"id":7},"@openzeppelin/contracts/access/Ownable.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":4},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":5},"@openzeppelin/contracts/access/AccessControl.sol":{"id":0},"@openzeppelin/contracts/access/IAccessControl.sol":{"id":1},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":8},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":3},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":9},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":10},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":6}},"contracts":{"contracts/StUSDCWrapper.sol":{"StUSDCWrapper":{"abi":[{"type":"constructor","inputs":[{"name":"_sUSDC","type":"address","internalType":"address"},{"name":"_spusd","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AccessControlBadConfirmation","type":"error","inputs":[]},{"name":"AccessControlUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"neededRole","type":"bytes32","internalType":"bytes32"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"LockedTokensMinted","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"unlockTime","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleAdminChanged","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"previousAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"newAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"RoleGranted","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleRevoked","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Unwrapped","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Wrapped","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"OPERATOR_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"getLockInfo","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"locked","type":"uint256","internalType":"uint256"},{"name":"unlockTime","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getRoleAdmin","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"grantRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"hasRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"lockedBalances","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"unlockTime","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"callerConfirmation","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"revokeRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"sUSDC","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IERC20"}],"stateMutability":"view"},{"name":"setOperator","type":"function","inputs":[{"name":"operator","type":"address","internalType":"address"},{"name":"granted","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"spusd","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract SPUSD"}],"stateMutability":"view"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unwrap","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"wrap","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"wrapAndLock","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"unlockTime","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_sUSDC\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_spusd\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AccessControlBadConfirmation\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"neededRole\",\"type\":\"bytes32\"}],\"name\":\"AccessControlUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"unlockTime\",\"type\":\"uint256\"}],\"name\":\"LockedTokensMinted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Unwrapped\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Wrapped\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"OPERATOR_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getLockInfo\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"locked\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"unlockTime\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"lockedBalances\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"unlockTime\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"callerConfirmation\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"sUSDC\",\"outputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"granted\",\"type\":\"bool\"}],\"name\":\"setOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"spusd\",\"outputs\":[{\"internalType\":\"contract SPUSD\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"unwrap\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"wrap\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"unlockTime\",\"type\":\"uint256\"}],\"name\":\"wrapAndLock\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Handles wrap/unwrap operations and locked tokens for investors\",\"errors\":{\"AccessControlBadConfirmation()\":[{\"details\":\"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\"}],\"AccessControlUnauthorizedAccount(address,bytes32)\":[{\"details\":\"The `account` is missing a role.\"}],\"OwnableInvalidOwner(address)\":[{\"details\":\"The owner is not a valid owner account. (eg. `address(0)`)\"}],\"OwnableUnauthorizedAccount(address)\":[{\"details\":\"The caller account is not authorized to perform an operation.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}]},\"events\":{\"RoleAdminChanged(bytes32,bytes32,bytes32)\":{\"details\":\"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this.\"},\"RoleGranted(bytes32,address,address)\":{\"details\":\"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.\"},\"RoleRevoked(bytes32,address,address)\":{\"details\":\"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)\"}},\"kind\":\"dev\",\"methods\":{\"getLockInfo(address)\":{\"params\":{\"account\":\"Address to check\"},\"returns\":{\"locked\":\"Amount of locked tokens\",\"unlockTime\":\"When tokens unlock\"}},\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event.\"},\"setOperator(address,bool)\":{\"details\":\"Only owner can call this\",\"params\":{\"granted\":\"True to grant, false to revoke\",\"operator\":\"Address to grant/revoke role\"}},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"unwrap(uint256)\":{\"params\":{\"amount\":\"Amount of SPUSD to unwrap\"}},\"wrap(uint256)\":{\"params\":{\"amount\":\"Amount of sUSDC to wrap\"}},\"wrapAndLock(address,uint256,uint256)\":{\"details\":\"Only owner can call this\",\"params\":{\"amount\":\"Amount to mint\",\"to\":\"Recipient address\",\"unlockTime\":\"Timestamp when tokens unlock\"}}},\"title\":\"StUSDCWrapper V2\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"getLockInfo(address)\":{\"notice\":\"Check if address has locked tokens\"},\"setOperator(address,bool)\":{\"notice\":\"Grant or revoke OPERATOR_ROLE\"},\"unwrap(uint256)\":{\"notice\":\"Unwrap SPUSD to get back sUSDC\"},\"wrap(uint256)\":{\"notice\":\"Wrap sUSDC to get SPUSD\"},\"wrapAndLock(address,uint256,uint256)\":{\"notice\":\"Mint locked SPUSD tokens for investors\"}},\"notice\":\"Wrapper contract for converting between sUSDC and SPUSD with lock support\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/StUSDCWrapper.sol\":\"StUSDCWrapper\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/access/AccessControl.sol\":{\"keccak256\":\"0xc1bebdee8943bd5e9ef1e0f2e63296aa1dd4171a66b9e74d0286220e891e1458\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://928cf2f0042c606f3dcb21bd8a272573f462a215cd65285d2d6b407f31e9bd67\",\"dweb:/ipfs/QmWGxjckno6sfjHPX5naPnsfsyisgy4PJDf46eLw9umfpx\"]},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"keccak256\":\"0x4d9a2b261b56a1e4a37bb038151dec98b952fed16de2bdfdda27e38e2b12b530\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f724110f7aeb6151af800ab8c12e6060b29bda9e013f0ccb331eb754d6a7cbf0\",\"dweb:/ipfs/QmUcjzCZpxtUPdEThtAzE1f9LvuJiUGZxTdH9N6bHrb5Cf\"]},\"@openzeppelin/contracts/access/Ownable.sol\":{\"keccak256\":\"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6\",\"dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a\"]},\"@openzeppelin/contracts/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b\",\"dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz\"]},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0x41f6b3b9e030561e7896dbef372b499cc8d418a80c3884a4d65a68f2fdc7493a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://80b0992a11b2fd1f75ced2971696d07bbd1d19ce6761dd50d8b6d48aa435f42a\",\"dweb:/ipfs/QmZDe5xd2gXHjVEjv9t8C1KQ68K5T8qFwdinwQgmP3rF3x\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf\",\"dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r\"]},\"@openzeppelin/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a\",\"dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA\"]},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"keccak256\":\"0xddce8e17e3d3f9ed818b4f4c4478a8262aab8b11ed322f1bf5ed705bb4bd97fa\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8084aa71a4cc7d2980972412a88fe4f114869faea3fefa5436431644eb5c0287\",\"dweb:/ipfs/Qmbqfs5dRdPvHVKY8kTaeyc65NdqXRQwRK7h9s5UJEhD1p\"]},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621\",\"dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL\"]},\"contracts/SPUSD.sol\":{\"keccak256\":\"0x370cb03c3fdc69fee3f01e22f77e6413e4f985f05ed7108839285ee634ad90b4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2e6e2db2ea0bdb52551c65db4ea32ee4b8282741b1305c631e3f1e2bb3fc1dc4\",\"dweb:/ipfs/QmZGTnjK2GtzfUCaPFBi9dGTs1eKxigH3igKYWWLWrrS8T\"]},\"contracts/StUSDCWrapper.sol\":{\"keccak256\":\"0x3d89d4fc211a185234e90eeb12b072ab4537ec2d75c5df1810a242a548ef8bf2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://50b584e31943ab495f917496ef2d3d3ea5b9913df8e16ae50b278e21a42b7d7b\",\"dweb:/ipfs/QmX317Lqt2wKWw1KUtbdgyLZLJ8frLSKBi1J6kiQpscCbN\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Wrapper contract for converting between sUSDC and SPUSD with lock support","methods":{"wrap(uint256)":{"notice":"Wrap sUSDC to get SPUSD"},"unwrap(uint256)":{"notice":"Unwrap SPUSD to get back sUSDC"},"getLockInfo(address)":{"notice":"Check if address has locked tokens"},"setOperator(address,bool)":{"notice":"Grant or revoke OPERATOR_ROLE"},"wrapAndLock(address,uint256,uint256)":{"notice":"Mint locked SPUSD tokens for investors"}},"version":1},"devdoc":{"kind":"dev","title":"StUSDCWrapper V2","errors":{"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"AccessControlBadConfirmation()":[{"details":"The caller of a function is not the expected one. NOTE: Don't confuse with {AccessControlUnauthorizedAccount}."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"AccessControlUnauthorizedAccount(address,bytes32)":[{"details":"The `account` is missing a role."}]},"events":{"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call. This account bears the admin role (for the granted role). Expected in cases where the role was granted using the internal {AccessControl-_grantRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted to signal this."}},"details":"Handles wrap/unwrap operations and locked tokens for investors","methods":{"owner()":{"details":"Returns the address of the current owner."},"wrap(uint256)":{"params":{"amount":"Amount of sUSDC to wrap"}},"unwrap(uint256)":{"params":{"amount":"Amount of SPUSD to unwrap"}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"getLockInfo(address)":{"params":{"account":"Address to check"},"returns":{"locked":"Amount of locked tokens","unlockTime":"When tokens unlock"}},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"setOperator(address,bool)":{"params":{"granted":"True to grant, false to revoke","operator":"Address to grant/revoke role"},"details":"Only owner can call this"},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `callerConfirmation`. May emit a {RoleRevoked} event."},"wrapAndLock(address,uint256,uint256)":{"params":{"to":"Recipient address","amount":"Amount to mint","unlockTime":"Timestamp when tokens unlock"},"details":"Only owner can call this"}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_struct(RoleData)21_storage":{"label":"struct AccessControl.RoleData","members":[{"slot":"0","type":"t_mapping(t_address,t_bool)","astId":18,"label":"hasRole","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"1","type":"t_bytes32","astId":20,"label":"adminRole","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"}],"encoding":"inplace","numberOfBytes":"64"},"t_struct(LockInfo)1535_storage":{"label":"struct StUSDCWrapper.LockInfo","members":[{"slot":"0","type":"t_uint256","astId":1532,"label":"amount","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"1","type":"t_uint256","astId":1534,"label":"unlockTime","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"}],"encoding":"inplace","numberOfBytes":"64"},"t_mapping(t_bytes32,t_struct(RoleData)21_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct AccessControl.RoleData)","value":"t_struct(RoleData)21_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_struct(LockInfo)1535_storage)":{"key":"t_address","label":"mapping(address => struct StUSDCWrapper.LockInfo)","value":"t_struct(LockInfo)1535_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":387,"label":"_owner","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"1","type":"t_mapping(t_bytes32,t_struct(RoleData)21_storage)","astId":26,"label":"_roles","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"2","type":"t_uint256","astId":1323,"label":"_status","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"},{"slot":"3","type":"t_mapping(t_address,t_struct(LockInfo)1535_storage)","astId":1540,"label":"lockedBalances","offset":0,"contract":"contracts/StUSDCWrapper.sol:StUSDCWrapper"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"60c060405234801561001057600080fd5b5060405161140138038061140183398101604081905261002f91610238565b338061005657604051631e4fbdf760e01b8152600060048201526024015b60405180910390fd5b61005f81610137565b5060016002556001600160a01b0382166100bb5760405162461bcd60e51b815260206004820152601660248201527f577261707065723a20496e76616c696420735553444300000000000000000000604482015260640161004d565b6001600160a01b0381166101115760405162461bcd60e51b815260206004820152601660248201527f577261707065723a20496e76616c696420535055534400000000000000000000604482015260640161004d565b6001600160a01b03808316608052811660a05261012f600033610187565b50505061026b565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b60008281526001602090815260408083206001600160a01b038516845290915281205460ff166102125760008381526001602081815260408084206001600160a01b0387168086529252808420805460ff19169093179092559051339286917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a4506001610216565b5060005b92915050565b80516001600160a01b038116811461023357600080fd5b919050565b6000806040838503121561024b57600080fd5b6102548361021c565b91506102626020840161021c565b90509250929050565b60805160a0516111406102c1600039600081816102a001528181610775015281816108c9015281816109a90152610bf40152600081816102220152818161064201528181610a270152610b4701526111406000f3fe608060405234801561001057600080fd5b506004361061012c5760003560e01c806391d14854116100ad578063de0e9a3e11610071578063de0e9a3e146102d5578063ea598cb0146102e8578063f2fde38b146102fb578063f5b541a61461030e578063ffa1ad741461032357600080fd5b806391d148541461026d578063a217fddf14610280578063b4dd2d7014610288578063d51225661461029b578063d547741f146102c257600080fd5b8063558a7297116100f4578063558a7297146101ef578063715018a6146102025780637238ccdb1461020a5780637c2e889a1461021d5780638da5cb5b1461025c57600080fd5b806301ffc9a7146101315780630483a7f614610159578063248a9ca3146101955780632f2ff15d146101c757806336568abe146101dc575b600080fd5b61014461013f366004610ea0565b610354565b60405190151581526020015b60405180910390f35b610180610167366004610eed565b6003602052600090815260409020805460019091015482565b60408051928352602083019190915201610150565b6101b96101a3366004610f08565b6000908152600160208190526040909120015490565b604051908152602001610150565b6101da6101d5366004610f21565b61038b565b005b6101da6101ea366004610f21565b6103b7565b6101da6101fd366004610f5b565b6103ef565b6101da610431565b610180610218366004610eed565b610445565b6102447f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b039091168152602001610150565b6000546001600160a01b0316610244565b61014461027b366004610f21565b61049c565b6101b9600081565b6101da610296366004610f92565b6104c7565b6102447f000000000000000000000000000000000000000000000000000000000000000081565b6101da6102d0366004610f21565b61081f565b6101da6102e3366004610f08565b610845565b6101da6102f6366004610f08565b610afd565b6101da610309366004610eed565b610c97565b6101b96000805160206110eb83398151915281565b610347604051806040016040528060058152602001640322e302e360dc1b81525081565b6040516101509190610fc5565b60006001600160e01b03198216637965db0b60e01b148061038557506301ffc9a760e01b6001600160e01b03198316145b92915050565b600082815260016020819052604090912001546103a781610cd2565b6103b18383610cdc565b50505050565b6001600160a01b03811633146103e05760405163334bd91960e11b815260040160405180910390fd5b6103ea8282610d55565b505050565b6103f7610dc2565b8015610419576104156000805160206110eb8339815191528361038b565b5050565b6104156000805160206110eb8339815191528361081f565b610439610dc2565b6104436000610def565b565b6001600160a01b0381166000908152600360209081526040808320815180830190925280548252600101549181018290528291421061048a5750600093849350915050565b80516020909101519094909350915050565b60009182526001602090815260408084206001600160a01b0393909316845291905290205460ff1690565b6104cf610e3f565b336104e26000546001600160a01b031690565b6001600160a01b0316148061050a575061050a6000805160206110eb8339815191523361049c565b61055b5760405162461bcd60e51b815260206004820152601760248201527f577261707065723a204e6f7420617574686f72697a656400000000000000000060448201526064015b60405180910390fd5b6001600160a01b0383166105b15760405162461bcd60e51b815260206004820152601a60248201527f577261707065723a20496e76616c696420726563697069656e740000000000006044820152606401610552565b600082116105d15760405162461bcd60e51b815260040161055290611013565b4281116106205760405162461bcd60e51b815260206004820152601c60248201527f577261707065723a20496e76616c696420756e6c6f636b2074696d65000000006044820152606401610552565b6040516323b872dd60e01b8152336004820152306024820152604481018390527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906323b872dd906064016020604051808303816000875af1158015610693573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106b79190611041565b6106d35760405162461bcd60e51b81526004016105529061105e565b6001600160a01b038316600090815260036020526040902060010154811115610715576001600160a01b03831660009081526003602052604090206001018190555b6001600160a01b0383166000908152600360205260409020546107399083906110ab565b6001600160a01b03848116600081815260036020526040908190209390935591516340c10f1960e01b81526004810192909252602482018490527f000000000000000000000000000000000000000000000000000000000000000016906340c10f1990604401600060405180830381600087803b1580156107b957600080fd5b505af11580156107cd573d6000803e3d6000fd5b505060408051858152602081018590526001600160a01b03871693507fccfee612f03daea509297438941f31c70c65dc410484ff699bbdb6830637f6b592500160405180910390a26103ea6001600255565b6000828152600160208190526040909120015461083b81610cd2565b6103b18383610d55565b61084d610e3f565b6000811161086d5760405162461bcd60e51b815260040161055290611013565b336000908152600360209081526040918290208251808401909352805480845260019091015491830191909152158015906108ab5750806020015142105b1561098d5780516040516370a0823160e01b815233600482015283907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906370a0823190602401602060405180830381865afa158015610918573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061093c91906110be565b61094691906110d7565b101561098d5760405162461bcd60e51b815260206004820152601660248201527515dc985c1c195c8e88151bdad95b9cc81b1bd8dad95960521b6044820152606401610552565b60405163079cc67960e41b8152336004820152602481018390527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906379cc679090604401600060405180830381600087803b1580156109f557600080fd5b505af1158015610a09573d6000803e3d6000fd5b505060405163a9059cbb60e01b8152336004820152602481018590527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316925063a9059cbb91506044016020604051808303816000875af1158015610a7a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a9e9190611041565b610aba5760405162461bcd60e51b81526004016105529061105e565b60405182815233907f95ae649bfaaef9def56a52f4fb2d9e8fa5496bb7082930e442c74cc76b03dcb39060200160405180910390a250610afa6001600255565b50565b610b05610e3f565b60008111610b255760405162461bcd60e51b815260040161055290611013565b6040516323b872dd60e01b8152336004820152306024820152604481018290527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906323b872dd906064016020604051808303816000875af1158015610b98573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bbc9190611041565b610bd85760405162461bcd60e51b81526004016105529061105e565b6040516340c10f1960e01b8152336004820152602481018290527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906340c10f1990604401600060405180830381600087803b158015610c4057600080fd5b505af1158015610c54573d6000803e3d6000fd5b50506040518381523392507f4700c1726b4198077cd40320a32c45265a1910521eb0ef713dd1d8412413d7fc915060200160405180910390a2610afa6001600255565b610c9f610dc2565b6001600160a01b038116610cc957604051631e4fbdf760e01b815260006004820152602401610552565b610afa81610def565b610afa8133610e67565b6000610ce8838361049c565b610d4d5760008381526001602081815260408084206001600160a01b0387168086529252808420805460ff19169093179092559051339286917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a4506001610385565b506000610385565b6000610d61838361049c565b15610d4d5760008381526001602090815260408083206001600160a01b0386168085529252808320805460ff1916905551339286917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a4506001610385565b6000546001600160a01b031633146104435760405163118cdaa760e01b8152336004820152602401610552565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6002805403610e6157604051633ee5aeb560e01b815260040160405180910390fd5b60028055565b610e71828261049c565b6104155760405163e2517d3f60e01b81526001600160a01b038216600482015260248101839052604401610552565b600060208284031215610eb257600080fd5b81356001600160e01b031981168114610eca57600080fd5b9392505050565b80356001600160a01b0381168114610ee857600080fd5b919050565b600060208284031215610eff57600080fd5b610eca82610ed1565b600060208284031215610f1a57600080fd5b5035919050565b60008060408385031215610f3457600080fd5b82359150610f4460208401610ed1565b90509250929050565b8015158114610afa57600080fd5b60008060408385031215610f6e57600080fd5b610f7783610ed1565b91506020830135610f8781610f4d565b809150509250929050565b600080600060608486031215610fa757600080fd5b610fb084610ed1565b95602085013595506040909401359392505050565b602081526000825180602084015260005b81811015610ff35760208186018101516040868401015201610fd6565b506000604082850101526040601f19601f83011684010191505092915050565b60208082526014908201527315dc985c1c195c8e8816995c9bc8185b5bdd5b9d60621b604082015260600190565b60006020828403121561105357600080fd5b8151610eca81610f4d565b60208082526018908201527f577261707065723a205472616e73666572206661696c65640000000000000000604082015260600190565b634e487b7160e01b600052601160045260246000fd5b8082018082111561038557610385611095565b6000602082840312156110d057600080fd5b5051919050565b818103818111156103855761038561109556fe97667070c54ef182b0f5858b034beac1b6f3089aa2d3188bb1e8929f4fa9b929a2646970667358221220e055013225ada0547ecf4cd0b01b5b43164858ca1551f56b1281fd8a41f7971264736f6c634300081c0033","sourceMap":"501:4749:12:-:0;;;1211:334;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1263:10;;1269:95:2;;1322:31;;-1:-1:-1;;;1322:31:2;;1350:1;1322:31;;;640:51:13;613:18;;1322:31:2;;;;;;;;1269:95;1373:32;1392:12;1373:18;:32::i;:::-;-1:-1:-1;1857:1:8;2061:7;:21;-1:-1:-1;;;;;1293:20:12;::::1;1285:55;;;::::0;-1:-1:-1;;;1285:55:12;;904:2:13;1285:55:12::1;::::0;::::1;886:21:13::0;943:2;923:18;;;916:30;982:24;962:18;;;955:52;1024:18;;1285:55:12::1;702:346:13::0;1285:55:12::1;-1:-1:-1::0;;;;;1358:20:12;::::1;1350:55;;;::::0;-1:-1:-1;;;1350:55:12;;1255:2:13;1350:55:12::1;::::0;::::1;1237:21:13::0;1294:2;1274:18;;;1267:30;1333:24;1313:18;;;1306:52;1375:18;;1350:55:12::1;1053:346:13::0;1350:55:12::1;-1:-1:-1::0;;;;;1424:22:12;;::::1;;::::0;1456:21;::::1;;::::0;1496:42:::1;2232:4:0;1527:10:12;1496;:42::i;:::-;;1211:334:::0;;501:4749;;2912:187:2;2985:16;3004:6;;-1:-1:-1;;;;;3020:17:2;;;-1:-1:-1;;;;;;3020:17:2;;;;;;3052:40;;3004:6;;;;;;;3052:40;;2985:16;3052:40;2975:124;2912:187;:::o;6179:316:0:-;6256:4;2954:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;2954:29:0;;;;;;;;;;;;6272:217;;6315:12;;;;6347:4;6315:12;;;;;;;;-1:-1:-1;;;;;6315:29:0;;;;;;;;;;:36;;-1:-1:-1;;6315:36:0;;;;;;;6370:40;;735:10:7;;6315:12:0;;6370:40;;6315:12;6370:40;-1:-1:-1;6431:4:0;6424:11;;6272:217;-1:-1:-1;6473:5:0;6272:217;6179:316;;;;:::o;14:177:13:-;93:13;;-1:-1:-1;;;;;135:31:13;;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;1053:346::-;501:4749:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"501:4749:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2565:202:0;;;;;;:::i;:::-;;:::i;:::-;;;470:14:13;;463:22;445:41;;433:2;418:18;2565:202:0;;;;;;;;929:50:12;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;1040:25:13;;;1096:2;1081:18;;1074:34;;;;1013:18;929:50:12;866:248:13;3810:120:0;;;;;;:::i;:::-;3875:7;3901:12;;;:6;:12;;;;;;;;:22;;;3810:120;;;;1496:25:13;;;1484:2;1469:18;3810:120:0;1350:177:13;4226:136:0;;;;;;:::i;:::-;;:::i;:::-;;5328:245;;;;;;:::i;:::-;;:::i;4522:226:12:-;;;;;;:::i;:::-;;:::i;2293:101:2:-;;;:::i;4954:294:12:-;;;;;;:::i;:::-;;:::i;741:29::-;;;;;;;;-1:-1:-1;;;;;2459:32:13;;;2441:51;;2429:2;2414:18;741:29:12;2280:218:13;1638:85:2;1684:7;1710:6;-1:-1:-1;;;;;1710:6:2;1638:85;;2854:136:0;;;;;;:::i;:::-;;:::i;2187:49::-;;2232:4;2187:49;;3224:1085:12;;;;;;:::i;:::-;;:::i;776:28::-;;;;;4642:138:0;;;;;;:::i;:::-;;:::i;2223:759:12:-;;;;;;:::i;:::-;;:::i;1655:449::-;;;;;;:::i;:::-;;:::i;2543:215:2:-;;;;;;:::i;:::-;;:::i;664:66:12:-;;-1:-1:-1;;;;;;;;;;;664:66:12;;618:40;;;;;;;;;;;;;;;-1:-1:-1;;;618:40:12;;;;;;;;;;;;:::i;2565:202:0:-;2650:4;-1:-1:-1;;;;;;2673:47:0;;-1:-1:-1;;;2673:47:0;;:87;;-1:-1:-1;;;;;;;;;;862:40:9;;;2724:36:0;2666:94;2565:202;-1:-1:-1;;2565:202:0:o;4226:136::-;3875:7;3901:12;;;:6;:12;;;;;;;;:22;;2464:16;2475:4;2464:10;:16::i;:::-;4330:25:::1;4341:4;4347:7;4330:10;:25::i;:::-;;4226:136:::0;;;:::o;5328:245::-;-1:-1:-1;;;;;5421:34:0;;735:10:7;5421:34:0;5417:102;;5478:30;;-1:-1:-1;;;5478:30:0;;;;;;;;;;;5417:102;5529:37;5541:4;5547:18;5529:11;:37::i;:::-;;5328:245;;:::o;4522:226:12:-;1531:13:2;:11;:13::i;:::-;4608:7:12::1;4604:138;;;4631:34;-1:-1:-1::0;;;;;;;;;;;4656:8:12::1;4631:9;:34::i;:::-;4522:226:::0;;:::o;4604:138::-:1;4696:35;-1:-1:-1::0;;;;;;;;;;;4722:8:12::1;4696:10;:35::i;2293:101:2:-:0;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;4954:294:12:-;-1:-1:-1;;;;;5084:23:12;;5015:14;5084:23;;;:14;:23;;;;;;;;5061:46;;;;;;;;;;;;;;;;;;;;;5015:14;;5121:15;:34;5117:78;;-1:-1:-1;5179:1:12;;;;-1:-1:-1;4954:294:12;-1:-1:-1;;4954:294:12:o;5117:78::-;5212:11;;5225:15;;;;;5212:11;;5225:15;;-1:-1:-1;4954:294:12;-1:-1:-1;;4954:294:12:o;2854:136:0:-;2931:4;2954:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;2954:29:0;;;;;;;;;;;;;;;2854:136::o;3224:1085:12:-;2500:21:8;:19;:21::i;:::-;3387:10:12::1;3376:7;1684::2::0;1710:6;-1:-1:-1;;;;;1710:6:2;;1638:85;3376:7:12::1;-1:-1:-1::0;;;;;3376:21:12::1;;:59;;;;3401:34;-1:-1:-1::0;;;;;;;;;;;3424:10:12::1;3401:7;:34::i;:::-;3355:129;;;::::0;-1:-1:-1;;;3355:129:12;;4323:2:13;3355:129:12::1;::::0;::::1;4305:21:13::0;4362:2;4342:18;;;4335:30;4401:25;4381:18;;;4374:53;4444:18;;3355:129:12::1;;;;;;;;;-1:-1:-1::0;;;;;3502:16:12;::::1;3494:55;;;::::0;-1:-1:-1;;;3494:55:12;;4675:2:13;3494:55:12::1;::::0;::::1;4657:21:13::0;4714:2;4694:18;;;4687:30;4753:28;4733:18;;;4726:56;4799:18;;3494:55:12::1;4473:350:13::0;3494:55:12::1;3576:1;3567:6;:10;3559:43;;;;-1:-1:-1::0;;;3559:43:12::1;;;;;;;:::i;:::-;3633:15;3620:10;:28;3612:69;;;::::0;-1:-1:-1;;;3612:69:12;;5379:2:13;3612:69:12::1;::::0;::::1;5361:21:13::0;5418:2;5398:18;;;5391:30;5457;5437:18;;;5430:58;5505:18;;3612:69:12::1;5177:352:13::0;3612:69:12::1;3775:53;::::0;-1:-1:-1;;;3775:53:12;;3794:10:::1;3775:53;::::0;::::1;5736:51:13::0;3814:4:12::1;5803:18:13::0;;;5796:60;5872:18;;;5865:34;;;3775:5:12::1;-1:-1:-1::0;;;;;3775:18:12::1;::::0;::::1;::::0;5709::13;;3775:53:12::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3754:124;;;;-1:-1:-1::0;;;3754:124:12::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;3991:18:12;::::1;;::::0;;;:14:::1;:18;::::0;;;;:29:::1;;::::0;3978:42;::::1;3974:115;;;-1:-1:-1::0;;;;;4036:18:12;::::1;;::::0;;;:14:::1;:18;::::0;;;;:29:::1;;:42:::0;;;3974:115:::1;-1:-1:-1::0;;;;;4126:18:12;::::1;;::::0;;;:14:::1;:18;::::0;;;;:25;:34:::1;::::0;4154:6;;4126:34:::1;:::i;:::-;-1:-1:-1::0;;;;;4098:18:12;;::::1;;::::0;;;:14:::1;:18;::::0;;;;;;:62;;;;4214:22;;-1:-1:-1;;;4214:22:12;;::::1;::::0;::::1;6949:51:13::0;;;;7016:18;;;7009:34;;;4214:5:12::1;:10;::::0;::::1;::::0;6922:18:13;;4214:22:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;4260:42:12::1;::::0;;1040:25:13;;;1096:2;1081:18;;1074:34;;;-1:-1:-1;;;;;4260:42:12;::::1;::::0;-1:-1:-1;4260:42:12::1;::::0;-1:-1:-1;1013:18:13;4260:42:12::1;;;;;;;2542:20:8::0;1857:1;3068:7;:21;2888:208;4642:138:0;3875:7;3901:12;;;:6;:12;;;;;;;;:22;;2464:16;2475:4;2464:10;:16::i;:::-;4747:26:::1;4759:4;4765:7;4747:11;:26::i;2223:759:12:-:0;2500:21:8;:19;:21::i;:::-;2304:1:12::1;2295:6;:10;2287:43;;;;-1:-1:-1::0;;;2287:43:12::1;;;;;;;:::i;:::-;2430:10;2392:20;2415:26:::0;;;:14:::1;:26;::::0;;;;;;;;2392:49;;;;::::1;::::0;;;;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;2455:15;;;;:52:::1;;;2492:4;:15;;;2474;:33;2455:52;2451:215;;;2588:11:::0;;2548:27:::1;::::0;-1:-1:-1;;;2548:27:12;;2564:10:::1;2548:27;::::0;::::1;2441:51:13::0;2578:6:12;;2548:5:::1;-1:-1:-1::0;;;;;2548:15:12::1;::::0;::::1;::::0;2414:18:13;;2548:27:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;;;;:::i;:::-;:51;;2523:132;;;::::0;-1:-1:-1;;;2523:132:12;;7578:2:13;2523:132:12::1;::::0;::::1;7560:21:13::0;7617:2;7597:18;;;7590:30;-1:-1:-1;;;7636:18:13;;;7629:52;7698:18;;2523:132:12::1;7376:346:13::0;2523:132:12::1;2725:34;::::0;-1:-1:-1;;;2725:34:12;;2740:10:::1;2725:34;::::0;::::1;6949:51:13::0;7016:18;;;7009:34;;;2725:5:12::1;-1:-1:-1::0;;;;;2725:14:12::1;::::0;::::1;::::0;6922:18:13;;2725:34:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;2838:34:12::1;::::0;-1:-1:-1;;;2838:34:12;;2853:10:::1;2838:34;::::0;::::1;6949:51:13::0;7016:18;;;7009:34;;;2838:5:12::1;-1:-1:-1::0;;;;;2838:14:12::1;::::0;-1:-1:-1;2838:14:12::1;::::0;-1:-1:-1;6922:18:13;;2838:34:12::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2817:105;;;;-1:-1:-1::0;;;2817:105:12::1;;;;;;;:::i;:::-;2946:29;::::0;1496:25:13;;;2956:10:12::1;::::0;2946:29:::1;::::0;1484:2:13;1469:18;2946:29:12::1;;;;;;;2277:705;2542:20:8::0;1857:1;3068:7;:21;2888:208;2542:20;2223:759:12;:::o;1655:449::-;2500:21:8;:19;:21::i;:::-;1734:1:12::1;1725:6;:10;1717:43;;;;-1:-1:-1::0;;;1717:43:12::1;;;;;;;:::i;:::-;1853:53;::::0;-1:-1:-1;;;1853:53:12;;1872:10:::1;1853:53;::::0;::::1;5736:51:13::0;1892:4:12::1;5803:18:13::0;;;5796:60;5872:18;;;5865:34;;;1853:5:12::1;-1:-1:-1::0;;;;;1853:18:12::1;::::0;::::1;::::0;5709::13;;1853:53:12::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1832:124;;;;-1:-1:-1::0;;;1832:124:12::1;;;;;;;:::i;:::-;2016:30;::::0;-1:-1:-1;;;2016:30:12;;2027:10:::1;2016:30;::::0;::::1;6949:51:13::0;7016:18;;;7009:34;;;2016:5:12::1;-1:-1:-1::0;;;;;2016:10:12::1;::::0;::::1;::::0;6922:18:13;;2016:30:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;2070:27:12::1;::::0;1496:25:13;;;2078:10:12::1;::::0;-1:-1:-1;2070:27:12::1;::::0;-1:-1:-1;1484:2:13;1469:18;2070:27:12::1;;;;;;;2542:20:8::0;1857:1;3068:7;:21;2888:208;2543:215:2;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:2;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:2;;2700:1:::1;2672:31;::::0;::::1;2441:51:13::0;2414:18;;2672:31:2::1;2280:218:13::0;2623:91:2::1;2723:28;2742:8;2723:18;:28::i;3199:103:0:-:0;3265:30;3276:4;735:10:7;3265::0;:30::i;6179:316::-;6256:4;6277:22;6285:4;6291:7;6277;:22::i;:::-;6272:217;;6315:12;;;;6347:4;6315:12;;;;;;;;-1:-1:-1;;;;;6315:29:0;;;;;;;;;;:36;;-1:-1:-1;;6315:36:0;;;;;;;6370:40;;735:10:7;;6315:12:0;;6370:40;;6315:12;6370:40;-1:-1:-1;6431:4:0;6424:11;;6272:217;-1:-1:-1;6473:5:0;6466:12;;6732:317;6810:4;6830:22;6838:4;6844:7;6830;:22::i;:::-;6826:217;;;6900:5;6868:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;6868:29:0;;;;;;;;;;:37;;-1:-1:-1;;6868:37:0;;;6924:40;735:10:7;;6868:12:0;;6924:40;;6900:5;6924:40;-1:-1:-1;6985:4:0;6978:11;;1796:162:2;1684:7;1710:6;-1:-1:-1;;;;;1710:6:2;735:10:7;1855:23:2;1851:101;;1901:40;;-1:-1:-1;;;1901:40:2;;735:10:7;1901:40:2;;;2441:51:13;2414:18;;1901:40:2;2280:218:13;2912:187:2;2985:16;3004:6;;-1:-1:-1;;;;;3020:17:2;;;-1:-1:-1;;;;;;3020:17:2;;;;;;3052:40;;3004:6;;;;;;;3052:40;;2985:16;3052:40;2975:124;2912:187;:::o;2575:307:8:-;1899:1;2702:7;;:18;2698:86;;2743:30;;-1:-1:-1;;;2743:30:8;;;;;;;;;;;2698:86;1899:1;2858:17;;2575:307::o;3432:197:0:-;3520:22;3528:4;3534:7;3520;:22::i;:::-;3515:108;;3565:47;;-1:-1:-1;;;3565:47:0;;-1:-1:-1;;;;;6967:32:13;;3565:47:0;;;6949:51:13;7016:18;;;7009:34;;;6922:18;;3565:47:0;6775:274:13;14:286;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:13;;209:43;;199:71;;266:1;263;256:12;199:71;289:5;14:286;-1:-1:-1;;;14:286:13:o;497:173::-;565:20;;-1:-1:-1;;;;;614:31:13;;604:42;;594:70;;660:1;657;650:12;594:70;497:173;;;:::o;675:186::-;734:6;787:2;775:9;766:7;762:23;758:32;755:52;;;803:1;800;793:12;755:52;826:29;845:9;826:29;:::i;1119:226::-;1178:6;1231:2;1219:9;1210:7;1206:23;1202:32;1199:52;;;1247:1;1244;1237:12;1199:52;-1:-1:-1;1292:23:13;;1119:226;-1:-1:-1;1119:226:13:o;1532:300::-;1600:6;1608;1661:2;1649:9;1640:7;1636:23;1632:32;1629:52;;;1677:1;1674;1667:12;1629:52;1722:23;;;-1:-1:-1;1788:38:13;1822:2;1807:18;;1788:38;:::i;:::-;1778:48;;1532:300;;;;;:::o;1837:118::-;1923:5;1916:13;1909:21;1902:5;1899:32;1889:60;;1945:1;1942;1935:12;1960:315;2025:6;2033;2086:2;2074:9;2065:7;2061:23;2057:32;2054:52;;;2102:1;2099;2092:12;2054:52;2125:29;2144:9;2125:29;:::i;:::-;2115:39;;2204:2;2193:9;2189:18;2176:32;2217:28;2239:5;2217:28;:::i;:::-;2264:5;2254:15;;;1960:315;;;;;:::o;2711:420::-;2788:6;2796;2804;2857:2;2845:9;2836:7;2832:23;2828:32;2825:52;;;2873:1;2870;2863:12;2825:52;2896:29;2915:9;2896:29;:::i;:::-;2886:39;2994:2;2979:18;;2966:32;;-1:-1:-1;3095:2:13;3080:18;;;3067:32;;2711:420;-1:-1:-1;;;2711:420:13:o;3589:527::-;3738:2;3727:9;3720:21;3701:4;3770:6;3764:13;3813:6;3808:2;3797:9;3793:18;3786:34;3838:1;3848:140;3862:6;3859:1;3856:13;3848:140;;;3973:2;3957:14;;;3953:23;;3947:30;3942:2;3923:17;;;3919:26;3912:66;3877:10;3848:140;;;3852:3;4037:1;4032:2;4023:6;4012:9;4008:22;4004:31;3997:42;4107:2;4100;4096:7;4091:2;4083:6;4079:15;4075:29;4064:9;4060:45;4056:54;4048:62;;;3589:527;;;;:::o;4828:344::-;5030:2;5012:21;;;5069:2;5049:18;;;5042:30;-1:-1:-1;;;5103:2:13;5088:18;;5081:50;5163:2;5148:18;;4828:344::o;5910:245::-;5977:6;6030:2;6018:9;6009:7;6005:23;6001:32;5998:52;;;6046:1;6043;6036:12;5998:52;6078:9;6072:16;6097:28;6119:5;6097:28;:::i;6160:348::-;6362:2;6344:21;;;6401:2;6381:18;;;6374:30;6440:26;6435:2;6420:18;;6413:54;6499:2;6484:18;;6160:348::o;6513:127::-;6574:10;6569:3;6565:20;6562:1;6555:31;6605:4;6602:1;6595:15;6629:4;6626:1;6619:15;6645:125;6710:9;;;6731:10;;;6728:36;;;6744:18;;:::i;7054:184::-;7124:6;7177:2;7165:9;7156:7;7152:23;7148:32;7145:52;;;7193:1;7190;7183:12;7145:52;-1:-1:-1;7216:16:13;;7054:184;-1:-1:-1;7054:184:13:o;7243:128::-;7310:9;;;7331:11;;;7328:37;;;7345:18;;:::i","linkReferences":{},"immutableReferences":{"1527":[{"start":546,"length":32},{"start":1602,"length":32},{"start":2599,"length":32},{"start":2887,"length":32}],"1530":[{"start":672,"length":32},{"start":1909,"length":32},{"start":2249,"length":32},{"start":2473,"length":32},{"start":3060,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"DEFAULT_ADMIN_ROLE()","signatureHash4":"0xa217fddf","signatureHash32":"0xa217fddfde7807bb766525e432eeeecaaf4de889a05e8df9fb827257fb978cf4"},{"signature":"getLockInfo(address)","signatureHash4":"0x7238ccdb","signatureHash32":"0x7238ccdb99266f40bb064c19964bba75d7928a7576cd7a38bfe922d1112164b4"},{"signature":"getRoleAdmin(bytes32)","signatureHash4":"0x248a9ca3","signatureHash32":"0x248a9ca39e7e298ea3bbd193e7d36b87492efea84ff513fd03940aaa5bc0d98f"},{"signature":"grantRole(bytes32,address)","signatureHash4":"0x2f2ff15d","signatureHash32":"0x2f2ff15deca029b64bbc0874ae59c8f39be024a95aa718b4c13ca407db350be8"},{"signature":"hasRole(bytes32,address)","signatureHash4":"0x91d14854","signatureHash32":"0x91d1485424b278bc736d5d34907ed48280c7188845bc82b33370da2b4dc1194e"},{"signature":"lockedBalances(address)","signatureHash4":"0x0483a7f6","signatureHash32":"0x0483a7f653f1e82998c4948cc701f10490521d667faade2aef9b040a66a5de1d"},{"signature":"OPERATOR_ROLE()","signatureHash4":"0xf5b541a6","signatureHash32":"0xf5b541a666f83decfedf7eae304948070ddffd671629a935a19ad2772493494c"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"renounceRole(bytes32,address)","signatureHash4":"0x36568abe","signatureHash32":"0x36568abe2c7e6c1d662bad0fe1760ac72cf2f9478a86be824d68ec83895c49e9"},{"signature":"revokeRole(bytes32,address)","signatureHash4":"0xd547741f","signatureHash32":"0xd547741fd8d55981251e167708119763c372f2b41e85a1468b0a759b055a009f"},{"signature":"setOperator(address,bool)","signatureHash4":"0x558a7297","signatureHash32":"0x558a7297e60ce7d5583faecd6aae4a6ab582122664c6d398de0fd446fc6bd50c"},{"signature":"spusd()","signatureHash4":"0xd5122566","signatureHash32":"0xd512256604fedd03daf4564d08bac97c6d96ba54bae3b9acbb5238409015ae99"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"sUSDC()","signatureHash4":"0x7c2e889a","signatureHash32":"0x7c2e889ae8d27c4c52078fdf0b407d01bb24babfa0cac5b8b75421a79b94fe3b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"unwrap(uint256)","signatureHash4":"0xde0e9a3e","signatureHash32":"0xde0e9a3ebe15671cae7984340cb13c8032c69529866ee1eb6813c943d8ac1f70"},{"signature":"VERSION()","signatureHash4":"0xffa1ad74","signatureHash32":"0xffa1ad74ba96b4c159a84d090433911c3991c54f629eb60d0c84aed3be5f067c"},{"signature":"wrapAndLock(address,uint256,uint256)","signatureHash4":"0xb4dd2d70","signatureHash32":"0xb4dd2d70da0409821b5adb1d823c0d740fafb32e612a7ba7d874d90e291b6865"},{"signature":"wrap(uint256)","signatureHash4":"0xea598cb0","signatureHash32":"0xea598cb0148282ef17c150c03a6801f0ba608751abe373b8bdebcf2f497f6492"}],"event":[{"signature":"LockedTokensMinted(address,uint256,uint256)","signatureHash4":"0xccfee612","signatureHash32":"0xccfee612f03daea509297438941f31c70c65dc410484ff699bbdb6830637f6b5"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"RoleAdminChanged(bytes32,bytes32,bytes32)","signatureHash4":"0xbd79b86f","signatureHash32":"0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff"},{"signature":"RoleGranted(bytes32,address,address)","signatureHash4":"0x2f878811","signatureHash32":"0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d"},{"signature":"RoleRevoked(bytes32,address,address)","signatureHash4":"0xf6391f5c","signatureHash32":"0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b"},{"signature":"Unwrapped(address,uint256)","signatureHash4":"0x95ae649b","signatureHash32":"0x95ae649bfaaef9def56a52f4fb2d9e8fa5496bb7082930e442c74cc76b03dcb3"},{"signature":"Wrapped(address,uint256)","signatureHash4":"0x4700c172","signatureHash32":"0x4700c1726b4198077cd40320a32c45265a1910521eb0ef713dd1d8412413d7fc"}],"error":[{"signature":"AccessControlBadConfirmation()","signatureHash4":"0x6697b232","signatureHash32":"0x6697b23232a647058342c0724fe7c415cab25915b54e5dbc03f233173d37b41c"},{"signature":"AccessControlUnauthorizedAccount(address,bytes32)","signatureHash4":"0xe2517d3f","signatureHash32":"0xe2517d3fbfae6f8515ef5ff1ccedc3933ab0cbbda0b492c06eb54ad10ef03b3e"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"ReentrancyGuardReentrantCall()","signatureHash4":"0x3ee5aeb5","signatureHash32":"0x3ee5aeb571de7fc460830b4d0017439a1ca56fb0bc39062227ade4fe4a24c1ca"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0x0e8fB2E774b827711e0F86069931C1321113238e"}