{"matchId":"30094368","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-05-27T18:37:23Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1694:7590:6:-:0;;;3038:858;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3445:12;:28;;-1:-1:-1;;;;;;3445:28:6;;;-1:-1:-1;;;;;3445:28:6;;;;;;;;;;3483:3;:10;;;;;;;;;;3503:12;:28;;;;;;;;;;3541:17;:38;;;;;;;;;;3589:12;:28;;;;;;;;;;3627:15;:34;;;;;;;;;;3671:15;:34;;;;;;;;;;3715:16;:36;;;;;;;;;;3761:21;:46;;;;;;;;;;3817:16;:36;;;;;;;;;;;;;;3863:26;3882:6;3863:18;:26::i;:::-;3038:858;;;;;;;;;;;1694:7590;;1213:185:7;1286:16;1305:5;;-1:-1:-1;;;;;1320:16:7;;;-1:-1:-1;;;;;;1320:16:7;;;;;;1351:40;;1305:5;;;;;;;1351:40;;1286:16;1351:40;1276:122;1213:185;:::o;14:131:28:-;-1:-1:-1;;;;;89:31:28;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:138::-;229:13;;251:31;229:13;251:31;:::i;:::-;150:138;;;:::o;293:1553::-;559:6;567;575;583;591;599;607;615;623;631;639:7;693:3;681:9;672:7;668:23;664:33;661:53;;;710:1;707;700:12;661:53;742:9;736:16;761:31;786:5;761:31;:::i;:::-;861:2;846:18;;840:25;811:5;;-1:-1:-1;874:33:28;840:25;874:33;:::i;:::-;978:2;963:18;;957:25;926:7;;-1:-1:-1;991:33:28;957:25;991:33;:::i;:::-;1095:2;1080:18;;1074:25;1043:7;;-1:-1:-1;1108:33:28;1074:25;1108:33;:::i;:::-;1212:3;1197:19;;1191:26;1160:7;;-1:-1:-1;1226:33:28;1191:26;1226:33;:::i;:::-;1351:3;1336:19;;1330:26;1278:7;;-1:-1:-1;1365:33:28;1330:26;1365:33;:::i;:::-;1490:3;1475:19;;1469:26;1417:7;;-1:-1:-1;1504:33:28;1469:26;1504:33;:::i;:::-;1556:7;-1:-1:-1;1582:50:28;1627:3;1612:19;;1582:50;:::i;:::-;1572:60;;1651:50;1696:3;1685:9;1681:19;1651:50;:::i;:::-;1641:60;;1720:50;1765:3;1754:9;1750:19;1720:50;:::i;:::-;1710:60;;1790:50;1835:3;1824:9;1820:19;1790:50;:::i;:::-;1779:61;;293:1553;;;;;;;;;;;;;;:::o;:::-;1694:7590:6;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212202a97d37236bb4197f710df287c53c2bbfdc9e7a4c97362a18c984309a33db49964736f6c634300081c0033","offset":6750}},"transformations":[{"type":"insert","offset":6803,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000461b62cb3a7e9df8f800ae058ae92f855f2c27ca000000000000000000000000f3f7669dceed2f985815011c19ed68f667267215000000000000000000000000b1c2db5d6ca03fce73dbd304d320bf76c55ae1b1000000000000000000000000b4e1d3bbd2843263d58b4d648c599512cea6e88b0000000000000000000000001461d76aa1c9c523398301d9174098c6d53ce639000000000000000000000000a9e0021d8917c51f496823605d218d7e78719c9900000000000000000000000068e75bfc46fe4cd2eaa1ceb1fd68990916a0ebfb000000000000000000000000a6c6193abaf2f1b72ed251984d391eaac7c31e77000000000000000000000000d7a63e1ffff888488db275189078282da8a4e638000000000000000000000000bce94d131b288590f1ef1f62622865ba1fa514e4000000000000000000000000b10ec742bc530b4fd5484f6364993d9bd98642b8"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1694:7590:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2423:36;;;;;;;;;;;;190:42:28;178:55;;;160:74;;148:2;133:18;2423:36:6;;;;;;;1800:33;;;;;;;;;2248:30;;;;;;;;;5628:480;;;;;;:::i;:::-;;:::i;7323:553::-;;;;;;:::i;:::-;;:::i;2335:31::-;;;;;;;;;2073:33;;;;;;;;;1866:15;;;;;;;;;102:20:7;;;;;;;;;8290:462:6;;;;;;:::i;:::-;;:::i;1918:33::-;;;;;;;;;6473:485;;;;;;:::i;:::-;;:::i;2516:31::-;;;;;;;;;1993:43;;;;;;;;;844:215:7;;;;;;:::i;:::-;;:::i;:::-;;4729:480:6;;;;;;:::i;:::-;;:::i;2162:30::-;;;;;;;;;5628:480;5792:7;435:13:7;:11;:13::i;:::-;5827:15:6::1;::::0;5811:13:::1;::::0;5827:23:::1;::::0;:15:::1;;:21;:23::i;:::-;5811:39;;5879:5;5860:36;;;5897:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;5897:18:::1;5917:11;5930:4;5860:75;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5945:72;5963:5;5970:9;5981:11;:24;;;;;;;;:::i;:::-;6007:9;5945:17;:72::i;:::-;6032:47;6055:5:::0;6062:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;:::-;6032:47;;;;;;;;:::i;:::-;;;;;;;;6096:5:::0;5628:480;-1:-1:-1;;;;;5628:480:6:o;7323:553::-;7542:7;435:13:7;:11;:13::i;:::-;7577:21:6::1;::::0;7561:13:::1;::::0;7577:29:::1;::::0;:21:::1;;:27;:29::i;:::-;7561:45;;7639:5;7616:40;;;7657:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;7657:18:::1;7677:11;7690:6;7616:81;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7707:72;7725:5;7732:9;7743:11;:24;;;;;;;;:::i;7707:72::-;7794:53;7823:5:::0;7830:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;8290:462::-:0;8441:7;435:13:7;:11;:13::i;:::-;8476:16:6::1;::::0;8460:13:::1;::::0;8476:24:::1;::::0;:16:::1;;:22;:24::i;:::-;8460:40;;8528:5;8510:35;;;8546:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;8546:18:::1;8566:11;8510:68;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8588:72;8606:5;8613:9;8624:11;:24;;;;;;;;:::i;8588:72::-;8675:48;8699:5:::0;8706:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;:::-;8675:48;;;;;;;;:::i;:::-;;;;;;;;8740:5:::0;8290:462;-1:-1:-1;;;;8290:462:6:o;6473:485::-;6639:7;435:13:7;:11;:13::i;:::-;6674:16:6::1;::::0;6658:13:::1;::::0;6674:24:::1;::::0;:16:::1;;:22;:24::i;:::-;6658:40;;6726:5;6708:35;;;6744:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;6744:18:::1;6764:11;6777:6;6708:76;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6794:72;6812:5;6819:9;6830:11;:24;;;;;;;;:::i;6794:72::-;6881:48;6905:5:::0;6912:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;844:215:7:-:0;435:13;:11;:13::i;:::-;928:22:::1;::::0;::::1;924:91;;973:31;::::0;::::1;::::0;;1001:1:::1;973:31;::::0;::::1;160:74:28::0;133:18;;973:31:7::1;;;;;;;;924:91;1024:28;1043:8;1024:18;:28::i;:::-;844:215:::0;:::o;4729:480:6:-;4893:7;435:13:7;:11;:13::i;:::-;4928:15:6::1;::::0;4912:13:::1;::::0;4928:23:::1;::::0;:15:::1;;:21;:23::i;:::-;4912:39;;4980:5;4961:36;;;4998:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;4998:18:::1;5018:11;5031:4;4961:75;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5046:72;5064:5;5071:9;5082:11;:24;;;;;;;;:::i;5046:72::-;5133:47;5156:5:::0;5163:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;539:156:7:-:0;598:5;;:19;:5;607:10;598:19;594:95;;640:38;;;;;667:10;640:38;;;160:74:28;133:18;;640:38:7;14:226:28;594:95:7;539:156::o;1071:123:1:-;1128:16;1163:24;1169:14;1185:1;1163:5;:24::i;:::-;1156:31;1071:123;-1:-1:-1;;1071:123:1:o;8758:524:6:-;8962:3;;:30;;;;;:3;178:55:28;;;8962:30:6;;;160:74:28;8962:3:6;;;;:20;;133:18:28;;8962:30:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9070:12:6;;:50;;;;;:12;;;;;-1:-1:-1;9070:29:6;;-1:-1:-1;9070:50:6;;9100:8;;9110:9;;9070:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9206:17:6;;;:69;;;;;:17;;;;;-1:-1:-1;9206:34:6;;-1:-1:-1;9206:69:6;;9241:8;;9251:12;;;;9265:9;;9206:69;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8758:524;;;;;:::o;1213:185:7:-;1286:16;1305:5;;;1320:16;;;;;;;;;;1351:40;;1305:5;;;;;;;1351:40;;1286:16;1351:40;1276:122;1213:185;:::o;1586:910:1:-;1658:16;1714:5;1690:21;:29;1686:123;;;1742:56;;;;;1769:21;1742:56;;;17887:25:28;17928:18;;;17921:34;;;17860:18;;1742:56:1;17713:248:28;1686:123:1;2095:48;2077:14;2071:4;2067:25;2061:4;2057:36;2054:90;2048:4;2041:104;2302:32;2285:14;2279:4;2275:25;2272:63;2266:4;2259:77;2381:4;2375;2368:5;2361:25;2349:37;-1:-1:-1;2409:22:1;;;2405:85;;2454:25;;;;;;;;;;;;;;645:159:28;708:5;753:3;744:6;739:3;735:16;731:26;728:46;;;770:1;767;760:12;728:46;-1:-1:-1;792:6:28;645:159;-1:-1:-1;645:159:28:o;809:157::-;870:5;915:3;906:6;901:3;897:16;893:26;890:46;;;932:1;929;922:12;971:736;1143:6;1151;1159;1167;1220:3;1208:9;1199:7;1195:23;1191:33;1188:53;;;1237:1;1234;1227:12;1188:53;1277:9;1264:23;1310:18;1302:6;1299:30;1296:50;;;1342:1;1339;1332:12;1296:50;1365:70;1427:7;1418:6;1407:9;1403:22;1365:70;:::i;:::-;1355:80;-1:-1:-1;;1504:2:28;1489:18;;1476:32;;-1:-1:-1;1551:66:28;1609:7;1604:2;1589:18;;1551:66;:::i;:::-;1541:76;;1636:65;1693:7;1687:3;1676:9;1672:19;1636:65;:::i;:::-;1626:75;;971:736;;;;;;;:::o;1712:172::-;1816:42;1809:5;1805:54;1798:5;1795:65;1785:93;;1874:1;1871;1864:12;1889:800;2086:6;2094;2102;2110;2163:3;2151:9;2142:7;2138:23;2134:33;2131:53;;;2180:1;2177;2170:12;2131:53;2220:9;2207:23;2253:18;2245:6;2242:30;2239:50;;;2285:1;2282;2275:12;2239:50;2308:70;2370:7;2361:6;2350:9;2346:22;2308:70;:::i;:::-;2298:80;;;2428:2;2417:9;2413:18;2400:32;2441:49;2484:5;2441:49;:::i;:::-;2509:5;-1:-1:-1;2533:66:28;2591:7;2586:2;2571:18;;2533:66;:::i;3191:622::-;3354:6;3362;3370;3423:3;3411:9;3402:7;3398:23;3394:33;3391:53;;;3440:1;3437;3430:12;3391:53;3480:9;3467:23;3513:18;3505:6;3502:30;3499:50;;;3545:1;3542;3535:12;3499:50;3568:70;3630:7;3621:6;3610:9;3606:22;3568:70;:::i;:::-;3558:80;;;3657:66;3715:7;3710:2;3699:9;3695:18;3657:66;:::i;:::-;3647:76;;3742:65;3799:7;3793:3;3782:9;3778:19;3742:65;:::i;:::-;3732:75;;3191:622;;;;;:::o;5124:265::-;5183:6;5236:2;5224:9;5215:7;5211:23;5207:32;5204:52;;;5252:1;5249;5242:12;5204:52;5291:9;5278:23;5310:49;5353:5;5310:49;:::i;:::-;5378:5;5124:265;-1:-1:-1;;;5124:265:28:o;6080:168::-;6164:20;;6193:49;6164:20;6193:49;:::i;:::-;6080:168;;;:::o;6253:587::-;6331:5;6338:6;6398:3;6385:17;6480:66;6469:8;6453:14;6449:29;6445:102;6425:18;6421:127;6411:155;;6562:1;6559;6552:12;6411:155;6590:33;;6694:4;6681:18;;;-1:-1:-1;6642:21:28;;-1:-1:-1;6722:18:28;6711:30;;6708:50;;;6754:1;6751;6744:12;6708:50;6808:6;6805:1;6801:14;6785;6781:35;6774:5;6770:47;6767:67;;;6830:1;6827;6820:12;6767:67;6253:587;;;;;:::o;7048:623::-;7156:6;7151:3;7144:19;7188:4;7183:3;7179:14;7172:21;;7126:3;7216:5;7239:1;7249:397;7263:6;7260:1;7257:13;7249:397;;;7340:6;7327:20;7360:51;7403:7;7360:51;:::i;:::-;7481:42;7468:56;7456:69;;7561:4;7552:14;;;;7619:17;;;;;7285:1;7278:9;7249:397;;;-1:-1:-1;7662:3:28;;7048:623;-1:-1:-1;;;;7048:623:28:o;7676:560::-;7735:5;7742:6;7802:3;7789:17;7884:66;7873:8;7857:14;7853:29;7849:102;7829:18;7825:127;7815:155;;7966:1;7963;7956:12;7815:155;7994:33;;8098:4;8085:18;;;-1:-1:-1;8046:21:28;;-1:-1:-1;8126:18:28;8115:30;;8112:50;;;8158:1;8155;8148:12;8112:50;8205:6;8189:14;8185:27;8178:5;8174:39;8171:59;;;8226:1;8223;8216:12;8241:326;8330:6;8325:3;8318:19;8382:6;8375:5;8368:4;8363:3;8359:14;8346:43;;8434:1;8427:4;8418:6;8413:3;8409:16;8405:27;8398:38;8300:3;8556:4;8486:66;8481:2;8473:6;8469:15;8465:88;8460:3;8456:98;8452:109;8445:116;;8241:326;;;;:::o;8572:1402::-;8652:81;8729:3;8686:41;8721:5;8686:41;:::i;:::-;337:42;326:54;314:67;;245:142;8652:81;8634:3;8762:52;8808:4;8801:5;8797:16;8762:52;:::i;:::-;337:42;326:54;8880:4;8871:14;;314:67;8955:4;8944:16;;;8931:30;8977:14;;;8970:31;9070:4;9059:16;;;9046:30;9092:14;;;9085:31;9185:4;9174:16;;;9161:30;9207:14;;;9200:31;9300:4;9289:16;;;9276:30;9322:14;;;9315:31;9415:4;9404:16;;;9391:30;9437:14;;;9430:31;9506:75;9575:4;9564:16;;8944;9506:75;:::i;:::-;9613:6;9606:4;9601:3;9597:14;9590:30;9641:93;9726:6;9721:3;9717:16;9703:12;9687:14;9641:93;:::i;:::-;9629:105;;;9781:58;9831:6;9824:5;9820:18;9813:5;9781:58;:::i;:::-;9883:3;9877:4;9873:14;9864:6;9859:3;9855:16;9848:40;9904:64;9963:4;9947:14;9931;9904:64;:::i;:::-;9897:71;8572:1402;-1:-1:-1;;;;;;8572:1402:28:o;9979:538::-;10284:59;10333:9;10325:6;5500:42;5492:5;5486:12;5482:61;5477:3;5470:74;5605:42;5597:4;5590:5;5586:16;5580:23;5576:72;5569:4;5564:3;5560:14;5553:96;5710:42;5702:4;5695:5;5691:16;5685:23;5681:72;5674:4;5669:3;5665:14;5658:96;5815:42;5807:4;5800:5;5796:16;5790:23;5786:72;5779:4;5774:3;5770:14;5763:96;5920:42;5912:4;5905:5;5901:16;5895:23;5891:72;5884:4;5879:3;5875:14;5868:96;6025:42;6017:4;6010:5;6006:16;6000:23;5996:72;5989:4;5984:3;5980:14;5973:96;;;5394:681;10284:59;10380:3;10374;10363:9;10359:19;10352:32;10265:4;10401:66;10462:3;10451:9;10447:19;10439:6;10401:66;:::i;:::-;10393:74;;10504:6;10498:3;10487:9;10483:19;10476:35;9979:538;;;;;;:::o;10522:618::-;10629:4;10635:6;10695:11;10682:25;10785:66;10774:8;10758:14;10754:29;10750:102;10730:18;10726:127;10716:155;;10867:1;10864;10857:12;10716:155;10894:33;;10946:20;;;-1:-1:-1;10989:18:28;10978:30;;10975:50;;;11021:1;11018;11011:12;10975:50;11054:4;11042:17;;-1:-1:-1;11105:1:28;11101:14;;;11085;11081:35;11071:46;;11068:66;;;11130:1;11127;11120:12;11145:581;11223:4;11229:6;11289:11;11276:25;11379:66;11368:8;11352:14;11348:29;11344:102;11324:18;11320:127;11310:155;;11461:1;11458;11451:12;11310:155;11488:33;;11540:20;;;-1:-1:-1;11583:18:28;11572:30;;11569:50;;;11615:1;11612;11605:12;11569:50;11648:4;11636:17;;-1:-1:-1;11679:14:28;11675:27;;;11665:38;;11662:58;;;11716:1;11713;11706:12;11731:367;11930:42;11922:6;11918:55;11907:9;11900:74;12010:2;12005;11994:9;11990:18;11983:30;11881:4;12030:62;12088:2;12077:9;12073:18;12065:6;12057;12030:62;:::i;:::-;12022:70;11731:367;-1:-1:-1;;;;;11731:367:28:o;12103:612::-;12433:59;12482:9;12474:6;5500:42;5492:5;5486:12;5482:61;5477:3;5470:74;5605:42;5597:4;5590:5;5586:16;5580:23;5576:72;5569:4;5564:3;5560:14;5553:96;5710:42;5702:4;5695:5;5691:16;5685:23;5681:72;5674:4;5669:3;5665:14;5658:96;5815:42;5807:4;5800:5;5796:16;5790:23;5786:72;5779:4;5774:3;5770:14;5763:96;5920:42;5912:4;5905:5;5901:16;5895:23;5891:72;5884:4;5879:3;5875:14;5868:96;6025:42;6017:4;6010:5;6006:16;6000:23;5996:72;5989:4;5984:3;5980:14;5973:96;;;5394:681;12433:59;12529:3;12523;12512:9;12508:19;12501:32;12414:4;12550:66;12611:3;12600:9;12596:19;12588:6;12550:66;:::i;:::-;12542:74;;12665:42;12657:6;12653:55;12647:3;12636:9;12632:19;12625:84;12103:612;;;;;;:::o;12720:466::-;12997:59;13046:9;13038:6;5500:42;5492:5;5486:12;5482:61;5477:3;5470:74;5605:42;5597:4;5590:5;5586:16;5580:23;5576:72;5569:4;5564:3;5560:14;5553:96;5710:42;5702:4;5695:5;5691:16;5685:23;5681:72;5674:4;5669:3;5665:14;5658:96;5815:42;5807:4;5800:5;5796:16;5790:23;5786:72;5779:4;5774:3;5770:14;5763:96;5920:42;5912:4;5905:5;5901:16;5895:23;5891:72;5884:4;5879:3;5875:14;5868:96;6025:42;6017:4;6010:5;6006:16;6000:23;5996:72;5989:4;5984:3;5980:14;5973:96;;;5394:681;12997:59;13093:3;13087;13076:9;13072:19;13065:32;12978:4;13114:66;13175:3;13164:9;13160:19;13152:6;13114:66;:::i;:::-;13106:74;12720:466;-1:-1:-1;;;;12720:466:28:o;13894:161::-;13961:20;;14021:8;14010:20;;14000:31;;13990:59;;14045:1;14042;14035:12;14157:163;14224:20;;14284:10;14273:22;;14263:33;;14253:61;;14310:1;14307;14300:12;14424:1494;14683:42;14671:55;;14653:74;;14640:3;14625:19;;14749:20;;14805:13;;14798:21;14788:32;;14778:60;;14834:1;14831;14824:12;14778:60;13868:13;;13861:21;14885:2;14870:18;;13849:34;14847:42;14918:34;14948:2;14940:6;14936:15;14918:34;:::i;:::-;14136:8;14125:20;;15008:2;14993:18;;14113:33;14961:51;15043:34;15073:2;15065:6;15061:15;15043:34;:::i;:::-;14401:10;14390:22;;15135:2;15120:18;;14378:35;15086:53;15170:34;15200:2;15192:6;15188:15;15170:34;:::i;:::-;14401:10;14390:22;;15262:3;15247:19;;14378:35;15213:54;15298:35;15328:3;15320:6;15316:16;15298:35;:::i;:::-;14401:10;14390:22;;15391:3;15376:19;;14378:35;15342:54;15427:35;15457:3;15449:6;15445:16;15427:35;:::i;:::-;14401:10;14390:22;;15520:3;15505:19;;14378:35;15471:54;15556:35;15586:3;15578:6;15574:16;15556:35;:::i;:::-;14401:10;14390:22;;15649:3;15634:19;;14378:35;15600:54;15685:35;15715:3;15707:6;15703:16;15685:35;:::i;:::-;14401:10;14390:22;;15778:3;15763:19;;14378:35;15729:54;15814:35;15844:3;15836:6;15832:16;15814:35;:::i;:::-;14401:10;14390:22;;15907:3;15892:19;;14378:35;15858:54;14424:1494;;;;;:::o;15923:159::-;15990:20;;16050:6;16039:18;;16029:29;;16019:57;;16072:1;16069;16062:12;16087:175;16154:20;;16214:22;16203:34;;16193:45;;16183:73;;16252:1;16249;16242:12;16267:1441;16634:42;16622:55;;16604:74;;16591:3;16709:2;16694:18;;16687:31;;;16576:19;;16753:22;;;16543:4;16833:6;16806:3;16791:19;;16543:4;16867:274;16881:6;16878:1;16875:13;16867:274;;;16956:6;16943:20;16976:49;17019:5;16976:49;:::i;:::-;6956:42;6944:55;6932:68;;7032:4;17116:15;;;;7023:14;;;;16903:1;16896:9;16867:274;;;-1:-1:-1;17158:3:28;-1:-1:-1;17228:6:28;;-1:-1:-1;17201:25:28;17219:6;17201:25;:::i;:::-;17197:38;17192:2;17181:9;17177:18;17170:66;17312:6;17276:34;17306:2;17298:6;17294:15;17276:34;:::i;:::-;17272:47;17267:2;17256:9;17252:18;17245:75;17397:10;17361:34;17391:2;17383:6;17379:15;17361:34;:::i;:::-;17357:51;17351:3;17340:9;17336:19;17329:80;17486:10;17450:34;17480:2;17472:6;17468:15;17450:34;:::i;:::-;17446:51;17440:3;17429:9;17425:19;17418:80;17576:22;17539:35;17569:3;17561:6;17557:16;17539:35;:::i;:::-;17535:64;17529:3;17518:9;17514:19;17507:93;17678:22;17641:35;17671:3;17663:6;17659:16;17641:35;:::i;:::-;17637:64;17631:3;17620:9;17616:19;17609:93;16267:1441;;;;;;;:::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212202a97d37236bb4197f710df287c53c2bbfdc9e7a4c97362a18c984309a33db49964736f6c634300081c0033","offset":6185}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xb5ed119b632b8356c168dafb9a7f32f098c8394a80752eb61d6d54227ab48645","blockNumber":"24634921","transactionIndex":"169","deployer":"0xe08c2512F87cF63fb7D2325EDd08aEC7920aC2f6"},"sources":{"@openzeppelin/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"@openzeppelin/contracts/proxy/Clones.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (proxy/Clones.sol)\n\npragma solidity ^0.8.20;\n\nimport {Create2} from \"../utils/Create2.sol\";\nimport {Errors} from \"../utils/Errors.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-1167[ERC-1167] is a standard for\n * deploying minimal proxy contracts, also known as \"clones\".\n *\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\n *\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\n * deterministic method.\n */\nlibrary Clones {\n    error CloneArgumentsTooLong();\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n     *\n     * This function uses the create opcode, which should never revert.\n     */\n    function clone(address implementation) internal returns (address instance) {\n        return clone(implementation, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-clone-address-}[clone], but with a `value` parameter to send native currency\n     * to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function clone(address implementation, uint256 value) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        assembly (\"memory-safe\") {\n            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\n            // of the `implementation` address with the bytecode before the address.\n            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\n            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\n            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\n            instance := create(value, 0x09, 0x37)\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n     *\n     * This function uses the create2 opcode and a `salt` to deterministically deploy\n     * the clone. Using the same `implementation` and `salt` multiple times will revert, since\n     * the clones cannot be deployed twice at the same address.\n     */\n    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\n        return cloneDeterministic(implementation, salt, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneDeterministic-address-bytes32-}[cloneDeterministic], but with\n     * a `value` parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneDeterministic(\n        address implementation,\n        bytes32 salt,\n        uint256 value\n    ) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        assembly (\"memory-safe\") {\n            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\n            // of the `implementation` address with the bytecode before the address.\n            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\n            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\n            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\n            instance := create2(value, 0x09, 0x37, salt)\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n     */\n    function predictDeterministicAddress(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            mstore(add(ptr, 0x38), deployer)\n            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)\n            mstore(add(ptr, 0x14), implementation)\n            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)\n            mstore(add(ptr, 0x58), salt)\n            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))\n            predicted := and(keccak256(add(ptr, 0x43), 0x55), 0xffffffffffffffffffffffffffffffffffffffff)\n        }\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n     */\n    function predictDeterministicAddress(\n        address implementation,\n        bytes32 salt\n    ) internal view returns (address predicted) {\n        return predictDeterministicAddress(implementation, salt, address(this));\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom\n     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To\n     * access the arguments within the implementation, use {fetchCloneArgs}.\n     *\n     * This function uses the create opcode, which should never revert.\n     */\n    function cloneWithImmutableArgs(address implementation, bytes memory args) internal returns (address instance) {\n        return cloneWithImmutableArgs(implementation, args, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneWithImmutableArgs-address-bytes-}[cloneWithImmutableArgs], but with a `value`\n     * parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        uint256 value\n    ) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        assembly (\"memory-safe\") {\n            instance := create(value, add(bytecode, 0x20), mload(bytecode))\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation` with custom\n     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To\n     * access the arguments within the implementation, use {fetchCloneArgs}.\n     *\n     * This function uses the create2 opcode and a `salt` to deterministically deploy the clone. Using the same\n     * `implementation`, `args` and `salt` multiple times will revert, since the clones cannot be deployed twice\n     * at the same address.\n     */\n    function cloneDeterministicWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        return cloneDeterministicWithImmutableArgs(implementation, args, salt, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-}[cloneDeterministicWithImmutableArgs],\n     * but with a `value` parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneDeterministicWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        uint256 value\n    ) internal returns (address instance) {\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        return Create2.deploy(value, salt, bytecode);\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.\n     */\n    function predictDeterministicAddressWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        return Create2.computeAddress(salt, keccak256(bytecode), deployer);\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.\n     */\n    function predictDeterministicAddressWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal view returns (address predicted) {\n        return predictDeterministicAddressWithImmutableArgs(implementation, args, salt, address(this));\n    }\n\n    /**\n     * @dev Get the immutable args attached to a clone.\n     *\n     * - If `instance` is a clone that was deployed using `clone` or `cloneDeterministic`, this\n     *   function will return an empty array.\n     * - If `instance` is a clone that was deployed using `cloneWithImmutableArgs` or\n     *   `cloneDeterministicWithImmutableArgs`, this function will return the args array used at\n     *   creation.\n     * - If `instance` is NOT a clone deployed using this library, the behavior is undefined. This\n     *   function should only be used to check addresses that are known to be clones.\n     */\n    function fetchCloneArgs(address instance) internal view returns (bytes memory) {\n        bytes memory result = new bytes(instance.code.length - 45); // revert if length is too short\n        assembly (\"memory-safe\") {\n            extcodecopy(instance, add(result, 32), 45, mload(result))\n        }\n        return result;\n    }\n\n    /**\n     * @dev Helper that prepares the initcode of the proxy with immutable args.\n     *\n     * An assembly variant of this function requires copying the `args` array, which can be efficiently done using\n     * `mcopy`. Unfortunately, that opcode is not available before cancun. A pure solidity implementation using\n     * abi.encodePacked is more expensive but also more portable and easier to review.\n     *\n     * NOTE: https://eips.ethereum.org/EIPS/eip-170[EIP-170] limits the length of the contract code to 24576 bytes.\n     * With the proxy code taking 45 bytes, that limits the length of the immutable args to 24531 bytes.\n     */\n    function _cloneCodeWithImmutableArgs(\n        address implementation,\n        bytes memory args\n    ) private pure returns (bytes memory) {\n        if (args.length > 24531) revert CloneArgumentsTooLong();\n        return\n            abi.encodePacked(\n                hex\"61\",\n                uint16(args.length + 45),\n                hex\"3d81600a3d39f3363d3d373d3d3d363d73\",\n                implementation,\n                hex\"5af43d82803e903d91602b57fd5bf3\",\n                args\n            );\n    }\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/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/utils/Create2.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Create2.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\n * `CREATE2` can be used to compute in advance the address where a smart\n * contract will be deployed, which allows for interesting new mechanisms known\n * as 'counterfactual interactions'.\n *\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\n * information.\n */\nlibrary Create2 {\n    /**\n     * @dev There's no code to deploy.\n     */\n    error Create2EmptyBytecode();\n\n    /**\n     * @dev Deploys a contract using `CREATE2`. The address where the contract\n     * will be deployed can be known in advance via {computeAddress}.\n     *\n     * The bytecode for a contract can be obtained from Solidity with\n     * `type(contractName).creationCode`.\n     *\n     * Requirements:\n     *\n     * - `bytecode` must not be empty.\n     * - `salt` must have not been used for `bytecode` already.\n     * - the factory must have a balance of at least `amount`.\n     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\n     */\n    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n        if (bytecode.length == 0) {\n            revert Create2EmptyBytecode();\n        }\n        assembly (\"memory-safe\") {\n            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\n            // if no address was created, and returndata is not empty, bubble revert\n            if and(iszero(addr), not(iszero(returndatasize()))) {\n                let p := mload(0x40)\n                returndatacopy(p, 0, returndatasize())\n                revert(p, returndatasize())\n            }\n        }\n        if (addr == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\n     * `bytecodeHash` or `salt` will result in a new destination address.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\n        return computeAddress(salt, bytecodeHash, address(this));\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\n     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40) // Get free memory pointer\n\n            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |\n            // |-------------------|---------------------------------------------------------------------------|\n            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |\n            // | salt              |                                      BBBBBBBBBBBBB...BB                   |\n            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |\n            // | 0xFF              |            FF                                                             |\n            // |-------------------|---------------------------------------------------------------------------|\n            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |\n            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |\n\n            mstore(add(ptr, 0x40), bytecodeHash)\n            mstore(add(ptr, 0x20), salt)\n            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes\n            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff\n            mstore8(start, 0xff)\n            addr := and(keccak256(start, 85), 0xffffffffffffffffffffffffffffffffffffffff)\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Errors.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},"src/interfaces/externals/Convex/ICvxRewardToken.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface ICvxRewardToken is IERC20 {\n    function addExtraReward(address _reward) external returns (bool);\n\n    function balanceOf(address account) external view returns (uint256);\n\n    function clearExtraRewards() external;\n\n    function currentRewards() external view returns (uint256);\n\n    function donate(uint256 _amount) external returns (bool);\n\n    function duration() external view returns (uint256);\n\n    function earned(address account) external view returns (uint256);\n\n    function extraRewards(uint256) external view returns (address);\n\n    function extraRewardsLength() external view returns (uint256);\n\n    function getReward() external returns (bool);\n\n    function getReward(address _account, bool _claimExtras) external returns (bool);\n\n    function historicalRewards() external view returns (uint256);\n\n    function lastTimeRewardApplicable() external view returns (uint256);\n\n    function lastUpdateTime() external view returns (uint256);\n\n    function newRewardRatio() external view returns (uint256);\n\n    function operator() external view returns (address);\n\n    function periodFinish() external view returns (uint256);\n\n    function pid() external view returns (uint256);\n\n    function queueNewRewards(uint256 _rewards) external returns (bool);\n\n    function queuedRewards() external view returns (uint256);\n\n    function rewardManager() external view returns (address);\n\n    function rewardPerToken() external view returns (uint256);\n\n    function rewardPerTokenStored() external view returns (uint256);\n\n    function rewardRate() external view returns (uint256);\n\n    function rewardToken() external view returns (address);\n\n    function rewards(address) external view returns (uint256);\n\n    function stake(uint256 _amount) external returns (bool);\n\n    function stakeAll() external returns (bool);\n\n    function stakeFor(address _for, uint256 _amount) external returns (bool);\n\n    function stakingToken() external view returns (IERC20Metadata);\n\n    function totalSupply() external view returns (uint256);\n\n    function userRewardPerTokenPaid(address) external view returns (uint256);\n\n    function withdraw(uint256 amount, bool claim) external returns (bool);\n\n    function withdrawAll(bool claim) external;\n\n    function withdrawAllAndUnwrap(bool claim) external;\n\n    function withdrawAndUnwrap(uint256 amount, bool claim) external returns (bool);\n}\n"},"src/interfaces/externals/Convex/IStakingProxyERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport \"../FXN/ISharedLiquidityGauge.sol\";\ninterface IStakingProxyERC20 {\n    function FEE_DENOMINATOR() external view returns (uint256);\n    function deposit(uint256 _amount, bool _manage) external;\n    function deposit(uint256 _amount) external;\n    function earned() external returns (address[] memory token_addresses, uint256[] memory total_earned);\n    function execute(address _to, uint256 _value, bytes memory _data) external returns (bool, bytes memory);\n    function feeRegistry() external view returns (address);\n    function fxn() external view returns (address);\n    function fxnMinter() external view returns (address);\n    function gaugeAddress() external view returns (ISharedLiquidityGauge);\n    function getReward() external;\n    function getReward(bool _claim, address[] memory _tokenList) external;\n    function getReward(bool _claim) external;\n    function initialize(address _owner, uint256 _pid) external;\n    function owner() external view returns (address);\n    function pid() external view returns (uint256);\n    function poolRegistry() external view returns (address);\n    function rewards() external view returns (address);\n    function setVeFXNProxy(address _proxy) external;\n    function stakingToken() external view returns (address);\n    function transferTokens(address[] memory _tokenList) external;\n    function usingProxy() external view returns (address);\n    function vaultType() external pure returns (uint8);\n    function vaultVersion() external pure returns (uint256);\n    function vefxnProxy() external view returns (address);\n    function withdraw(uint256 _amount) external;\n}\n"},"src/interfaces/externals/Curve/IGauge.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface IGauge is IERC20Metadata {\n    function initialize(address _lp_token) external;\n    function integrate_checkpoint() external view returns (uint256);\n    function user_checkpoint(address addr) external returns (bool);\n    function claimable_tokens(address addr) external returns (uint256);\n    function claimed_reward(address _addr, address _token) external view returns (uint256);\n    function claimable_reward(address _user, address _reward_token) external view returns (uint256);\n    function set_rewards_receiver(address _receiver) external;\n    function claim_rewards() external;\n    function claim_rewards(address _addr) external;\n    function claim_rewards(address _addr, address _receiver) external;\n    function kick(address addr) external;\n    function deposit(uint256 _value) external;\n    function deposit(uint256 _value, address _addr) external;\n    function deposit(uint256 _value, address _addr, bool _claim_rewards) external;\n    function withdraw(uint256 _value) external;\n    function withdraw(uint256 _value, bool _claim_rewards) external;\n    function transfer(address _to, uint256 _value) external returns (bool);\n    function transferFrom(address _from, address _to, uint256 _value) external returns (bool);\n    function approve(address _spender, uint256 _value) external returns (bool);\n    function increaseAllowance(address _spender, uint256 _added_value) external returns (bool);\n    function decreaseAllowance(address _spender, uint256 _subtracted_value) external returns (bool);\n    function add_reward(address _reward_token, address _distributor) external;\n    function set_reward_distributor(address _reward_token, address _distributor) external;\n    function deposit_reward_token(address _reward_token, uint256 _amount) external;\n    function set_killed(bool _is_killed) external;\n    function lp_token() external view returns (address);\n    function future_epoch_time() external view returns (uint256);\n    function balanceOf(address arg0) external view returns (uint256);\n    function totalSupply() external view returns (uint256);\n    function allowance(address arg0, address arg1) external view returns (uint256);\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function working_balances(address arg0) external view returns (uint256);\n    function working_supply() external view returns (uint256);\n    function period() external view returns (int128);\n    function period_timestamp(uint256 arg0) external view returns (uint256);\n    function integrate_inv_supply(uint256 arg0) external view returns (uint256);\n    function integrate_inv_supply_of(address arg0) external view returns (uint256);\n    function integrate_checkpoint_of(address arg0) external view returns (uint256);\n    function integrate_fraction(address arg0) external view returns (uint256);\n    function inflation_rate() external view returns (uint256);\n    function reward_count() external view returns (uint256);\n    function reward_tokens(uint256 arg0) external view returns (address);\n    function reward_data(address arg0) external view returns (address token, address distributor, uint256 period_finish, uint256 rate, uint256 last_update, uint256 integral);\n    function rewards_receiver(address arg0) external view returns (address);\n    function reward_integral_for(address arg0, address arg1) external view returns (uint256);\n    function is_killed() external view returns (bool);\n    function factory() external view returns (address);\n    function staking_token() external view returns (address);\n}\n"},"src/interfaces/externals/FXN/ISharedLiquidityGauge.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\ninterface ISharedLiquidityGauge {\n    function DEFAULT_ADMIN_ROLE() external view returns (bytes32);\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n    function REWARD_MANAGER_ROLE() external view returns (bytes32);\n    function acceptSharedVote(address _newOwner) external;\n    function allowance(address owner, address spender) external view returns (uint256);\n    function approve(address spender, uint256 amount) external returns (bool);\n    function balanceOf(address account) external view returns (uint256);\n    function checkpoint(address _account) external;\n    function claim(address _account) external;\n    function claim(address _account, address _receiver) external;\n    function claim() external;\n    function claimHistorical(address[] memory _tokens) external;\n    function claimHistorical(address _account, address[] memory _tokens) external;\n    function claimable(address _account, address _token) external view returns (uint256);\n    function claimed(address _account, address _token) external view returns (uint256);\n    function controller() external view returns (address);\n    function decimals() external view returns (uint8);\n    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);\n    function deposit(uint256 _amount, address _receiver) external;\n    function deposit(uint256 _amount, address _receiver, bool _manage) external;\n    function deposit(uint256 _amount) external;\n    function depositReward(address _token, uint256 _amount) external;\n    function disableGauge() external;\n    function distributors(address) external view returns (address);\n    function eip712Domain()\n        external\n        view\n        returns (bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions);\n    function getActiveRewardTokens() external view returns (address[] memory _rewardTokens);\n    function getHistoricalRewardTokens() external view returns (address[] memory _rewardTokens);\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n    function getStakerVoteOwner(address _account) external view returns (address);\n    function governanceToken() external view returns (address);\n    function grantRole(bytes32 role, address account) external;\n    function hasRole(bytes32 role, address account) external view returns (bool);\n    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);\n    function inflationParams() external view returns (uint192 rate, uint64 futureEpochTime);\n    function initialize(address _stakingToken) external;\n    function integrate_fraction(address account) external view returns (uint256);\n    function isActive() external view returns (bool);\n    function isStakerAllowed(address, address) external view returns (bool);\n    function kick(address _account) external;\n    function manager() external view returns (address);\n    function minter() external view returns (address);\n    function name() external view returns (string memory);\n    function nonces(address owner) external view returns (uint256);\n    function numAcceptedStakers(address) external view returns (uint256);\n    function pendingRewards(address _token) external view returns (uint256, uint256);\n    function periodLength() external view returns (uint40);\n    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;\n    function registerRewardToken(address _token, address _distributor) external;\n    function rejectSharedVote() external;\n    function renounceRole(bytes32 role, address account) external;\n    function revokeRole(bytes32 role, address account) external;\n    function rewardData(address) external view returns (uint96 queued, uint80 rate, uint40 lastUpdate, uint40 finishAt);\n    function rewardReceiver(address) external view returns (address);\n    function rewardSnapshot(address) external view returns (uint64 timestamp, uint192 integral);\n    function setRewardReceiver(address _newReceiver) external;\n    function sharedBalanceOf(address) external view returns (uint256);\n    function snapshot() external view returns (uint64 timestamp, uint192 integral);\n    function stakingToken() external view returns (address);\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n    function symbol() external view returns (string memory);\n    function toggleVoteSharing(address _staker) external;\n    function totalSupply() external view returns (uint256);\n    function transfer(address to, uint256 amount) external returns (bool);\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n    function unregisterRewardToken(address _token) external;\n    function updateLiquidityManager(address _newManager) external;\n    function updateRewardDistributor(address _token, address _newDistributor) external;\n    function user_checkpoint(address _account) external returns (bool);\n    function ve() external view returns (address);\n    function veProxy() external view returns (address);\n    function withdraw(uint256 _amount, address _receiver) external;\n    function withdraw(uint256 _amount) external;\n    function workingBalanceOf(address) external view returns (uint256);\n    function workingSupply() external view returns (uint256);\n}\n"},"src/interfaces/externals/StakeDao/IStakeDaoVaultV2.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport {IERC20Metadata, IERC20} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface IStakeDaoVaultV2 is IERC20Metadata {\n    function ACCOUNTANT() external view returns (address);\n    function DEFAULT_REWARDS_DURATION() external view returns (uint32);\n    function POLICY() external view returns (uint8);\n    function PROTOCOL_CONTROLLER() external view returns (address);\n    function PROTOCOL_ID() external view returns (bytes4);\n    function accountData(address account, address rewardToken) external view returns (uint128 rewardPerTokenPaid, uint128 claimable);\n    function addRewardToken(address rewardToken, address distributor) external;\n    function allocator() external view returns (address _allocator);\n    function allowance(address owner, address spender) external view returns (uint256);\n    function approve(address spender, uint256 value) external returns (bool);\n    function asset() external view returns (address);\n    function balanceOf(address account) external view returns (uint256);\n    function checkpoint(address account) external;\n    function claim(address[] calldata tokens, address receiver) external returns (uint256[] memory amounts);\n    function claim(address account, address[] calldata tokens, address receiver) external returns (uint256[] memory amounts);\n    function convertToAssets(uint256 shares) external pure returns (uint256);\n    function convertToShares(uint256 assets) external pure returns (uint256);\n    function decimals() external view returns (uint8);\n    function deposit(uint256 assets, address receiver, address referrer) external returns (uint256);\n    function deposit(address account, address receiver, uint256 assets, address referrer) external returns (uint256);\n    function deposit(uint256 assets, address receiver) external returns (uint256);\n    function depositRewards(address rewardToken, uint128 amount) external;\n    function earned(address account, address token) external view returns (uint128);\n    function gauge() external view returns (address _gauge);\n    function getClaimable(address token, address account) external view returns (uint128);\n    function getLastUpdateTime(address token) external view returns (uint32);\n    function getPeriodFinish(address token) external view returns (uint32);\n    function getRewardPerTokenPaid(address token, address account) external view returns (uint128);\n    function getRewardPerTokenStored(address token) external view returns (uint128);\n    function getRewardRate(address token) external view returns (uint128);\n    function getRewardTokens() external view returns (address[] memory);\n    function getRewardsDistributor(address token) external view returns (address);\n    function isRewardToken(address rewardToken) external view returns (bool);\n    function lastTimeRewardApplicable(address token) external view returns (uint256);\n    function maxDeposit(address) external pure returns (uint256);\n    function maxMint(address _account) external pure returns (uint256);\n    function maxRedeem(address owner) external view returns (uint256);\n    function maxWithdraw(address owner) external view returns (uint256);\n    function mint(uint256 shares, address receiver) external returns (uint256);\n    function mint(uint256 shares, address receiver, address referrer) external returns (uint256);\n    function name() external view returns (string memory);\n    function previewDeposit(uint256 shares) external pure returns (uint256);\n    function previewMint(uint256 assets) external pure returns (uint256);\n    function previewRedeem(uint256 shares) external pure returns (uint256);\n    function previewWithdraw(uint256 assets) external pure returns (uint256);\n    function redeem(uint256 shares, address receiver, address owner) external returns (uint256);\n    function resumeVault() external;\n    function rewardData(\n        address rewardToken\n    ) external view returns (address rewardsDistributor, uint32 lastUpdateTime, uint32 periodFinish, uint128 rewardRate, uint128 rewardPerTokenStored);\n    function rewardPerToken(address token) external view returns (uint128);\n    function strategy() external view returns (address _strategy);\n    function symbol() external view returns (string memory);\n    function totalAssets() external view returns (uint256);\n    function totalSupply() external view returns (uint256);\n    function transfer(address to, uint256 value) external returns (bool);\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256);\n}\n"},"src/interfaces/internals/ICommonStruct.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\nstruct TokenAmount {\n    IERC20 token;\n    uint256 amount;\n}\nstruct ZapStruct {\n    address router;\n    bytes routerCall;\n}\nstruct ZapStructDeposit {\n    IERC20 tokenIn;\n    uint256 amountIn;\n    uint256 minAmountOut;\n    ZapStruct zap;\n}\n\nstruct ZapStructDepositNoMinAmount {\n    IERC20 tokenIn;\n    uint256 amountIn;\n    ZapStruct zap;\n}\n"},"src/interfaces/internals/USG/IBasicERC20Market.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\ninterface IBasicERC20Market {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit) external;\n}\n"},"src/interfaces/internals/USG/ICollateral.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nimport {IDebtIR} from \"./IDebtIR.sol\";\nimport {IRewardAccumulator} from \"./IRewardAccumulator.sol\";\nimport {IPriceOracle} from \"./IPriceOracle.sol\";\n\ninterface ICollateral {\n    function collatOracle() external view returns (IPriceOracle);\n\n    function collatToken() external view returns (IERC20Metadata);\n\n    function collatDecimals() external view returns (uint256);\n\n    function collateralBalances(address account) external view returns (uint256);\n\n    function totalCollateral() external view returns (uint256);\n\n    function maxLTV() external view returns (uint256);\n\n    function liquidationThreshold() external view returns (uint256);\n\n    function rewardAccumulator() external view returns (IRewardAccumulator);\n\n    function getBalanceAndTotalCollateral(address account) external view returns (uint256, uint256);\n}\n"},"src/interfaces/internals/USG/IControlTower.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nimport {IDebtIR} from \"./IDebtIR.sol\";\n\ninterface IControlTower {\n    function isMarketCreator(address marketCreator) external view returns (bool);\n\n    function isPositionMigrator(address migrator) external view returns (bool);\n\n    function isPauser(address pauser) external view returns (bool);\n\n    function feeTreasury() external view returns (address);\n}\n"},"src/interfaces/internals/USG/IConvexCrvLPMarket.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {ICvxRewardToken} from \"../../externals/Convex/ICvxRewardToken.sol\";\ninterface IConvexCrvLPMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, uint256 _pid) external;\n\n    function cvxRewardToken() external view returns (ICvxRewardToken);\n}\n"},"src/interfaces/internals/USG/IConvexFxnLPMarket.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IStakingProxyERC20} from \"../../externals/Convex/IStakingProxyERC20.sol\";\ninterface IConvexFxnLPMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, uint256 _pid) external;\n\n    function stakingProxyVault() external view returns (IStakingProxyERC20);\n}\n"},"src/interfaces/internals/USG/ICurveGaugeMarket.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IGauge} from \"../../externals/Curve/IGauge.sol\";\ninterface ICurveGaugeMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, IGauge _gauge) external;\n}\n"},"src/interfaces/internals/USG/IDebtIR.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IIRCalculator} from \"./IIRCalculator.sol\";\n\ninterface IDebtIR {\n    function maxMarketDebt() external view returns (uint256);\n    function irCalculator() external view returns (IIRCalculator);\n    function minimumLoan() external view returns (uint256);\n    function userDebtShares(address user) external view returns (uint256);\n    function totalDebtShares() external view returns (uint256);\n    function badDebt() external view returns (uint256);\n}\n"},"src/interfaces/internals/USG/IIRCalculator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nstruct IRParams {\n    /// @dev Flag to determine if a Market is HEC or LEC\n    bool isHEC;\n    /// @dev Minimum IR reached at pMax.\n    ///      1_000 <=> 1% / 100_000 <=> 100%.\n    uint24 rMin;\n    /// @dev Maximum IR reached at pMin.\n    ///      1_000 <=> 1% / 100_000 <=> 100%.\n    uint32 rMax;\n    /// @dev Minimum price of USG where rMax is reached.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pMin;\n    /// @dev Inflexion price of USG where IR starts to increases more significantly.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pInf;\n    /// @dev Maximum price of USG where IR increases more significantly.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pMax;\n    /// @dev Convexity of the curve before pInf\n    ///      2_000 <=> 2 / 4_500 <=> 4.5\n    uint32 a1;\n    /// @dev Convexity of the curve after pInf\n    ///      2_000 <=> 2 / 4_500 <=> 4.5\n    uint32 a2;\n    /// @dev Velocity of the transition between a1 and a2\n    ///      It's an integer. 250 <=> 250\n    uint32 k;\n}\n\nstruct IRCheckpoint {\n    uint216 ir;\n    uint40 timestamp;\n}\ninterface IIRCalculator {\n    function initializeMarket(address market, IRParams calldata _irParam) external;\n\n    function simulateIR(uint256 USGPrice, IRParams memory irParam) external view returns (uint256);\n\n    function computeIRForMarket(address market) external returns (uint256);\n\n    function checkpointIR(address market) external returns (uint256);\n\n    function newDebtIndex(address market) external view returns (uint256);\n\n    function irCheckpoints(address market) external view returns (uint216, uint40);\n\n    function debtIndexes(address market) external view returns (uint256);\n\n    function indexDelta(address market) external view returns (uint256);\n\n    function mintableInterests() external view returns (uint256);\n\n    function getIRParams(address market) external view returns (IRParams memory);\n\n    function getIRCheckpoint(address market) external view returns (IRCheckpoint memory);\n}\n"},"src/interfaces/internals/USG/IMarketCore.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {ZapStruct} from \"../ICommonStruct.sol\";\nimport {IIRCalculator} from \"./IIRCalculator.sol\";\nimport {IUSG} from \"./IUSG.sol\";\nimport {ICollateral, IERC20Metadata} from \"./ICollateral.sol\";\nimport {IControlTower} from \"./IControlTower.sol\";\nimport {IPriceOracle} from \"./IPriceOracle.sol\";\nimport {IZappingProxy} from \"./IZappingProxy.sol\";\nimport {IRewardAccumulator} from \"./IRewardAccumulator.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nstruct LiquidationPre {\n    uint256 newDebtIndex;\n    uint256 collatBalance;\n    uint256 _userDebtShares;\n    uint256 userDebt_;\n}\n\nstruct LiquidateIn {\n    address account;\n    PostLiquidate postLiquidate;\n    uint256 minCollatValueToLiquidate;\n}\n\nstruct LiquidateTransitionStruct {\n    LiquidateIn liquidateIn;\n    uint256 collatPrice;\n    uint256 newDebtIndex;\n    uint256 _collateralBalance;\n    uint256 _totalCollateral;\n    uint256 _userDebtShares;\n    uint256 _totalDebtShares;\n    uint256 userDebt;\n}\n\nstruct PostLiquidate {\n    uint256 collatAmountToLiquidate;\n    uint256 minUsgOut;\n    uint256 maxUsgToBurn;\n    uint256 minCollatAmountToLiquidate;\n    bool isReceiptOut;\n}\n\nstruct SelfLiquidateIn {\n    uint256 collatAmountToLiquidate;\n    uint256 usgToRepay;\n    uint256 maxUsgToBurn;\n    uint256 minUsgOut;\n    bool isReceiptOut;\n}\n\nstruct SelfLiquidateTransitionStruct {\n    SelfLiquidateIn selfLiquidateIn;\n    uint256 newDebtIndex;\n    uint256 _collateralBalance;\n    uint256 _totalCollateral;\n    uint256 _userDebtShares;\n    uint256 _totalDebtShares;\n    uint256 userDebt;\n}\n\nstruct LeverageIn {\n    uint256 collatToDeposit;\n    uint256 usgToFlashMint;\n    uint256 minCollatAmountOut;\n    bool isReceiptIn;\n}\n\nstruct GlobalMarketInitParams {\n    address _owner;\n    IUSG _USG;\n    IControlTower _controlTower;\n    IIRCalculator _irCalculator;\n    IRewardAccumulator _rewardAccumulator;\n    IZappingProxy _zappingProxy;\n}\n\nstruct MarketInit {\n    IERC20Metadata collatToken;\n    IPriceOracle collatOracle;\n    uint256 maxLTV;\n    uint256 liquidationThreshold;\n    uint256 liquidationFee;\n    uint256 maxMarketDebt;\n    uint256 minimumLoan;\n    IERC20[] rewardTokens;\n    string name;\n}\n"},"src/interfaces/internals/USG/IPriceOracle.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\ninterface IPriceOracle {\n    function latestAnswer(bool isNoFailMode) external view returns (uint256);\n\n    function latestAnswerUpdate(bool isNoFailMode) external returns (uint256);\n\n    function decimals() external view returns (uint8);\n}\n"},"src/interfaces/internals/USG/IRewardAccumulator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {TokenAmount, IERC20} from \"../ICommonStruct.sol\";\n\nstruct Reward {\n    uint128 lastUpdateTime;\n    uint128 periodFinish;\n    uint256 rewardRate;\n    uint256 rewardPerTokenStored;\n}\nstruct RCParams {\n    uint16 harvestFeePercentage;\n    /// @dev Amount of distincts reward cut steps.\n    uint16 stepAmount;\n    /// @dev Percentage minimum of the reward cut.\n    uint32 startCutPercentage;\n    /// @dev Percentage maximum of the reward cut.\n    uint32 endCutPercentage;\n    /// @dev Price of USG on which the reward cut starts to increase.\n    uint80 startCutPrice;\n    /// @dev Price of USG on which the reward cut is at its maximum\n    uint80 endCutPrice;\n}\ninterface IRewardAccumulator {\n    function cutFeeForToken(IERC20 token) external view returns (uint256);\n\n    function getRewardData(address market, IERC20 token) external view returns (Reward memory);\n\n    function updateRewards(address account, uint256 collateralBalances, uint256 totalCollateral) external;\n\n    function processRewards(address market, address harvestFeeReceiver) external;\n\n    function getRewardTokens(address markets) external view returns (IERC20[] memory);\n\n    function lastRewardCuts(address market) external view returns (uint256);\n\n    function claimableRewards(address market, address _account) external view returns (TokenAmount[] memory userRewards);\n\n    function simulateRC(uint256 USGPrice, RCParams calldata rcParams) external pure returns (uint256);\n\n    function computeRCForMarket(address market) external returns (uint256);\n\n    function initializeMarket(address market, IERC20[] calldata rewardTokens, RCParams calldata _rcParams) external;\n\n    function getRCParams(address markets) external view returns (RCParams memory);\n}\n"},"src/interfaces/internals/USG/IStakeDaoVaultV2Market.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IStakeDaoVaultV2} from \"../../externals/StakeDao/IStakeDaoVaultV2.sol\";\ninterface IStakeDaoVaultV2Market {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, IStakeDaoVaultV2 _vault) external;\n}\n"},"src/interfaces/internals/USG/IUSG.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\n\ninterface IUSG is IERC20 {\n    function mintDebt(address to, uint256 amount) external;\n\n    function burnDebt(address from, uint256 amount) external;\n\n    function mintIR(uint256 amount) external;\n\n    function initializeMarket(address market) external;\n}\n"},"src/interfaces/internals/USG/IZappingProxy.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\n\nimport {ZapStruct} from \"../ICommonStruct.sol\";\n\ninterface IZappingProxy {\n    function zapProxy(IERC20 tokenIn, IERC20 tokenOut, uint256 minAmountOut, address receiver, ZapStruct calldata routerCall) external payable returns (uint256);\n}\n"},"src/USG/Utilities/abstract/LightOwnable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.22;\n\nabstract contract LightOwnable {\n    address public owner;\n\n    error OwnableUnauthorizedAccount(address account);\n\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\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 Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner != msg.sender) {\n            revert OwnableUnauthorizedAccount(msg.sender);\n        }\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"},"src/USG/Utilities/MarketCreator.sol":{"content":"// SPDX-License-Identifier: MIT\n/**\n _____\n/  __ \\\n| /  \\/ ___  _ ____   _____ _ __ __ _  ___ _ __   ___ ___\n| |    / _ \\| '_ \\ \\ / / _ \\ '__/ _` |/ _ \\ '_ \\ / __/ _ \\\n| \\__/\\ (_) | | | \\ V /  __/ | | (_| |  __/ | | | (_|  __/\n \\____/\\___/|_| |_|\\_/ \\___|_|  \\__, |\\___|_| |_|\\___\\___|\n                                 __/ |\n                                |___/\n */\npragma solidity ^0.8.0;\n\nimport {LightOwnable} from \"../Utilities/abstract/LightOwnable.sol\";\nimport {Clones} from \"@openzeppelin/contracts/proxy/Clones.sol\";\n\nimport {GlobalMarketInitParams, MarketInit, IRewardAccumulator, IERC20Metadata, IERC20} from \"../../interfaces/internals/USG/IMarketCore.sol\";\nimport {IConvexCrvLPMarket, ICvxRewardToken} from \"../../interfaces/internals/USG/IConvexCrvLPMarket.sol\";\nimport {ICurveGaugeMarket, IGauge} from \"../../interfaces/internals/USG/ICurveGaugeMarket.sol\";\nimport {IStakeDaoVaultV2Market, IStakeDaoVaultV2} from \"../../interfaces/internals/USG/IStakeDaoVaultV2Market.sol\";\nimport {IConvexFxnLPMarket} from \"../../interfaces/internals/USG/IConvexFxnLPMarket.sol\";\nimport {IBasicERC20Market} from \"../../interfaces/internals/USG/IBasicERC20Market.sol\";\nimport {IControlTower} from \"../../interfaces/internals/USG/IControlTower.sol\";\nimport {IRParams, IIRCalculator} from \"../../interfaces/internals/USG/IIRCalculator.sol\";\nimport {RCParams} from \"../../interfaces/internals/USG/IRewardAccumulator.sol\";\nimport {IZappingProxy} from \"../../interfaces/internals/USG/IZappingProxy.sol\";\nimport {IUSG} from \"../../interfaces/internals/USG/IUSG.sol\";\n\n/// @title  MarketCreator\n/// @author Tangent Finance\n/// @notice Factory to deploy market following the Minimal proxy implementation\ncontract MarketCreator is LightOwnable {\n    using Clones for address;\n\n    /// @notice Control tower\n    IControlTower public controlTower;\n\n    /// @notice USG token\n    IUSG public USG;\n\n    /// @notice IR Calculator\n    IIRCalculator public irCalculator;\n\n    /// @notice Reward accumulator\n    IRewardAccumulator public rewardAccumulator;\n\n    /// @notice Zapping proxy\n    IZappingProxy public zappingProxy;\n\n    /// @notice Convex CRV market implementation\n    address public marketConvexCrv;\n\n    /// @notice Convex FXN market implementation\n    address public marketConvexFxn;\n\n    /// @notice Market Curve gauge implementation\n    address public marketCurveGauge;\n\n    /// @notice Market Curve gauge implementation\n    address public marketStakeDaoVaultV2;\n\n    /// @notice Basic ERC20 market implementation\n    address public marketBasicERC20;\n\n    event MarketConvexCrvCreated(address proxy, string name);\n    event MarketConvexFxnCreated(address proxy, string name);\n    event MarketCurveGaugeCreated(address proxy, string name);\n    event MarketStakeDaoVaultV2Created(address proxy, string name);\n    event BasicERC20MarketCreated(address proxy, string name);\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                            CONSTRUCTOR\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    constructor(\n        address _owner,\n        IControlTower _controlTower,\n        IUSG _USG,\n        IIRCalculator _irCalculator,\n        IRewardAccumulator _rewardAccumulator,\n        IZappingProxy _zappingProxy,\n        address _marketConvexCrv,\n        address _marketConvexFxn,\n        address _marketCurveGauge,\n        address _marketStakeDaoVaultV2,\n        address _marketBasicERC20\n    ) {\n        controlTower = _controlTower;\n        USG = _USG;\n        irCalculator = _irCalculator;\n        rewardAccumulator = _rewardAccumulator;\n        zappingProxy = _zappingProxy;\n        marketConvexCrv = _marketConvexCrv;\n        marketConvexFxn = _marketConvexFxn;\n        marketCurveGauge = _marketCurveGauge;\n        marketStakeDaoVaultV2 = _marketStakeDaoVaultV2;\n        marketBasicERC20 = _marketBasicERC20;\n        _transferOwnership(_owner);\n    }\n\n    function _getGlobalParams() internal view returns (GlobalMarketInitParams memory) {\n        return\n            GlobalMarketInitParams({\n                _owner: owner,\n                _USG: USG,\n                _controlTower: controlTower,\n                _irCalculator: irCalculator,\n                _rewardAccumulator: rewardAccumulator,\n                _zappingProxy: zappingProxy\n            });\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _pid            Pool ID of Curve Convex LP\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createConvexCrvMarket(MarketInit calldata _marketInit, uint256 _pid, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketConvexCrv.clone();\n        IConvexCrvLPMarket(proxy).initialize(_getGlobalParams(), _marketInit, _pid);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketConvexCrvCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a FXN Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _pid            Pool ID of FXN Convex LP\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createConvexFxnMarket(MarketInit calldata _marketInit, uint256 _pid, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketConvexFxn.clone();\n        IConvexFxnLPMarket(proxy).initialize(_getGlobalParams(), _marketInit, _pid);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketConvexFxnCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createCurveGaugeMarket(MarketInit calldata _marketInit, IGauge _gauge, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketCurveGauge.clone();\n        ICurveGaugeMarket(proxy).initialize(_getGlobalParams(), _marketInit, _gauge);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketCurveGaugeCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createStakeDaoVaultV2Market(\n        MarketInit calldata _marketInit,\n        IStakeDaoVaultV2 _vault,\n        IRParams calldata _irParams,\n        RCParams calldata _rcParams\n    ) external onlyOwner returns (address) {\n        address proxy = marketStakeDaoVaultV2.clone();\n        IStakeDaoVaultV2Market(proxy).initialize(_getGlobalParams(), _marketInit, _vault);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketStakeDaoVaultV2Created(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a basic ERC20 as collateral, without reward streaming coming from the collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createBasicERC20Market(MarketInit calldata _marketInit, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketBasicERC20.clone();\n        IBasicERC20Market(proxy).initialize(_getGlobalParams(), _marketInit);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit BasicERC20MarketCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    function _commonInitialize(address newProxy, IRParams calldata _irParams, IERC20[] calldata rewardTokens, RCParams calldata _rcParams) internal {\n        // Set market as minter and burner of USG\n        USG.initializeMarket(newProxy);\n        // Set up IRParams and initialize debt index for the market\n        irCalculator.initializeMarket(newProxy, _irParams);\n        // Set up RewardCut params and initialize debt index for the market\n        rewardAccumulator.initializeMarket(newProxy, rewardTokens, _rcParams);\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun"},"name":"MarketCreator","fullyQualifiedName":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_controlTower","type":"address","internalType":"contract IControlTower"},{"name":"_USG","type":"address","internalType":"contract IUSG"},{"name":"_irCalculator","type":"address","internalType":"contract IIRCalculator"},{"name":"_rewardAccumulator","type":"address","internalType":"contract IRewardAccumulator"},{"name":"_zappingProxy","type":"address","internalType":"contract IZappingProxy"},{"name":"_marketConvexCrv","type":"address","internalType":"address"},{"name":"_marketConvexFxn","type":"address","internalType":"address"},{"name":"_marketCurveGauge","type":"address","internalType":"address"},{"name":"_marketStakeDaoVaultV2","type":"address","internalType":"address"},{"name":"_marketBasicERC20","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"FailedDeployment","type":"error","inputs":[]},{"name":"InsufficientBalance","type":"error","inputs":[{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"BasicERC20MarketCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketConvexCrvCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketConvexFxnCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketCurveGaugeCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketStakeDaoVaultV2Created","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"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":"USG","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IUSG"}],"stateMutability":"view"},{"name":"controlTower","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IControlTower"}],"stateMutability":"view"},{"name":"createBasicERC20Market","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createConvexCrvMarket","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_pid","type":"uint256","internalType":"uint256"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createConvexFxnMarket","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_pid","type":"uint256","internalType":"uint256"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createCurveGaugeMarket","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_gauge","type":"address","internalType":"contract IGauge"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createStakeDaoVaultV2Market","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_vault","type":"address","internalType":"contract IStakeDaoVaultV2"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"irCalculator","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IIRCalculator"}],"stateMutability":"view"},{"name":"marketBasicERC20","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketConvexCrv","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketConvexFxn","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketCurveGauge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketStakeDaoVaultV2","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"rewardAccumulator","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IRewardAccumulator"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"zappingProxy","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IZappingProxy"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"contract IControlTower","name":"_controlTower","type":"address"},{"internalType":"contract IUSG","name":"_USG","type":"address"},{"internalType":"contract IIRCalculator","name":"_irCalculator","type":"address"},{"internalType":"contract IRewardAccumulator","name":"_rewardAccumulator","type":"address"},{"internalType":"contract IZappingProxy","name":"_zappingProxy","type":"address"},{"internalType":"address","name":"_marketConvexCrv","type":"address"},{"internalType":"address","name":"_marketConvexFxn","type":"address"},{"internalType":"address","name":"_marketCurveGauge","type":"address"},{"internalType":"address","name":"_marketStakeDaoVaultV2","type":"address"},{"internalType":"address","name":"_marketBasicERC20","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"FailedDeployment","type":"error"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"BasicERC20MarketCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketConvexCrvCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketConvexFxnCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketCurveGaugeCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"MarketStakeDaoVaultV2Created","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"},{"inputs":[],"name":"USG","outputs":[{"internalType":"contract IUSG","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controlTower","outputs":[{"internalType":"contract IControlTower","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createBasicERC20Market","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createConvexCrvMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"uint256","name":"_pid","type":"uint256"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createConvexFxnMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"contract IGauge","name":"_gauge","type":"address"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createCurveGaugeMarket","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"contract IERC20Metadata","name":"collatToken","type":"address"},{"internalType":"contract IPriceOracle","name":"collatOracle","type":"address"},{"internalType":"uint256","name":"maxLTV","type":"uint256"},{"internalType":"uint256","name":"liquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"liquidationFee","type":"uint256"},{"internalType":"uint256","name":"maxMarketDebt","type":"uint256"},{"internalType":"uint256","name":"minimumLoan","type":"uint256"},{"internalType":"contract IERC20[]","name":"rewardTokens","type":"address[]"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct MarketInit","name":"_marketInit","type":"tuple"},{"internalType":"contract IStakeDaoVaultV2","name":"_vault","type":"address"},{"components":[{"internalType":"bool","name":"isHEC","type":"bool"},{"internalType":"uint24","name":"rMin","type":"uint24"},{"internalType":"uint32","name":"rMax","type":"uint32"},{"internalType":"uint32","name":"pMin","type":"uint32"},{"internalType":"uint32","name":"pInf","type":"uint32"},{"internalType":"uint32","name":"pMax","type":"uint32"},{"internalType":"uint32","name":"a1","type":"uint32"},{"internalType":"uint32","name":"a2","type":"uint32"},{"internalType":"uint32","name":"k","type":"uint32"}],"internalType":"struct IRParams","name":"_irParams","type":"tuple"},{"components":[{"internalType":"uint16","name":"harvestFeePercentage","type":"uint16"},{"internalType":"uint16","name":"stepAmount","type":"uint16"},{"internalType":"uint32","name":"startCutPercentage","type":"uint32"},{"internalType":"uint32","name":"endCutPercentage","type":"uint32"},{"internalType":"uint80","name":"startCutPrice","type":"uint80"},{"internalType":"uint80","name":"endCutPrice","type":"uint80"}],"internalType":"struct RCParams","name":"_rcParams","type":"tuple"}],"name":"createStakeDaoVaultV2Market","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"irCalculator","outputs":[{"internalType":"contract IIRCalculator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketBasicERC20","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketConvexCrv","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketConvexFxn","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketCurveGauge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"marketStakeDaoVaultV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardAccumulator","outputs":[{"internalType":"contract IRewardAccumulator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"zappingProxy","outputs":[{"internalType":"contract IZappingProxy","name":"","type":"address"}],"stateMutability":"view","type":"function"}],"devdoc":{"author":"Tangent Finance","errors":{"FailedDeployment()":[{"details":"The deployment failed."}],"InsufficientBalance(uint256,uint256)":[{"details":"The ETH balance of the account is not enough to perform the operation."}]},"kind":"dev","methods":{"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"details":"Only on callable by DAO","params":{"_irParams":"Interest Rate parameters of the market","_marketInit":"Market init parameter containing all data related to the market","_rcParams":"Reward Cut parameters of the market"}},"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"details":"Only on callable by DAO","params":{"_irParams":"Interest Rate parameters of the market","_marketInit":"Market init parameter containing all data related to the market","_pid":"Pool ID of Curve Convex LP","_rcParams":"Reward Cut parameters of the market"}},"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"details":"Only on callable by DAO","params":{"_irParams":"Interest Rate parameters of the market","_marketInit":"Market init parameter containing all data related to the market","_pid":"Pool ID of FXN Convex LP","_rcParams":"Reward Cut parameters of the market"}},"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"details":"Only on callable by DAO","params":{"_irParams":"Interest Rate parameters of the market","_marketInit":"Market init parameter containing all data related to the market","_rcParams":"Reward Cut parameters of the market"}},"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"details":"Only on callable by DAO","params":{"_irParams":"Interest Rate parameters of the market","_marketInit":"Market init parameter containing all data related to the market","_rcParams":"Reward Cut parameters of the market"}},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"title":"MarketCreator","version":1},"userdoc":{"kind":"user","methods":{"USG()":{"notice":"USG token"},"controlTower()":{"notice":"Control tower"},"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a basic ERC20 as collateral, without reward streaming coming from the collateral."},"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."},"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a FXN Convex LP as Collateral."},"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."},"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."},"irCalculator()":{"notice":"IR Calculator"},"marketBasicERC20()":{"notice":"Basic ERC20 market implementation"},"marketConvexCrv()":{"notice":"Convex CRV market implementation"},"marketConvexFxn()":{"notice":"Convex FXN market implementation"},"marketCurveGauge()":{"notice":"Market Curve gauge implementation"},"marketStakeDaoVaultV2()":{"notice":"Market Curve gauge implementation"},"rewardAccumulator()":{"notice":"Reward accumulator"},"zappingProxy()":{"notice":"Zapping proxy"}},"notice":"Factory to deploy market following the Minimal proxy implementation","version":1}},"settings":{"compilationTarget":{"src/USG/Utilities/MarketCreator.sol":"MarketCreator"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":1000000},"remappings":[]},"sources":{"@openzeppelin/contracts/interfaces/IERC20.sol":{"keccak256":"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c","license":"MIT","urls":["bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba","dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1"]},"@openzeppelin/contracts/proxy/Clones.sol":{"keccak256":"0x83b10b9c4f3117f1bff30c49bc486d719de88c8425fe646bc8a5f998ee44ceb9","license":"MIT","urls":["bzz-raw://ef2774d5513d7567c3e886a875d90261e1173876324e88e5f21ce79cad14e188","dweb:/ipfs/QmRDkvYwjyHCyTahZ5BqaRz64VtxSzGiYTLmDkacC5yEqr"]},"@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/Create2.sol":{"keccak256":"0xbb7e8401583d26268ea9103013bcdcd90866a7718bd91105ebd21c9bf11f4f06","license":"MIT","urls":["bzz-raw://866a11ad89c93ee918078f7a46ae31e17d89216ce64603f0d34be7ed0a5c520e","dweb:/ipfs/QmW3ckLEJg2v2NzuVLNJFmRuerGSipw6Dzg6ntbmqbAGoC"]},"@openzeppelin/contracts/utils/Errors.sol":{"keccak256":"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123","license":"MIT","urls":["bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf","dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB"]},"src/USG/Utilities/MarketCreator.sol":{"keccak256":"0xdc754d6ba81979112dc961da3120617c0f57a46ca4074d5833382808b2158580","license":"MIT","urls":["bzz-raw://8a588e6f8e1eacd677c4b0481abf7c2b5a2a55f9070197bc1eae4bf8aaab8f94","dweb:/ipfs/QmRqbv8LDDpbMDxEtnYh7ZkUZnDjUTSYTvL5AL5sC3rEUL"]},"src/USG/Utilities/abstract/LightOwnable.sol":{"keccak256":"0x88c4c115ff0ba91e7d911c9d4dace8626f4622f56c1ee19dfbd612aff283e3b7","license":"UNLICENSED","urls":["bzz-raw://29ca7e825aca8d14f45c6ac7a17cb3995a9167b091fb8acf555bd501e8f65c90","dweb:/ipfs/QmfEAaoxwwnELfg3VW5yDu9rV3Q9hdXUCKkcvwQo9HCbyq"]},"src/interfaces/externals/Convex/ICvxRewardToken.sol":{"keccak256":"0x9f9787b8b4fba86d70b76c4d8c4cf402ec19141ec6b7b9c9680f42c429d47491","license":"MIT","urls":["bzz-raw://53f50ca7c36eb8f7fb77677d1910176b810bba1e3a4e89bdab57528be92b368a","dweb:/ipfs/QmfLfFruiPEZh6u2Eas2wi2GzoMVd4K6rEoeNqzDxjUReZ"]},"src/interfaces/externals/Convex/IStakingProxyERC20.sol":{"keccak256":"0x98deba4eae3addda273d78af4f7f9f21f9613e00f9ec8fca4bd4d7a5c4c33151","license":"MIT","urls":["bzz-raw://f73ea30fd3c38397326315358a70ba66710fa02d2541f4709d632b63ac784163","dweb:/ipfs/QmcJhmjQyRwFxX5keNJvVH1K78hzrY3JG8WsMhEqfEDEJi"]},"src/interfaces/externals/Curve/IGauge.sol":{"keccak256":"0x135032f400941bd825c0e27cadbdb955d7754040e0b93ab13a213ac17951d550","license":"MIT","urls":["bzz-raw://798d7f2def63947897312e9b1802d0f54f76593107037f19e9399e31134ec55f","dweb:/ipfs/QmZJBaVxxnXPgzepDsm7z6TZogRzUb1ud3zSE6FS21V45W"]},"src/interfaces/externals/FXN/ISharedLiquidityGauge.sol":{"keccak256":"0x54f7d7d973473d8aac40b0e165b58845128ff88389a3a20302f5a93862270e05","license":"MIT","urls":["bzz-raw://2979f05b62b34f014ae8bc1c7907e050f78e5c57e31043d439898c5796946dbe","dweb:/ipfs/QmSnDxsDbsTdnr32CXGTK8XA7YjNgjGErPQWikAyXepM4y"]},"src/interfaces/externals/StakeDao/IStakeDaoVaultV2.sol":{"keccak256":"0x727bb731ec546346813c73e0cd69e8831539584341b9a7dfff896d78432f607a","license":"MIT","urls":["bzz-raw://51a72621fff56c47e5eec8751c1b6a6ac8c68283c031611eea2d58148fa7b2f4","dweb:/ipfs/QmafqgwenPLAs7pxWFUac3Wfz6k3LLKU67AwKFaadnuwZk"]},"src/interfaces/internals/ICommonStruct.sol":{"keccak256":"0xe66889d5bf49a2f13723f5f1ff3f365b925ecd7d0dc387994cb0a9f0842aeede","license":"MIT","urls":["bzz-raw://94689e9878196025dc72cd58cdf9c97deb7ab79740d557ae44e0883e66d080ac","dweb:/ipfs/QmVceqC6CRy3tYLoQJsFoZritH2QiRC4dSVgXuXRb7X4hC"]},"src/interfaces/internals/USG/IBasicERC20Market.sol":{"keccak256":"0x981d6a4b1c8bb4cc133d8df2a160df94b30932e203904a618e9d00a878d762ca","license":"MIT","urls":["bzz-raw://3cdccd2d9a29ae58fe2b730380bcfc6c883a6c1c8d7b0b37fa0765baafbdda6e","dweb:/ipfs/QmeZpjQVGJ9orvS13ZPwRVzmFCJKRAkaKyKRhkHR6M92Rt"]},"src/interfaces/internals/USG/ICollateral.sol":{"keccak256":"0x9c1a059c6ae1bbc0c305419462be6f0655b517b12d2528a035d8dff2444cae53","license":"MIT","urls":["bzz-raw://46445e314d7b35cfc71b9b31d0e8a89fc807d1eee1be87ab88925a530ae16700","dweb:/ipfs/QmS4fkVszW4euaqqYqDbcEr1cbKbYA885Lcw38dEPozGKY"]},"src/interfaces/internals/USG/IControlTower.sol":{"keccak256":"0xa762b09652859e007148df15d5fe60b6678197c2f1aea19e53b453bd53d96eaf","license":"MIT","urls":["bzz-raw://cf3e1494e9e6df32bb48ac64e404341c626aad0d9dd633c958b07c085f3ededc","dweb:/ipfs/QmYhYCghWLjv8WzExcigYhPCANgyx67njKxisNj9tbjBjT"]},"src/interfaces/internals/USG/IConvexCrvLPMarket.sol":{"keccak256":"0xa73af7f4fbaefa19c00acdd2bc10b4d9fe63a1eb07261e6a1c85b7508c002713","license":"MIT","urls":["bzz-raw://03a9bb7e124dddd9f80078cf897887d6b7c1bfef210787701372972ac8a4a241","dweb:/ipfs/QmaFQuHwo8kzLVUQ9jZ7MTmtmhVregMBtf3yo3kBBhyR2x"]},"src/interfaces/internals/USG/IConvexFxnLPMarket.sol":{"keccak256":"0x93a9ed7c973c63b6febb8c8b4572a05ae2cef35f6e2337e80389a6c708ce3eb3","license":"MIT","urls":["bzz-raw://55de11a769b915c0544f44dbe336ce5e9e9fd10e3a2e40296470bfbb0fd562d5","dweb:/ipfs/QmNqeYD1hTGq2g2Ep76kEyWcUZ4otC1cMqquHECaMwtJhT"]},"src/interfaces/internals/USG/ICurveGaugeMarket.sol":{"keccak256":"0x696a189c89a33c20149c2007f7bcb3e874c5cbe801d611b0a42fa080ad682603","license":"MIT","urls":["bzz-raw://77781bb1d02e567aed21a15db009cb8442d8545b99f879fba77b88ea3a98cb0a","dweb:/ipfs/QmSJmwtPrhCD27J59PLse1ECmJrdbPoKBfH5VCJkWFa5cZ"]},"src/interfaces/internals/USG/IDebtIR.sol":{"keccak256":"0xf1b17238a3c8a96ce1ad44f5e772016a7a35722f7a76bb4f552516f949295943","license":"MIT","urls":["bzz-raw://e556853a4f5be1dd697de721a258e0183c5c6cb691eafbfc461884dca2b17026","dweb:/ipfs/QmXhbrRBFTpYKKBR9GiLQuL5n1c9hedZkfAC1W5RNRfJch"]},"src/interfaces/internals/USG/IIRCalculator.sol":{"keccak256":"0xec390b63b76bfdbf7165e66d652210b6774427d6cce7a38346babd016dc6c275","license":"MIT","urls":["bzz-raw://b83dfe894d175e626c4f6004f841b3817603e83bc08439ce6da9e94fdfe89efb","dweb:/ipfs/Qme99R42frMKaizYzo36FFLmWnNRiywnD8n6GsrEbaK6LK"]},"src/interfaces/internals/USG/IMarketCore.sol":{"keccak256":"0x1735a67e3ecc02afa53455ee5a3dd6444362dcb73ed3deeae48f35642a47ce70","license":"MIT","urls":["bzz-raw://d67495a8d2327d30c0407860af2f3b46e9c532d82c82ba3a4cfd6124af504297","dweb:/ipfs/QmSLp9C98kSFLpMyj72Tm8gHCzWAQDQ3kREvsCscpT2w7t"]},"src/interfaces/internals/USG/IPriceOracle.sol":{"keccak256":"0x1d696fafdc5f4d3a3eba8249ba885d76061d2767a1891f0fb27b88ffadcb091c","license":"MIT","urls":["bzz-raw://2d098310848e34010993e80e23276d50a2ce7bed605d7cf6835b5953b62147d7","dweb:/ipfs/Qmak9vsPkcLhSLGVDbb3Lvna72tNPvUVFZ3QrhCjuqCAgw"]},"src/interfaces/internals/USG/IRewardAccumulator.sol":{"keccak256":"0xd68ae48cf25d77fc53ee202c3e32fa2437d8f57de62bdfcad1eda8e997c09e0c","license":"MIT","urls":["bzz-raw://07632ade2c266a7d7b70177672e5d5acacae551e1298b356303a54a668fbb111","dweb:/ipfs/QmRT6sRbwo1amdxcGJdqhnCcoU5nNvFbv6msxBcpFfEieB"]},"src/interfaces/internals/USG/IStakeDaoVaultV2Market.sol":{"keccak256":"0xd12d8c289e20ce4636ef5c2a09a1f95fe90044bf0534d7ac35c63808ac7d2766","license":"MIT","urls":["bzz-raw://bd132112213871546786cd8665aef06ce8a3ea4a9ee68c2894f5c3837a36cc4a","dweb:/ipfs/QmPWuGVzmo7VmdmB5Gca3xB9gLxcb4vhRiCPtPVAyP66mL"]},"src/interfaces/internals/USG/IUSG.sol":{"keccak256":"0x39eb5da91c763740799025f16e060d8347a9c1bccbe8875c3a2d2942f9c600df","license":"MIT","urls":["bzz-raw://35c366e2978750d024de951ccf256d497c1d1b595084f1f785f4a860cb579a07","dweb:/ipfs/QmQpgHN6ub6H7DhYzGjAc4pzTjmpfmSzcj4xYcVnJo6rf7"]},"src/interfaces/internals/USG/IZappingProxy.sol":{"keccak256":"0xd32034c54886fe61815df81216157775bbec18d3687f9e8d073d327a27def691","license":"MIT","urls":["bzz-raw://e533f5e10391b9b2721a409a156ddc399a4d9947a33305b4b9dcd999a79b0f5d","dweb:/ipfs/QmUpAQvcbFCmRNizmvPP1qT5P3DVWRmfaEh9PTpjNbM8Tv"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_contract(IUSG)3581":{"label":"contract IUSG","encoding":"inplace","numberOfBytes":"20"},"t_contract(IControlTower)3005":{"label":"contract IControlTower","encoding":"inplace","numberOfBytes":"20"},"t_contract(IIRCalculator)3232":{"label":"contract IIRCalculator","encoding":"inplace","numberOfBytes":"20"},"t_contract(IZappingProxy)3606":{"label":"contract IZappingProxy","encoding":"inplace","numberOfBytes":"20"},"t_contract(IRewardAccumulator)3530":{"label":"contract IRewardAccumulator","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":1126,"label":"owner","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"1","type":"t_contract(IControlTower)3005","astId":673,"label":"controlTower","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"2","type":"t_contract(IUSG)3581","astId":677,"label":"USG","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"3","type":"t_contract(IIRCalculator)3232","astId":681,"label":"irCalculator","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"4","type":"t_contract(IRewardAccumulator)3530","astId":685,"label":"rewardAccumulator","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"5","type":"t_contract(IZappingProxy)3606","astId":689,"label":"zappingProxy","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"6","type":"t_address","astId":692,"label":"marketConvexCrv","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"7","type":"t_address","astId":695,"label":"marketConvexFxn","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"8","type":"t_address","astId":698,"label":"marketCurveGauge","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"9","type":"t_address","astId":701,"label":"marketStakeDaoVaultV2","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"10","type":"t_address","astId":704,"label":"marketBasicERC20","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Factory to deploy market following the Minimal proxy implementation","methods":{"USG()":{"notice":"USG token"},"controlTower()":{"notice":"Control tower"},"irCalculator()":{"notice":"IR Calculator"},"zappingProxy()":{"notice":"Zapping proxy"},"marketConvexCrv()":{"notice":"Convex CRV market implementation"},"marketConvexFxn()":{"notice":"Convex FXN market implementation"},"marketBasicERC20()":{"notice":"Basic ERC20 market implementation"},"marketCurveGauge()":{"notice":"Market Curve gauge implementation"},"rewardAccumulator()":{"notice":"Reward accumulator"},"marketStakeDaoVaultV2()":{"notice":"Market Curve gauge implementation"},"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a basic ERC20 as collateral, without reward streaming coming from the collateral."},"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."},"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a FXN Convex LP as Collateral."},"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."},"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."}},"version":1},"devdoc":{"kind":"dev","title":"MarketCreator","author":"Tangent Finance","errors":{"FailedDeployment()":[{"details":"The deployment failed."}],"InsufficientBalance(uint256,uint256)":[{"details":"The ETH balance of the account is not enough to perform the operation."}]},"methods":{"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_pid":"Pool ID of Curve Convex LP","_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_pid":"Pool ID of FXN Convex LP","_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"}},"version":1},"sourceIds":{"src/USG/Utilities/MarketCreator.sol":{"id":6},"src/interfaces/internals/USG/IUSG.sol":{"id":26},"@openzeppelin/contracts/proxy/Clones.sol":{"id":1},"@openzeppelin/contracts/utils/Errors.sol":{"id":5},"src/interfaces/internals/USG/IDebtIR.sol":{"id":20},"@openzeppelin/contracts/utils/Create2.sol":{"id":4},"src/interfaces/externals/Curve/IGauge.sol":{"id":10},"src/interfaces/internals/ICommonStruct.sol":{"id":13},"src/USG/Utilities/abstract/LightOwnable.sol":{"id":7},"src/interfaces/internals/USG/ICollateral.sol":{"id":15},"src/interfaces/internals/USG/IMarketCore.sol":{"id":22},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":0},"src/interfaces/internals/USG/IPriceOracle.sol":{"id":23},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":2},"src/interfaces/internals/USG/IControlTower.sol":{"id":16},"src/interfaces/internals/USG/IIRCalculator.sol":{"id":21},"src/interfaces/internals/USG/IZappingProxy.sol":{"id":27},"src/interfaces/internals/USG/IBasicERC20Market.sol":{"id":14},"src/interfaces/internals/USG/ICurveGaugeMarket.sol":{"id":19},"src/interfaces/externals/Convex/ICvxRewardToken.sol":{"id":8},"src/interfaces/internals/USG/IConvexCrvLPMarket.sol":{"id":17},"src/interfaces/internals/USG/IConvexFxnLPMarket.sol":{"id":18},"src/interfaces/internals/USG/IRewardAccumulator.sol":{"id":24},"src/interfaces/externals/Convex/IStakingProxyERC20.sol":{"id":9},"src/interfaces/externals/FXN/ISharedLiquidityGauge.sol":{"id":11},"src/interfaces/externals/StakeDao/IStakeDaoVaultV2.sol":{"id":12},"src/interfaces/internals/USG/IStakeDaoVaultV2Market.sol":{"id":25},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"additionalInput":null,"stdJsonInput":{"sources":{"src/USG/Utilities/MarketCreator.sol":{"content":"// SPDX-License-Identifier: MIT\n/**\n _____\n/  __ \\\n| /  \\/ ___  _ ____   _____ _ __ __ _  ___ _ __   ___ ___\n| |    / _ \\| '_ \\ \\ / / _ \\ '__/ _` |/ _ \\ '_ \\ / __/ _ \\\n| \\__/\\ (_) | | | \\ V /  __/ | | (_| |  __/ | | | (_|  __/\n \\____/\\___/|_| |_|\\_/ \\___|_|  \\__, |\\___|_| |_|\\___\\___|\n                                 __/ |\n                                |___/\n */\npragma solidity ^0.8.0;\n\nimport {LightOwnable} from \"../Utilities/abstract/LightOwnable.sol\";\nimport {Clones} from \"@openzeppelin/contracts/proxy/Clones.sol\";\n\nimport {GlobalMarketInitParams, MarketInit, IRewardAccumulator, IERC20Metadata, IERC20} from \"../../interfaces/internals/USG/IMarketCore.sol\";\nimport {IConvexCrvLPMarket, ICvxRewardToken} from \"../../interfaces/internals/USG/IConvexCrvLPMarket.sol\";\nimport {ICurveGaugeMarket, IGauge} from \"../../interfaces/internals/USG/ICurveGaugeMarket.sol\";\nimport {IStakeDaoVaultV2Market, IStakeDaoVaultV2} from \"../../interfaces/internals/USG/IStakeDaoVaultV2Market.sol\";\nimport {IConvexFxnLPMarket} from \"../../interfaces/internals/USG/IConvexFxnLPMarket.sol\";\nimport {IBasicERC20Market} from \"../../interfaces/internals/USG/IBasicERC20Market.sol\";\nimport {IControlTower} from \"../../interfaces/internals/USG/IControlTower.sol\";\nimport {IRParams, IIRCalculator} from \"../../interfaces/internals/USG/IIRCalculator.sol\";\nimport {RCParams} from \"../../interfaces/internals/USG/IRewardAccumulator.sol\";\nimport {IZappingProxy} from \"../../interfaces/internals/USG/IZappingProxy.sol\";\nimport {IUSG} from \"../../interfaces/internals/USG/IUSG.sol\";\n\n/// @title  MarketCreator\n/// @author Tangent Finance\n/// @notice Factory to deploy market following the Minimal proxy implementation\ncontract MarketCreator is LightOwnable {\n    using Clones for address;\n\n    /// @notice Control tower\n    IControlTower public controlTower;\n\n    /// @notice USG token\n    IUSG public USG;\n\n    /// @notice IR Calculator\n    IIRCalculator public irCalculator;\n\n    /// @notice Reward accumulator\n    IRewardAccumulator public rewardAccumulator;\n\n    /// @notice Zapping proxy\n    IZappingProxy public zappingProxy;\n\n    /// @notice Convex CRV market implementation\n    address public marketConvexCrv;\n\n    /// @notice Convex FXN market implementation\n    address public marketConvexFxn;\n\n    /// @notice Market Curve gauge implementation\n    address public marketCurveGauge;\n\n    /// @notice Market Curve gauge implementation\n    address public marketStakeDaoVaultV2;\n\n    /// @notice Basic ERC20 market implementation\n    address public marketBasicERC20;\n\n    event MarketConvexCrvCreated(address proxy, string name);\n    event MarketConvexFxnCreated(address proxy, string name);\n    event MarketCurveGaugeCreated(address proxy, string name);\n    event MarketStakeDaoVaultV2Created(address proxy, string name);\n    event BasicERC20MarketCreated(address proxy, string name);\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                            CONSTRUCTOR\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    constructor(\n        address _owner,\n        IControlTower _controlTower,\n        IUSG _USG,\n        IIRCalculator _irCalculator,\n        IRewardAccumulator _rewardAccumulator,\n        IZappingProxy _zappingProxy,\n        address _marketConvexCrv,\n        address _marketConvexFxn,\n        address _marketCurveGauge,\n        address _marketStakeDaoVaultV2,\n        address _marketBasicERC20\n    ) {\n        controlTower = _controlTower;\n        USG = _USG;\n        irCalculator = _irCalculator;\n        rewardAccumulator = _rewardAccumulator;\n        zappingProxy = _zappingProxy;\n        marketConvexCrv = _marketConvexCrv;\n        marketConvexFxn = _marketConvexFxn;\n        marketCurveGauge = _marketCurveGauge;\n        marketStakeDaoVaultV2 = _marketStakeDaoVaultV2;\n        marketBasicERC20 = _marketBasicERC20;\n        _transferOwnership(_owner);\n    }\n\n    function _getGlobalParams() internal view returns (GlobalMarketInitParams memory) {\n        return\n            GlobalMarketInitParams({\n                _owner: owner,\n                _USG: USG,\n                _controlTower: controlTower,\n                _irCalculator: irCalculator,\n                _rewardAccumulator: rewardAccumulator,\n                _zappingProxy: zappingProxy\n            });\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _pid            Pool ID of Curve Convex LP\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createConvexCrvMarket(MarketInit calldata _marketInit, uint256 _pid, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketConvexCrv.clone();\n        IConvexCrvLPMarket(proxy).initialize(_getGlobalParams(), _marketInit, _pid);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketConvexCrvCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a FXN Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _pid            Pool ID of FXN Convex LP\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createConvexFxnMarket(MarketInit calldata _marketInit, uint256 _pid, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketConvexFxn.clone();\n        IConvexFxnLPMarket(proxy).initialize(_getGlobalParams(), _marketInit, _pid);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketConvexFxnCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createCurveGaugeMarket(MarketInit calldata _marketInit, IGauge _gauge, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketCurveGauge.clone();\n        ICurveGaugeMarket(proxy).initialize(_getGlobalParams(), _marketInit, _gauge);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketCurveGaugeCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a Curve Convex LP as Collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createStakeDaoVaultV2Market(\n        MarketInit calldata _marketInit,\n        IStakeDaoVaultV2 _vault,\n        IRParams calldata _irParams,\n        RCParams calldata _rcParams\n    ) external onlyOwner returns (address) {\n        address proxy = marketStakeDaoVaultV2.clone();\n        IStakeDaoVaultV2Market(proxy).initialize(_getGlobalParams(), _marketInit, _vault);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit MarketStakeDaoVaultV2Created(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    /**\n     *  @notice Creates a market with a basic ERC20 as collateral, without reward streaming coming from the collateral.\n     *  @dev    Only on callable by DAO\n     *  @param _marketInit     Market init parameter containing all data related to the market\n     *  @param _irParams       Interest Rate parameters of the market\n     *  @param _rcParams       Reward Cut parameters of the market\n     */\n    function createBasicERC20Market(MarketInit calldata _marketInit, IRParams calldata _irParams, RCParams calldata _rcParams) external onlyOwner returns (address) {\n        address proxy = marketBasicERC20.clone();\n        IBasicERC20Market(proxy).initialize(_getGlobalParams(), _marketInit);\n        _commonInitialize(proxy, _irParams, _marketInit.rewardTokens, _rcParams);\n        emit BasicERC20MarketCreated(proxy, _marketInit.name);\n        return proxy;\n    }\n\n    function _commonInitialize(address newProxy, IRParams calldata _irParams, IERC20[] calldata rewardTokens, RCParams calldata _rcParams) internal {\n        // Set market as minter and burner of USG\n        USG.initializeMarket(newProxy);\n        // Set up IRParams and initialize debt index for the market\n        irCalculator.initializeMarket(newProxy, _irParams);\n        // Set up RewardCut params and initialize debt index for the market\n        rewardAccumulator.initializeMarket(newProxy, rewardTokens, _rcParams);\n    }\n}\n"},"src/interfaces/internals/USG/IUSG.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\n\ninterface IUSG is IERC20 {\n    function mintDebt(address to, uint256 amount) external;\n\n    function burnDebt(address from, uint256 amount) external;\n\n    function mintIR(uint256 amount) external;\n\n    function initializeMarket(address market) external;\n}\n"},"@openzeppelin/contracts/proxy/Clones.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (proxy/Clones.sol)\n\npragma solidity ^0.8.20;\n\nimport {Create2} from \"../utils/Create2.sol\";\nimport {Errors} from \"../utils/Errors.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-1167[ERC-1167] is a standard for\n * deploying minimal proxy contracts, also known as \"clones\".\n *\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\n *\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\n * deterministic method.\n */\nlibrary Clones {\n    error CloneArgumentsTooLong();\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n     *\n     * This function uses the create opcode, which should never revert.\n     */\n    function clone(address implementation) internal returns (address instance) {\n        return clone(implementation, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-clone-address-}[clone], but with a `value` parameter to send native currency\n     * to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function clone(address implementation, uint256 value) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        assembly (\"memory-safe\") {\n            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\n            // of the `implementation` address with the bytecode before the address.\n            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\n            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\n            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\n            instance := create(value, 0x09, 0x37)\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\n     *\n     * This function uses the create2 opcode and a `salt` to deterministically deploy\n     * the clone. Using the same `implementation` and `salt` multiple times will revert, since\n     * the clones cannot be deployed twice at the same address.\n     */\n    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\n        return cloneDeterministic(implementation, salt, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneDeterministic-address-bytes32-}[cloneDeterministic], but with\n     * a `value` parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneDeterministic(\n        address implementation,\n        bytes32 salt,\n        uint256 value\n    ) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        assembly (\"memory-safe\") {\n            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\n            // of the `implementation` address with the bytecode before the address.\n            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\n            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\n            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\n            instance := create2(value, 0x09, 0x37, salt)\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n     */\n    function predictDeterministicAddress(\n        address implementation,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            mstore(add(ptr, 0x38), deployer)\n            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)\n            mstore(add(ptr, 0x14), implementation)\n            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)\n            mstore(add(ptr, 0x58), salt)\n            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))\n            predicted := and(keccak256(add(ptr, 0x43), 0x55), 0xffffffffffffffffffffffffffffffffffffffff)\n        }\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\n     */\n    function predictDeterministicAddress(\n        address implementation,\n        bytes32 salt\n    ) internal view returns (address predicted) {\n        return predictDeterministicAddress(implementation, salt, address(this));\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom\n     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To\n     * access the arguments within the implementation, use {fetchCloneArgs}.\n     *\n     * This function uses the create opcode, which should never revert.\n     */\n    function cloneWithImmutableArgs(address implementation, bytes memory args) internal returns (address instance) {\n        return cloneWithImmutableArgs(implementation, args, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneWithImmutableArgs-address-bytes-}[cloneWithImmutableArgs], but with a `value`\n     * parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        uint256 value\n    ) internal returns (address instance) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        assembly (\"memory-safe\") {\n            instance := create(value, add(bytecode, 0x20), mload(bytecode))\n        }\n        if (instance == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation` with custom\n     * immutable arguments. These are provided through `args` and cannot be changed after deployment. To\n     * access the arguments within the implementation, use {fetchCloneArgs}.\n     *\n     * This function uses the create2 opcode and a `salt` to deterministically deploy the clone. Using the same\n     * `implementation`, `args` and `salt` multiple times will revert, since the clones cannot be deployed twice\n     * at the same address.\n     */\n    function cloneDeterministicWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal returns (address instance) {\n        return cloneDeterministicWithImmutableArgs(implementation, args, salt, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-}[cloneDeterministicWithImmutableArgs],\n     * but with a `value` parameter to send native currency to the new contract.\n     *\n     * NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)\n     * to always have enough balance for new deployments. Consider exposing this function under a payable method.\n     */\n    function cloneDeterministicWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        uint256 value\n    ) internal returns (address instance) {\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        return Create2.deploy(value, salt, bytecode);\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.\n     */\n    function predictDeterministicAddressWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt,\n        address deployer\n    ) internal pure returns (address predicted) {\n        bytes memory bytecode = _cloneCodeWithImmutableArgs(implementation, args);\n        return Create2.computeAddress(salt, keccak256(bytecode), deployer);\n    }\n\n    /**\n     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministicWithImmutableArgs}.\n     */\n    function predictDeterministicAddressWithImmutableArgs(\n        address implementation,\n        bytes memory args,\n        bytes32 salt\n    ) internal view returns (address predicted) {\n        return predictDeterministicAddressWithImmutableArgs(implementation, args, salt, address(this));\n    }\n\n    /**\n     * @dev Get the immutable args attached to a clone.\n     *\n     * - If `instance` is a clone that was deployed using `clone` or `cloneDeterministic`, this\n     *   function will return an empty array.\n     * - If `instance` is a clone that was deployed using `cloneWithImmutableArgs` or\n     *   `cloneDeterministicWithImmutableArgs`, this function will return the args array used at\n     *   creation.\n     * - If `instance` is NOT a clone deployed using this library, the behavior is undefined. This\n     *   function should only be used to check addresses that are known to be clones.\n     */\n    function fetchCloneArgs(address instance) internal view returns (bytes memory) {\n        bytes memory result = new bytes(instance.code.length - 45); // revert if length is too short\n        assembly (\"memory-safe\") {\n            extcodecopy(instance, add(result, 32), 45, mload(result))\n        }\n        return result;\n    }\n\n    /**\n     * @dev Helper that prepares the initcode of the proxy with immutable args.\n     *\n     * An assembly variant of this function requires copying the `args` array, which can be efficiently done using\n     * `mcopy`. Unfortunately, that opcode is not available before cancun. A pure solidity implementation using\n     * abi.encodePacked is more expensive but also more portable and easier to review.\n     *\n     * NOTE: https://eips.ethereum.org/EIPS/eip-170[EIP-170] limits the length of the contract code to 24576 bytes.\n     * With the proxy code taking 45 bytes, that limits the length of the immutable args to 24531 bytes.\n     */\n    function _cloneCodeWithImmutableArgs(\n        address implementation,\n        bytes memory args\n    ) private pure returns (bytes memory) {\n        if (args.length > 24531) revert CloneArgumentsTooLong();\n        return\n            abi.encodePacked(\n                hex\"61\",\n                uint16(args.length + 45),\n                hex\"3d81600a3d39f3363d3d373d3d3d363d73\",\n                implementation,\n                hex\"5af43d82803e903d91602b57fd5bf3\",\n                args\n            );\n    }\n}\n"},"@openzeppelin/contracts/utils/Errors.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},"src/interfaces/internals/USG/IDebtIR.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IIRCalculator} from \"./IIRCalculator.sol\";\n\ninterface IDebtIR {\n    function maxMarketDebt() external view returns (uint256);\n    function irCalculator() external view returns (IIRCalculator);\n    function minimumLoan() external view returns (uint256);\n    function userDebtShares(address user) external view returns (uint256);\n    function totalDebtShares() external view returns (uint256);\n    function badDebt() external view returns (uint256);\n}\n"},"@openzeppelin/contracts/utils/Create2.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Create2.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.\n * `CREATE2` can be used to compute in advance the address where a smart\n * contract will be deployed, which allows for interesting new mechanisms known\n * as 'counterfactual interactions'.\n *\n * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more\n * information.\n */\nlibrary Create2 {\n    /**\n     * @dev There's no code to deploy.\n     */\n    error Create2EmptyBytecode();\n\n    /**\n     * @dev Deploys a contract using `CREATE2`. The address where the contract\n     * will be deployed can be known in advance via {computeAddress}.\n     *\n     * The bytecode for a contract can be obtained from Solidity with\n     * `type(contractName).creationCode`.\n     *\n     * Requirements:\n     *\n     * - `bytecode` must not be empty.\n     * - `salt` must have not been used for `bytecode` already.\n     * - the factory must have a balance of at least `amount`.\n     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.\n     */\n    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n        if (bytecode.length == 0) {\n            revert Create2EmptyBytecode();\n        }\n        assembly (\"memory-safe\") {\n            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)\n            // if no address was created, and returndata is not empty, bubble revert\n            if and(iszero(addr), not(iszero(returndatasize()))) {\n                let p := mload(0x40)\n                returndatacopy(p, 0, returndatasize())\n                revert(p, returndatasize())\n            }\n        }\n        if (addr == address(0)) {\n            revert Errors.FailedDeployment();\n        }\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the\n     * `bytecodeHash` or `salt` will result in a new destination address.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {\n        return computeAddress(salt, bytecodeHash, address(this));\n    }\n\n    /**\n     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at\n     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.\n     */\n    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40) // Get free memory pointer\n\n            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |\n            // |-------------------|---------------------------------------------------------------------------|\n            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |\n            // | salt              |                                      BBBBBBBBBBBBB...BB                   |\n            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |\n            // | 0xFF              |            FF                                                             |\n            // |-------------------|---------------------------------------------------------------------------|\n            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |\n            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |\n\n            mstore(add(ptr, 0x40), bytecodeHash)\n            mstore(add(ptr, 0x20), salt)\n            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes\n            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff\n            mstore8(start, 0xff)\n            addr := and(keccak256(start, 85), 0xffffffffffffffffffffffffffffffffffffffff)\n        }\n    }\n}\n"},"src/interfaces/externals/Curve/IGauge.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface IGauge is IERC20Metadata {\n    function initialize(address _lp_token) external;\n    function integrate_checkpoint() external view returns (uint256);\n    function user_checkpoint(address addr) external returns (bool);\n    function claimable_tokens(address addr) external returns (uint256);\n    function claimed_reward(address _addr, address _token) external view returns (uint256);\n    function claimable_reward(address _user, address _reward_token) external view returns (uint256);\n    function set_rewards_receiver(address _receiver) external;\n    function claim_rewards() external;\n    function claim_rewards(address _addr) external;\n    function claim_rewards(address _addr, address _receiver) external;\n    function kick(address addr) external;\n    function deposit(uint256 _value) external;\n    function deposit(uint256 _value, address _addr) external;\n    function deposit(uint256 _value, address _addr, bool _claim_rewards) external;\n    function withdraw(uint256 _value) external;\n    function withdraw(uint256 _value, bool _claim_rewards) external;\n    function transfer(address _to, uint256 _value) external returns (bool);\n    function transferFrom(address _from, address _to, uint256 _value) external returns (bool);\n    function approve(address _spender, uint256 _value) external returns (bool);\n    function increaseAllowance(address _spender, uint256 _added_value) external returns (bool);\n    function decreaseAllowance(address _spender, uint256 _subtracted_value) external returns (bool);\n    function add_reward(address _reward_token, address _distributor) external;\n    function set_reward_distributor(address _reward_token, address _distributor) external;\n    function deposit_reward_token(address _reward_token, uint256 _amount) external;\n    function set_killed(bool _is_killed) external;\n    function lp_token() external view returns (address);\n    function future_epoch_time() external view returns (uint256);\n    function balanceOf(address arg0) external view returns (uint256);\n    function totalSupply() external view returns (uint256);\n    function allowance(address arg0, address arg1) external view returns (uint256);\n    function name() external view returns (string memory);\n    function symbol() external view returns (string memory);\n    function working_balances(address arg0) external view returns (uint256);\n    function working_supply() external view returns (uint256);\n    function period() external view returns (int128);\n    function period_timestamp(uint256 arg0) external view returns (uint256);\n    function integrate_inv_supply(uint256 arg0) external view returns (uint256);\n    function integrate_inv_supply_of(address arg0) external view returns (uint256);\n    function integrate_checkpoint_of(address arg0) external view returns (uint256);\n    function integrate_fraction(address arg0) external view returns (uint256);\n    function inflation_rate() external view returns (uint256);\n    function reward_count() external view returns (uint256);\n    function reward_tokens(uint256 arg0) external view returns (address);\n    function reward_data(address arg0) external view returns (address token, address distributor, uint256 period_finish, uint256 rate, uint256 last_update, uint256 integral);\n    function rewards_receiver(address arg0) external view returns (address);\n    function reward_integral_for(address arg0, address arg1) external view returns (uint256);\n    function is_killed() external view returns (bool);\n    function factory() external view returns (address);\n    function staking_token() external view returns (address);\n}\n"},"src/interfaces/internals/ICommonStruct.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\nstruct TokenAmount {\n    IERC20 token;\n    uint256 amount;\n}\nstruct ZapStruct {\n    address router;\n    bytes routerCall;\n}\nstruct ZapStructDeposit {\n    IERC20 tokenIn;\n    uint256 amountIn;\n    uint256 minAmountOut;\n    ZapStruct zap;\n}\n\nstruct ZapStructDepositNoMinAmount {\n    IERC20 tokenIn;\n    uint256 amountIn;\n    ZapStruct zap;\n}\n"},"src/USG/Utilities/abstract/LightOwnable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.22;\n\nabstract contract LightOwnable {\n    address public owner;\n\n    error OwnableUnauthorizedAccount(address account);\n\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\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 Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner != msg.sender) {\n            revert OwnableUnauthorizedAccount(msg.sender);\n        }\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"},"src/interfaces/internals/USG/ICollateral.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nimport {IDebtIR} from \"./IDebtIR.sol\";\nimport {IRewardAccumulator} from \"./IRewardAccumulator.sol\";\nimport {IPriceOracle} from \"./IPriceOracle.sol\";\n\ninterface ICollateral {\n    function collatOracle() external view returns (IPriceOracle);\n\n    function collatToken() external view returns (IERC20Metadata);\n\n    function collatDecimals() external view returns (uint256);\n\n    function collateralBalances(address account) external view returns (uint256);\n\n    function totalCollateral() external view returns (uint256);\n\n    function maxLTV() external view returns (uint256);\n\n    function liquidationThreshold() external view returns (uint256);\n\n    function rewardAccumulator() external view returns (IRewardAccumulator);\n\n    function getBalanceAndTotalCollateral(address account) external view returns (uint256, uint256);\n}\n"},"src/interfaces/internals/USG/IMarketCore.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {ZapStruct} from \"../ICommonStruct.sol\";\nimport {IIRCalculator} from \"./IIRCalculator.sol\";\nimport {IUSG} from \"./IUSG.sol\";\nimport {ICollateral, IERC20Metadata} from \"./ICollateral.sol\";\nimport {IControlTower} from \"./IControlTower.sol\";\nimport {IPriceOracle} from \"./IPriceOracle.sol\";\nimport {IZappingProxy} from \"./IZappingProxy.sol\";\nimport {IRewardAccumulator} from \"./IRewardAccumulator.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nstruct LiquidationPre {\n    uint256 newDebtIndex;\n    uint256 collatBalance;\n    uint256 _userDebtShares;\n    uint256 userDebt_;\n}\n\nstruct LiquidateIn {\n    address account;\n    PostLiquidate postLiquidate;\n    uint256 minCollatValueToLiquidate;\n}\n\nstruct LiquidateTransitionStruct {\n    LiquidateIn liquidateIn;\n    uint256 collatPrice;\n    uint256 newDebtIndex;\n    uint256 _collateralBalance;\n    uint256 _totalCollateral;\n    uint256 _userDebtShares;\n    uint256 _totalDebtShares;\n    uint256 userDebt;\n}\n\nstruct PostLiquidate {\n    uint256 collatAmountToLiquidate;\n    uint256 minUsgOut;\n    uint256 maxUsgToBurn;\n    uint256 minCollatAmountToLiquidate;\n    bool isReceiptOut;\n}\n\nstruct SelfLiquidateIn {\n    uint256 collatAmountToLiquidate;\n    uint256 usgToRepay;\n    uint256 maxUsgToBurn;\n    uint256 minUsgOut;\n    bool isReceiptOut;\n}\n\nstruct SelfLiquidateTransitionStruct {\n    SelfLiquidateIn selfLiquidateIn;\n    uint256 newDebtIndex;\n    uint256 _collateralBalance;\n    uint256 _totalCollateral;\n    uint256 _userDebtShares;\n    uint256 _totalDebtShares;\n    uint256 userDebt;\n}\n\nstruct LeverageIn {\n    uint256 collatToDeposit;\n    uint256 usgToFlashMint;\n    uint256 minCollatAmountOut;\n    bool isReceiptIn;\n}\n\nstruct GlobalMarketInitParams {\n    address _owner;\n    IUSG _USG;\n    IControlTower _controlTower;\n    IIRCalculator _irCalculator;\n    IRewardAccumulator _rewardAccumulator;\n    IZappingProxy _zappingProxy;\n}\n\nstruct MarketInit {\n    IERC20Metadata collatToken;\n    IPriceOracle collatOracle;\n    uint256 maxLTV;\n    uint256 liquidationThreshold;\n    uint256 liquidationFee;\n    uint256 maxMarketDebt;\n    uint256 minimumLoan;\n    IERC20[] rewardTokens;\n    string name;\n}\n"},"@openzeppelin/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"src/interfaces/internals/USG/IPriceOracle.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\ninterface IPriceOracle {\n    function latestAnswer(bool isNoFailMode) external view returns (uint256);\n\n    function latestAnswerUpdate(bool isNoFailMode) external returns (uint256);\n\n    function decimals() external view returns (uint8);\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"},"src/interfaces/internals/USG/IControlTower.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\nimport {IDebtIR} from \"./IDebtIR.sol\";\n\ninterface IControlTower {\n    function isMarketCreator(address marketCreator) external view returns (bool);\n\n    function isPositionMigrator(address migrator) external view returns (bool);\n\n    function isPauser(address pauser) external view returns (bool);\n\n    function feeTreasury() external view returns (address);\n}\n"},"src/interfaces/internals/USG/IIRCalculator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nstruct IRParams {\n    /// @dev Flag to determine if a Market is HEC or LEC\n    bool isHEC;\n    /// @dev Minimum IR reached at pMax.\n    ///      1_000 <=> 1% / 100_000 <=> 100%.\n    uint24 rMin;\n    /// @dev Maximum IR reached at pMin.\n    ///      1_000 <=> 1% / 100_000 <=> 100%.\n    uint32 rMax;\n    /// @dev Minimum price of USG where rMax is reached.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pMin;\n    /// @dev Inflexion price of USG where IR starts to increases more significantly.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pInf;\n    /// @dev Maximum price of USG where IR increases more significantly.\n    ///      980_000 <=> 0.98$ / 1_000_000 <=> 1$\n    uint32 pMax;\n    /// @dev Convexity of the curve before pInf\n    ///      2_000 <=> 2 / 4_500 <=> 4.5\n    uint32 a1;\n    /// @dev Convexity of the curve after pInf\n    ///      2_000 <=> 2 / 4_500 <=> 4.5\n    uint32 a2;\n    /// @dev Velocity of the transition between a1 and a2\n    ///      It's an integer. 250 <=> 250\n    uint32 k;\n}\n\nstruct IRCheckpoint {\n    uint216 ir;\n    uint40 timestamp;\n}\ninterface IIRCalculator {\n    function initializeMarket(address market, IRParams calldata _irParam) external;\n\n    function simulateIR(uint256 USGPrice, IRParams memory irParam) external view returns (uint256);\n\n    function computeIRForMarket(address market) external returns (uint256);\n\n    function checkpointIR(address market) external returns (uint256);\n\n    function newDebtIndex(address market) external view returns (uint256);\n\n    function irCheckpoints(address market) external view returns (uint216, uint40);\n\n    function debtIndexes(address market) external view returns (uint256);\n\n    function indexDelta(address market) external view returns (uint256);\n\n    function mintableInterests() external view returns (uint256);\n\n    function getIRParams(address market) external view returns (IRParams memory);\n\n    function getIRCheckpoint(address market) external view returns (IRCheckpoint memory);\n}\n"},"src/interfaces/internals/USG/IZappingProxy.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\n\nimport {ZapStruct} from \"../ICommonStruct.sol\";\n\ninterface IZappingProxy {\n    function zapProxy(IERC20 tokenIn, IERC20 tokenOut, uint256 minAmountOut, address receiver, ZapStruct calldata routerCall) external payable returns (uint256);\n}\n"},"src/interfaces/internals/USG/IBasicERC20Market.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\ninterface IBasicERC20Market {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit) external;\n}\n"},"src/interfaces/internals/USG/ICurveGaugeMarket.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IGauge} from \"../../externals/Curve/IGauge.sol\";\ninterface ICurveGaugeMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, IGauge _gauge) external;\n}\n"},"src/interfaces/externals/Convex/ICvxRewardToken.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\nimport {IERC20, IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface ICvxRewardToken is IERC20 {\n    function addExtraReward(address _reward) external returns (bool);\n\n    function balanceOf(address account) external view returns (uint256);\n\n    function clearExtraRewards() external;\n\n    function currentRewards() external view returns (uint256);\n\n    function donate(uint256 _amount) external returns (bool);\n\n    function duration() external view returns (uint256);\n\n    function earned(address account) external view returns (uint256);\n\n    function extraRewards(uint256) external view returns (address);\n\n    function extraRewardsLength() external view returns (uint256);\n\n    function getReward() external returns (bool);\n\n    function getReward(address _account, bool _claimExtras) external returns (bool);\n\n    function historicalRewards() external view returns (uint256);\n\n    function lastTimeRewardApplicable() external view returns (uint256);\n\n    function lastUpdateTime() external view returns (uint256);\n\n    function newRewardRatio() external view returns (uint256);\n\n    function operator() external view returns (address);\n\n    function periodFinish() external view returns (uint256);\n\n    function pid() external view returns (uint256);\n\n    function queueNewRewards(uint256 _rewards) external returns (bool);\n\n    function queuedRewards() external view returns (uint256);\n\n    function rewardManager() external view returns (address);\n\n    function rewardPerToken() external view returns (uint256);\n\n    function rewardPerTokenStored() external view returns (uint256);\n\n    function rewardRate() external view returns (uint256);\n\n    function rewardToken() external view returns (address);\n\n    function rewards(address) external view returns (uint256);\n\n    function stake(uint256 _amount) external returns (bool);\n\n    function stakeAll() external returns (bool);\n\n    function stakeFor(address _for, uint256 _amount) external returns (bool);\n\n    function stakingToken() external view returns (IERC20Metadata);\n\n    function totalSupply() external view returns (uint256);\n\n    function userRewardPerTokenPaid(address) external view returns (uint256);\n\n    function withdraw(uint256 amount, bool claim) external returns (bool);\n\n    function withdrawAll(bool claim) external;\n\n    function withdrawAllAndUnwrap(bool claim) external;\n\n    function withdrawAndUnwrap(uint256 amount, bool claim) external returns (bool);\n}\n"},"src/interfaces/internals/USG/IConvexCrvLPMarket.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {ICvxRewardToken} from \"../../externals/Convex/ICvxRewardToken.sol\";\ninterface IConvexCrvLPMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, uint256 _pid) external;\n\n    function cvxRewardToken() external view returns (ICvxRewardToken);\n}\n"},"src/interfaces/internals/USG/IConvexFxnLPMarket.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IStakingProxyERC20} from \"../../externals/Convex/IStakingProxyERC20.sol\";\ninterface IConvexFxnLPMarket {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, uint256 _pid) external;\n\n    function stakingProxyVault() external view returns (IStakingProxyERC20);\n}\n"},"src/interfaces/internals/USG/IRewardAccumulator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {TokenAmount, IERC20} from \"../ICommonStruct.sol\";\n\nstruct Reward {\n    uint128 lastUpdateTime;\n    uint128 periodFinish;\n    uint256 rewardRate;\n    uint256 rewardPerTokenStored;\n}\nstruct RCParams {\n    uint16 harvestFeePercentage;\n    /// @dev Amount of distincts reward cut steps.\n    uint16 stepAmount;\n    /// @dev Percentage minimum of the reward cut.\n    uint32 startCutPercentage;\n    /// @dev Percentage maximum of the reward cut.\n    uint32 endCutPercentage;\n    /// @dev Price of USG on which the reward cut starts to increase.\n    uint80 startCutPrice;\n    /// @dev Price of USG on which the reward cut is at its maximum\n    uint80 endCutPrice;\n}\ninterface IRewardAccumulator {\n    function cutFeeForToken(IERC20 token) external view returns (uint256);\n\n    function getRewardData(address market, IERC20 token) external view returns (Reward memory);\n\n    function updateRewards(address account, uint256 collateralBalances, uint256 totalCollateral) external;\n\n    function processRewards(address market, address harvestFeeReceiver) external;\n\n    function getRewardTokens(address markets) external view returns (IERC20[] memory);\n\n    function lastRewardCuts(address market) external view returns (uint256);\n\n    function claimableRewards(address market, address _account) external view returns (TokenAmount[] memory userRewards);\n\n    function simulateRC(uint256 USGPrice, RCParams calldata rcParams) external pure returns (uint256);\n\n    function computeRCForMarket(address market) external returns (uint256);\n\n    function initializeMarket(address market, IERC20[] calldata rewardTokens, RCParams calldata _rcParams) external;\n\n    function getRCParams(address markets) external view returns (RCParams memory);\n}\n"},"src/interfaces/externals/Convex/IStakingProxyERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport \"../FXN/ISharedLiquidityGauge.sol\";\ninterface IStakingProxyERC20 {\n    function FEE_DENOMINATOR() external view returns (uint256);\n    function deposit(uint256 _amount, bool _manage) external;\n    function deposit(uint256 _amount) external;\n    function earned() external returns (address[] memory token_addresses, uint256[] memory total_earned);\n    function execute(address _to, uint256 _value, bytes memory _data) external returns (bool, bytes memory);\n    function feeRegistry() external view returns (address);\n    function fxn() external view returns (address);\n    function fxnMinter() external view returns (address);\n    function gaugeAddress() external view returns (ISharedLiquidityGauge);\n    function getReward() external;\n    function getReward(bool _claim, address[] memory _tokenList) external;\n    function getReward(bool _claim) external;\n    function initialize(address _owner, uint256 _pid) external;\n    function owner() external view returns (address);\n    function pid() external view returns (uint256);\n    function poolRegistry() external view returns (address);\n    function rewards() external view returns (address);\n    function setVeFXNProxy(address _proxy) external;\n    function stakingToken() external view returns (address);\n    function transferTokens(address[] memory _tokenList) external;\n    function usingProxy() external view returns (address);\n    function vaultType() external pure returns (uint8);\n    function vaultVersion() external pure returns (uint256);\n    function vefxnProxy() external view returns (address);\n    function withdraw(uint256 _amount) external;\n}\n"},"src/interfaces/externals/FXN/ISharedLiquidityGauge.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\ninterface ISharedLiquidityGauge {\n    function DEFAULT_ADMIN_ROLE() external view returns (bytes32);\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n    function REWARD_MANAGER_ROLE() external view returns (bytes32);\n    function acceptSharedVote(address _newOwner) external;\n    function allowance(address owner, address spender) external view returns (uint256);\n    function approve(address spender, uint256 amount) external returns (bool);\n    function balanceOf(address account) external view returns (uint256);\n    function checkpoint(address _account) external;\n    function claim(address _account) external;\n    function claim(address _account, address _receiver) external;\n    function claim() external;\n    function claimHistorical(address[] memory _tokens) external;\n    function claimHistorical(address _account, address[] memory _tokens) external;\n    function claimable(address _account, address _token) external view returns (uint256);\n    function claimed(address _account, address _token) external view returns (uint256);\n    function controller() external view returns (address);\n    function decimals() external view returns (uint8);\n    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);\n    function deposit(uint256 _amount, address _receiver) external;\n    function deposit(uint256 _amount, address _receiver, bool _manage) external;\n    function deposit(uint256 _amount) external;\n    function depositReward(address _token, uint256 _amount) external;\n    function disableGauge() external;\n    function distributors(address) external view returns (address);\n    function eip712Domain()\n        external\n        view\n        returns (bytes1 fields, string memory name, string memory version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] memory extensions);\n    function getActiveRewardTokens() external view returns (address[] memory _rewardTokens);\n    function getHistoricalRewardTokens() external view returns (address[] memory _rewardTokens);\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n    function getStakerVoteOwner(address _account) external view returns (address);\n    function governanceToken() external view returns (address);\n    function grantRole(bytes32 role, address account) external;\n    function hasRole(bytes32 role, address account) external view returns (bool);\n    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);\n    function inflationParams() external view returns (uint192 rate, uint64 futureEpochTime);\n    function initialize(address _stakingToken) external;\n    function integrate_fraction(address account) external view returns (uint256);\n    function isActive() external view returns (bool);\n    function isStakerAllowed(address, address) external view returns (bool);\n    function kick(address _account) external;\n    function manager() external view returns (address);\n    function minter() external view returns (address);\n    function name() external view returns (string memory);\n    function nonces(address owner) external view returns (uint256);\n    function numAcceptedStakers(address) external view returns (uint256);\n    function pendingRewards(address _token) external view returns (uint256, uint256);\n    function periodLength() external view returns (uint40);\n    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;\n    function registerRewardToken(address _token, address _distributor) external;\n    function rejectSharedVote() external;\n    function renounceRole(bytes32 role, address account) external;\n    function revokeRole(bytes32 role, address account) external;\n    function rewardData(address) external view returns (uint96 queued, uint80 rate, uint40 lastUpdate, uint40 finishAt);\n    function rewardReceiver(address) external view returns (address);\n    function rewardSnapshot(address) external view returns (uint64 timestamp, uint192 integral);\n    function setRewardReceiver(address _newReceiver) external;\n    function sharedBalanceOf(address) external view returns (uint256);\n    function snapshot() external view returns (uint64 timestamp, uint192 integral);\n    function stakingToken() external view returns (address);\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n    function symbol() external view returns (string memory);\n    function toggleVoteSharing(address _staker) external;\n    function totalSupply() external view returns (uint256);\n    function transfer(address to, uint256 amount) external returns (bool);\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n    function unregisterRewardToken(address _token) external;\n    function updateLiquidityManager(address _newManager) external;\n    function updateRewardDistributor(address _token, address _newDistributor) external;\n    function user_checkpoint(address _account) external returns (bool);\n    function ve() external view returns (address);\n    function veProxy() external view returns (address);\n    function withdraw(uint256 _amount, address _receiver) external;\n    function withdraw(uint256 _amount) external;\n    function workingBalanceOf(address) external view returns (uint256);\n    function workingSupply() external view returns (uint256);\n}\n"},"src/interfaces/externals/StakeDao/IStakeDaoVaultV2.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport {IERC20Metadata, IERC20} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface IStakeDaoVaultV2 is IERC20Metadata {\n    function ACCOUNTANT() external view returns (address);\n    function DEFAULT_REWARDS_DURATION() external view returns (uint32);\n    function POLICY() external view returns (uint8);\n    function PROTOCOL_CONTROLLER() external view returns (address);\n    function PROTOCOL_ID() external view returns (bytes4);\n    function accountData(address account, address rewardToken) external view returns (uint128 rewardPerTokenPaid, uint128 claimable);\n    function addRewardToken(address rewardToken, address distributor) external;\n    function allocator() external view returns (address _allocator);\n    function allowance(address owner, address spender) external view returns (uint256);\n    function approve(address spender, uint256 value) external returns (bool);\n    function asset() external view returns (address);\n    function balanceOf(address account) external view returns (uint256);\n    function checkpoint(address account) external;\n    function claim(address[] calldata tokens, address receiver) external returns (uint256[] memory amounts);\n    function claim(address account, address[] calldata tokens, address receiver) external returns (uint256[] memory amounts);\n    function convertToAssets(uint256 shares) external pure returns (uint256);\n    function convertToShares(uint256 assets) external pure returns (uint256);\n    function decimals() external view returns (uint8);\n    function deposit(uint256 assets, address receiver, address referrer) external returns (uint256);\n    function deposit(address account, address receiver, uint256 assets, address referrer) external returns (uint256);\n    function deposit(uint256 assets, address receiver) external returns (uint256);\n    function depositRewards(address rewardToken, uint128 amount) external;\n    function earned(address account, address token) external view returns (uint128);\n    function gauge() external view returns (address _gauge);\n    function getClaimable(address token, address account) external view returns (uint128);\n    function getLastUpdateTime(address token) external view returns (uint32);\n    function getPeriodFinish(address token) external view returns (uint32);\n    function getRewardPerTokenPaid(address token, address account) external view returns (uint128);\n    function getRewardPerTokenStored(address token) external view returns (uint128);\n    function getRewardRate(address token) external view returns (uint128);\n    function getRewardTokens() external view returns (address[] memory);\n    function getRewardsDistributor(address token) external view returns (address);\n    function isRewardToken(address rewardToken) external view returns (bool);\n    function lastTimeRewardApplicable(address token) external view returns (uint256);\n    function maxDeposit(address) external pure returns (uint256);\n    function maxMint(address _account) external pure returns (uint256);\n    function maxRedeem(address owner) external view returns (uint256);\n    function maxWithdraw(address owner) external view returns (uint256);\n    function mint(uint256 shares, address receiver) external returns (uint256);\n    function mint(uint256 shares, address receiver, address referrer) external returns (uint256);\n    function name() external view returns (string memory);\n    function previewDeposit(uint256 shares) external pure returns (uint256);\n    function previewMint(uint256 assets) external pure returns (uint256);\n    function previewRedeem(uint256 shares) external pure returns (uint256);\n    function previewWithdraw(uint256 assets) external pure returns (uint256);\n    function redeem(uint256 shares, address receiver, address owner) external returns (uint256);\n    function resumeVault() external;\n    function rewardData(\n        address rewardToken\n    ) external view returns (address rewardsDistributor, uint32 lastUpdateTime, uint32 periodFinish, uint128 rewardRate, uint128 rewardPerTokenStored);\n    function rewardPerToken(address token) external view returns (uint128);\n    function strategy() external view returns (address _strategy);\n    function symbol() external view returns (string memory);\n    function totalAssets() external view returns (uint256);\n    function totalSupply() external view returns (uint256);\n    function transfer(address to, uint256 value) external returns (bool);\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256);\n}\n"},"src/interfaces/internals/USG/IStakeDaoVaultV2Market.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {GlobalMarketInitParams, MarketInit} from \"./IMarketCore.sol\";\nimport {IStakeDaoVaultV2} from \"../../externals/StakeDao/IStakeDaoVaultV2.sol\";\ninterface IStakeDaoVaultV2Market {\n    function initialize(GlobalMarketInitParams memory _marketConstants, MarketInit memory _marketInit, IStakeDaoVaultV2 _vault) external;\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":{"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun"}},"stdJsonOutput":{"sources":{"src/USG/Utilities/MarketCreator.sol":{"id":6},"src/interfaces/internals/USG/IUSG.sol":{"id":26},"@openzeppelin/contracts/proxy/Clones.sol":{"id":1},"@openzeppelin/contracts/utils/Errors.sol":{"id":5},"src/interfaces/internals/USG/IDebtIR.sol":{"id":20},"@openzeppelin/contracts/utils/Create2.sol":{"id":4},"src/interfaces/externals/Curve/IGauge.sol":{"id":10},"src/interfaces/internals/ICommonStruct.sol":{"id":13},"src/USG/Utilities/abstract/LightOwnable.sol":{"id":7},"src/interfaces/internals/USG/ICollateral.sol":{"id":15},"src/interfaces/internals/USG/IMarketCore.sol":{"id":22},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":0},"src/interfaces/internals/USG/IPriceOracle.sol":{"id":23},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":2},"src/interfaces/internals/USG/IControlTower.sol":{"id":16},"src/interfaces/internals/USG/IIRCalculator.sol":{"id":21},"src/interfaces/internals/USG/IZappingProxy.sol":{"id":27},"src/interfaces/internals/USG/IBasicERC20Market.sol":{"id":14},"src/interfaces/internals/USG/ICurveGaugeMarket.sol":{"id":19},"src/interfaces/externals/Convex/ICvxRewardToken.sol":{"id":8},"src/interfaces/internals/USG/IConvexCrvLPMarket.sol":{"id":17},"src/interfaces/internals/USG/IConvexFxnLPMarket.sol":{"id":18},"src/interfaces/internals/USG/IRewardAccumulator.sol":{"id":24},"src/interfaces/externals/Convex/IStakingProxyERC20.sol":{"id":9},"src/interfaces/externals/FXN/ISharedLiquidityGauge.sol":{"id":11},"src/interfaces/externals/StakeDao/IStakeDaoVaultV2.sol":{"id":12},"src/interfaces/internals/USG/IStakeDaoVaultV2Market.sol":{"id":25},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"contracts":{"src/USG/Utilities/MarketCreator.sol":{"MarketCreator":{"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_controlTower","type":"address","internalType":"contract IControlTower"},{"name":"_USG","type":"address","internalType":"contract IUSG"},{"name":"_irCalculator","type":"address","internalType":"contract IIRCalculator"},{"name":"_rewardAccumulator","type":"address","internalType":"contract IRewardAccumulator"},{"name":"_zappingProxy","type":"address","internalType":"contract IZappingProxy"},{"name":"_marketConvexCrv","type":"address","internalType":"address"},{"name":"_marketConvexFxn","type":"address","internalType":"address"},{"name":"_marketCurveGauge","type":"address","internalType":"address"},{"name":"_marketStakeDaoVaultV2","type":"address","internalType":"address"},{"name":"_marketBasicERC20","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"FailedDeployment","type":"error","inputs":[]},{"name":"InsufficientBalance","type":"error","inputs":[{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"BasicERC20MarketCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketConvexCrvCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketConvexFxnCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketCurveGaugeCreated","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"name":"MarketStakeDaoVaultV2Created","type":"event","inputs":[{"name":"proxy","type":"address","indexed":false,"internalType":"address"},{"name":"name","type":"string","indexed":false,"internalType":"string"}],"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":"USG","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IUSG"}],"stateMutability":"view"},{"name":"controlTower","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IControlTower"}],"stateMutability":"view"},{"name":"createBasicERC20Market","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createConvexCrvMarket","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_pid","type":"uint256","internalType":"uint256"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createConvexFxnMarket","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_pid","type":"uint256","internalType":"uint256"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createCurveGaugeMarket","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_gauge","type":"address","internalType":"contract IGauge"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"createStakeDaoVaultV2Market","type":"function","inputs":[{"name":"_marketInit","type":"tuple","components":[{"name":"collatToken","type":"address","internalType":"contract IERC20Metadata"},{"name":"collatOracle","type":"address","internalType":"contract IPriceOracle"},{"name":"maxLTV","type":"uint256","internalType":"uint256"},{"name":"liquidationThreshold","type":"uint256","internalType":"uint256"},{"name":"liquidationFee","type":"uint256","internalType":"uint256"},{"name":"maxMarketDebt","type":"uint256","internalType":"uint256"},{"name":"minimumLoan","type":"uint256","internalType":"uint256"},{"name":"rewardTokens","type":"address[]","internalType":"contract IERC20[]"},{"name":"name","type":"string","internalType":"string"}],"internalType":"struct MarketInit"},{"name":"_vault","type":"address","internalType":"contract IStakeDaoVaultV2"},{"name":"_irParams","type":"tuple","components":[{"name":"isHEC","type":"bool","internalType":"bool"},{"name":"rMin","type":"uint24","internalType":"uint24"},{"name":"rMax","type":"uint32","internalType":"uint32"},{"name":"pMin","type":"uint32","internalType":"uint32"},{"name":"pInf","type":"uint32","internalType":"uint32"},{"name":"pMax","type":"uint32","internalType":"uint32"},{"name":"a1","type":"uint32","internalType":"uint32"},{"name":"a2","type":"uint32","internalType":"uint32"},{"name":"k","type":"uint32","internalType":"uint32"}],"internalType":"struct IRParams"},{"name":"_rcParams","type":"tuple","components":[{"name":"harvestFeePercentage","type":"uint16","internalType":"uint16"},{"name":"stepAmount","type":"uint16","internalType":"uint16"},{"name":"startCutPercentage","type":"uint32","internalType":"uint32"},{"name":"endCutPercentage","type":"uint32","internalType":"uint32"},{"name":"startCutPrice","type":"uint80","internalType":"uint80"},{"name":"endCutPrice","type":"uint80","internalType":"uint80"}],"internalType":"struct RCParams"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"irCalculator","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IIRCalculator"}],"stateMutability":"view"},{"name":"marketBasicERC20","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketConvexCrv","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketConvexFxn","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketCurveGauge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"marketStakeDaoVaultV2","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"rewardAccumulator","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IRewardAccumulator"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"zappingProxy","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IZappingProxy"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"contract IControlTower\",\"name\":\"_controlTower\",\"type\":\"address\"},{\"internalType\":\"contract IUSG\",\"name\":\"_USG\",\"type\":\"address\"},{\"internalType\":\"contract IIRCalculator\",\"name\":\"_irCalculator\",\"type\":\"address\"},{\"internalType\":\"contract IRewardAccumulator\",\"name\":\"_rewardAccumulator\",\"type\":\"address\"},{\"internalType\":\"contract IZappingProxy\",\"name\":\"_zappingProxy\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_marketConvexCrv\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_marketConvexFxn\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_marketCurveGauge\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_marketStakeDaoVaultV2\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_marketBasicERC20\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"FailedDeployment\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"proxy\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"BasicERC20MarketCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"proxy\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"MarketConvexCrvCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"proxy\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"MarketConvexFxnCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"proxy\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"MarketCurveGaugeCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"proxy\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"MarketStakeDaoVaultV2Created\",\"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\"},{\"inputs\":[],\"name\":\"USG\",\"outputs\":[{\"internalType\":\"contract IUSG\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"controlTower\",\"outputs\":[{\"internalType\":\"contract IControlTower\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"contract IERC20Metadata\",\"name\":\"collatToken\",\"type\":\"address\"},{\"internalType\":\"contract IPriceOracle\",\"name\":\"collatOracle\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxLTV\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxMarketDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minimumLoan\",\"type\":\"uint256\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"rewardTokens\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"internalType\":\"struct MarketInit\",\"name\":\"_marketInit\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"isHEC\",\"type\":\"bool\"},{\"internalType\":\"uint24\",\"name\":\"rMin\",\"type\":\"uint24\"},{\"internalType\":\"uint32\",\"name\":\"rMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMin\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pInf\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a1\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a2\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"k\",\"type\":\"uint32\"}],\"internalType\":\"struct IRParams\",\"name\":\"_irParams\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"harvestFeePercentage\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"stepAmount\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"startCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"endCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint80\",\"name\":\"startCutPrice\",\"type\":\"uint80\"},{\"internalType\":\"uint80\",\"name\":\"endCutPrice\",\"type\":\"uint80\"}],\"internalType\":\"struct RCParams\",\"name\":\"_rcParams\",\"type\":\"tuple\"}],\"name\":\"createBasicERC20Market\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"contract IERC20Metadata\",\"name\":\"collatToken\",\"type\":\"address\"},{\"internalType\":\"contract IPriceOracle\",\"name\":\"collatOracle\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxLTV\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxMarketDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minimumLoan\",\"type\":\"uint256\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"rewardTokens\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"internalType\":\"struct MarketInit\",\"name\":\"_marketInit\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"_pid\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"isHEC\",\"type\":\"bool\"},{\"internalType\":\"uint24\",\"name\":\"rMin\",\"type\":\"uint24\"},{\"internalType\":\"uint32\",\"name\":\"rMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMin\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pInf\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a1\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a2\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"k\",\"type\":\"uint32\"}],\"internalType\":\"struct IRParams\",\"name\":\"_irParams\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"harvestFeePercentage\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"stepAmount\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"startCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"endCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint80\",\"name\":\"startCutPrice\",\"type\":\"uint80\"},{\"internalType\":\"uint80\",\"name\":\"endCutPrice\",\"type\":\"uint80\"}],\"internalType\":\"struct RCParams\",\"name\":\"_rcParams\",\"type\":\"tuple\"}],\"name\":\"createConvexCrvMarket\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"contract IERC20Metadata\",\"name\":\"collatToken\",\"type\":\"address\"},{\"internalType\":\"contract IPriceOracle\",\"name\":\"collatOracle\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxLTV\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxMarketDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minimumLoan\",\"type\":\"uint256\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"rewardTokens\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"internalType\":\"struct MarketInit\",\"name\":\"_marketInit\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"_pid\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"isHEC\",\"type\":\"bool\"},{\"internalType\":\"uint24\",\"name\":\"rMin\",\"type\":\"uint24\"},{\"internalType\":\"uint32\",\"name\":\"rMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMin\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pInf\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a1\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a2\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"k\",\"type\":\"uint32\"}],\"internalType\":\"struct IRParams\",\"name\":\"_irParams\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"harvestFeePercentage\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"stepAmount\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"startCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"endCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint80\",\"name\":\"startCutPrice\",\"type\":\"uint80\"},{\"internalType\":\"uint80\",\"name\":\"endCutPrice\",\"type\":\"uint80\"}],\"internalType\":\"struct RCParams\",\"name\":\"_rcParams\",\"type\":\"tuple\"}],\"name\":\"createConvexFxnMarket\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"contract IERC20Metadata\",\"name\":\"collatToken\",\"type\":\"address\"},{\"internalType\":\"contract IPriceOracle\",\"name\":\"collatOracle\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxLTV\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxMarketDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minimumLoan\",\"type\":\"uint256\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"rewardTokens\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"internalType\":\"struct MarketInit\",\"name\":\"_marketInit\",\"type\":\"tuple\"},{\"internalType\":\"contract IGauge\",\"name\":\"_gauge\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"isHEC\",\"type\":\"bool\"},{\"internalType\":\"uint24\",\"name\":\"rMin\",\"type\":\"uint24\"},{\"internalType\":\"uint32\",\"name\":\"rMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMin\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pInf\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a1\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a2\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"k\",\"type\":\"uint32\"}],\"internalType\":\"struct IRParams\",\"name\":\"_irParams\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"harvestFeePercentage\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"stepAmount\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"startCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"endCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint80\",\"name\":\"startCutPrice\",\"type\":\"uint80\"},{\"internalType\":\"uint80\",\"name\":\"endCutPrice\",\"type\":\"uint80\"}],\"internalType\":\"struct RCParams\",\"name\":\"_rcParams\",\"type\":\"tuple\"}],\"name\":\"createCurveGaugeMarket\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"contract IERC20Metadata\",\"name\":\"collatToken\",\"type\":\"address\"},{\"internalType\":\"contract IPriceOracle\",\"name\":\"collatOracle\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maxLTV\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidationFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxMarketDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minimumLoan\",\"type\":\"uint256\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"rewardTokens\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"internalType\":\"struct MarketInit\",\"name\":\"_marketInit\",\"type\":\"tuple\"},{\"internalType\":\"contract IStakeDaoVaultV2\",\"name\":\"_vault\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"isHEC\",\"type\":\"bool\"},{\"internalType\":\"uint24\",\"name\":\"rMin\",\"type\":\"uint24\"},{\"internalType\":\"uint32\",\"name\":\"rMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMin\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pInf\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"pMax\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a1\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"a2\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"k\",\"type\":\"uint32\"}],\"internalType\":\"struct IRParams\",\"name\":\"_irParams\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint16\",\"name\":\"harvestFeePercentage\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"stepAmount\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"startCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"endCutPercentage\",\"type\":\"uint32\"},{\"internalType\":\"uint80\",\"name\":\"startCutPrice\",\"type\":\"uint80\"},{\"internalType\":\"uint80\",\"name\":\"endCutPrice\",\"type\":\"uint80\"}],\"internalType\":\"struct RCParams\",\"name\":\"_rcParams\",\"type\":\"tuple\"}],\"name\":\"createStakeDaoVaultV2Market\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"irCalculator\",\"outputs\":[{\"internalType\":\"contract IIRCalculator\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"marketBasicERC20\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"marketConvexCrv\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"marketConvexFxn\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"marketCurveGauge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"marketStakeDaoVaultV2\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rewardAccumulator\",\"outputs\":[{\"internalType\":\"contract IRewardAccumulator\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zappingProxy\",\"outputs\":[{\"internalType\":\"contract IZappingProxy\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Tangent Finance\",\"errors\":{\"FailedDeployment()\":[{\"details\":\"The deployment failed.\"}],\"InsufficientBalance(uint256,uint256)\":[{\"details\":\"The ETH balance of the account is not enough to perform the operation.\"}]},\"kind\":\"dev\",\"methods\":{\"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"details\":\"Only on callable by DAO\",\"params\":{\"_irParams\":\"Interest Rate parameters of the market\",\"_marketInit\":\"Market init parameter containing all data related to the market\",\"_rcParams\":\"Reward Cut parameters of the market\"}},\"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"details\":\"Only on callable by DAO\",\"params\":{\"_irParams\":\"Interest Rate parameters of the market\",\"_marketInit\":\"Market init parameter containing all data related to the market\",\"_pid\":\"Pool ID of Curve Convex LP\",\"_rcParams\":\"Reward Cut parameters of the market\"}},\"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"details\":\"Only on callable by DAO\",\"params\":{\"_irParams\":\"Interest Rate parameters of the market\",\"_marketInit\":\"Market init parameter containing all data related to the market\",\"_pid\":\"Pool ID of FXN Convex LP\",\"_rcParams\":\"Reward Cut parameters of the market\"}},\"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"details\":\"Only on callable by DAO\",\"params\":{\"_irParams\":\"Interest Rate parameters of the market\",\"_marketInit\":\"Market init parameter containing all data related to the market\",\"_rcParams\":\"Reward Cut parameters of the market\"}},\"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"details\":\"Only on callable by DAO\",\"params\":{\"_irParams\":\"Interest Rate parameters of the market\",\"_marketInit\":\"Market init parameter containing all data related to the market\",\"_rcParams\":\"Reward Cut parameters of the market\"}},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"title\":\"MarketCreator\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"USG()\":{\"notice\":\"USG token\"},\"controlTower()\":{\"notice\":\"Control tower\"},\"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"notice\":\"Creates a market with a basic ERC20 as collateral, without reward streaming coming from the collateral.\"},\"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"notice\":\"Creates a market with a Curve Convex LP as Collateral.\"},\"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"notice\":\"Creates a market with a FXN Convex LP as Collateral.\"},\"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"notice\":\"Creates a market with a Curve Convex LP as Collateral.\"},\"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))\":{\"notice\":\"Creates a market with a Curve Convex LP as Collateral.\"},\"irCalculator()\":{\"notice\":\"IR Calculator\"},\"marketBasicERC20()\":{\"notice\":\"Basic ERC20 market implementation\"},\"marketConvexCrv()\":{\"notice\":\"Convex CRV market implementation\"},\"marketConvexFxn()\":{\"notice\":\"Convex FXN market implementation\"},\"marketCurveGauge()\":{\"notice\":\"Market Curve gauge implementation\"},\"marketStakeDaoVaultV2()\":{\"notice\":\"Market Curve gauge implementation\"},\"rewardAccumulator()\":{\"notice\":\"Reward accumulator\"},\"zappingProxy()\":{\"notice\":\"Zapping proxy\"}},\"notice\":\"Factory to deploy market following the Minimal proxy implementation\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/USG/Utilities/MarketCreator.sol\":\"MarketCreator\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a2608291cb038b388d80b79a06b6118a42f7894ff67b7da10ec0dbbf5b2973ba\",\"dweb:/ipfs/QmWohqcBLbcxmA4eGPhZDXe5RYMMEEpFq22nfkaUMvTfw1\"]},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"keccak256\":\"0x83b10b9c4f3117f1bff30c49bc486d719de88c8425fe646bc8a5f998ee44ceb9\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ef2774d5513d7567c3e886a875d90261e1173876324e88e5f21ce79cad14e188\",\"dweb:/ipfs/QmRDkvYwjyHCyTahZ5BqaRz64VtxSzGiYTLmDkacC5yEqr\"]},\"@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/Create2.sol\":{\"keccak256\":\"0xbb7e8401583d26268ea9103013bcdcd90866a7718bd91105ebd21c9bf11f4f06\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://866a11ad89c93ee918078f7a46ae31e17d89216ce64603f0d34be7ed0a5c520e\",\"dweb:/ipfs/QmW3ckLEJg2v2NzuVLNJFmRuerGSipw6Dzg6ntbmqbAGoC\"]},\"@openzeppelin/contracts/utils/Errors.sol\":{\"keccak256\":\"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf\",\"dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB\"]},\"src/USG/Utilities/MarketCreator.sol\":{\"keccak256\":\"0xdc754d6ba81979112dc961da3120617c0f57a46ca4074d5833382808b2158580\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8a588e6f8e1eacd677c4b0481abf7c2b5a2a55f9070197bc1eae4bf8aaab8f94\",\"dweb:/ipfs/QmRqbv8LDDpbMDxEtnYh7ZkUZnDjUTSYTvL5AL5sC3rEUL\"]},\"src/USG/Utilities/abstract/LightOwnable.sol\":{\"keccak256\":\"0x88c4c115ff0ba91e7d911c9d4dace8626f4622f56c1ee19dfbd612aff283e3b7\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://29ca7e825aca8d14f45c6ac7a17cb3995a9167b091fb8acf555bd501e8f65c90\",\"dweb:/ipfs/QmfEAaoxwwnELfg3VW5yDu9rV3Q9hdXUCKkcvwQo9HCbyq\"]},\"src/interfaces/externals/Convex/ICvxRewardToken.sol\":{\"keccak256\":\"0x9f9787b8b4fba86d70b76c4d8c4cf402ec19141ec6b7b9c9680f42c429d47491\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53f50ca7c36eb8f7fb77677d1910176b810bba1e3a4e89bdab57528be92b368a\",\"dweb:/ipfs/QmfLfFruiPEZh6u2Eas2wi2GzoMVd4K6rEoeNqzDxjUReZ\"]},\"src/interfaces/externals/Convex/IStakingProxyERC20.sol\":{\"keccak256\":\"0x98deba4eae3addda273d78af4f7f9f21f9613e00f9ec8fca4bd4d7a5c4c33151\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f73ea30fd3c38397326315358a70ba66710fa02d2541f4709d632b63ac784163\",\"dweb:/ipfs/QmcJhmjQyRwFxX5keNJvVH1K78hzrY3JG8WsMhEqfEDEJi\"]},\"src/interfaces/externals/Curve/IGauge.sol\":{\"keccak256\":\"0x135032f400941bd825c0e27cadbdb955d7754040e0b93ab13a213ac17951d550\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://798d7f2def63947897312e9b1802d0f54f76593107037f19e9399e31134ec55f\",\"dweb:/ipfs/QmZJBaVxxnXPgzepDsm7z6TZogRzUb1ud3zSE6FS21V45W\"]},\"src/interfaces/externals/FXN/ISharedLiquidityGauge.sol\":{\"keccak256\":\"0x54f7d7d973473d8aac40b0e165b58845128ff88389a3a20302f5a93862270e05\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2979f05b62b34f014ae8bc1c7907e050f78e5c57e31043d439898c5796946dbe\",\"dweb:/ipfs/QmSnDxsDbsTdnr32CXGTK8XA7YjNgjGErPQWikAyXepM4y\"]},\"src/interfaces/externals/StakeDao/IStakeDaoVaultV2.sol\":{\"keccak256\":\"0x727bb731ec546346813c73e0cd69e8831539584341b9a7dfff896d78432f607a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://51a72621fff56c47e5eec8751c1b6a6ac8c68283c031611eea2d58148fa7b2f4\",\"dweb:/ipfs/QmafqgwenPLAs7pxWFUac3Wfz6k3LLKU67AwKFaadnuwZk\"]},\"src/interfaces/internals/ICommonStruct.sol\":{\"keccak256\":\"0xe66889d5bf49a2f13723f5f1ff3f365b925ecd7d0dc387994cb0a9f0842aeede\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://94689e9878196025dc72cd58cdf9c97deb7ab79740d557ae44e0883e66d080ac\",\"dweb:/ipfs/QmVceqC6CRy3tYLoQJsFoZritH2QiRC4dSVgXuXRb7X4hC\"]},\"src/interfaces/internals/USG/IBasicERC20Market.sol\":{\"keccak256\":\"0x981d6a4b1c8bb4cc133d8df2a160df94b30932e203904a618e9d00a878d762ca\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cdccd2d9a29ae58fe2b730380bcfc6c883a6c1c8d7b0b37fa0765baafbdda6e\",\"dweb:/ipfs/QmeZpjQVGJ9orvS13ZPwRVzmFCJKRAkaKyKRhkHR6M92Rt\"]},\"src/interfaces/internals/USG/ICollateral.sol\":{\"keccak256\":\"0x9c1a059c6ae1bbc0c305419462be6f0655b517b12d2528a035d8dff2444cae53\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://46445e314d7b35cfc71b9b31d0e8a89fc807d1eee1be87ab88925a530ae16700\",\"dweb:/ipfs/QmS4fkVszW4euaqqYqDbcEr1cbKbYA885Lcw38dEPozGKY\"]},\"src/interfaces/internals/USG/IControlTower.sol\":{\"keccak256\":\"0xa762b09652859e007148df15d5fe60b6678197c2f1aea19e53b453bd53d96eaf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cf3e1494e9e6df32bb48ac64e404341c626aad0d9dd633c958b07c085f3ededc\",\"dweb:/ipfs/QmYhYCghWLjv8WzExcigYhPCANgyx67njKxisNj9tbjBjT\"]},\"src/interfaces/internals/USG/IConvexCrvLPMarket.sol\":{\"keccak256\":\"0xa73af7f4fbaefa19c00acdd2bc10b4d9fe63a1eb07261e6a1c85b7508c002713\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://03a9bb7e124dddd9f80078cf897887d6b7c1bfef210787701372972ac8a4a241\",\"dweb:/ipfs/QmaFQuHwo8kzLVUQ9jZ7MTmtmhVregMBtf3yo3kBBhyR2x\"]},\"src/interfaces/internals/USG/IConvexFxnLPMarket.sol\":{\"keccak256\":\"0x93a9ed7c973c63b6febb8c8b4572a05ae2cef35f6e2337e80389a6c708ce3eb3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://55de11a769b915c0544f44dbe336ce5e9e9fd10e3a2e40296470bfbb0fd562d5\",\"dweb:/ipfs/QmNqeYD1hTGq2g2Ep76kEyWcUZ4otC1cMqquHECaMwtJhT\"]},\"src/interfaces/internals/USG/ICurveGaugeMarket.sol\":{\"keccak256\":\"0x696a189c89a33c20149c2007f7bcb3e874c5cbe801d611b0a42fa080ad682603\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://77781bb1d02e567aed21a15db009cb8442d8545b99f879fba77b88ea3a98cb0a\",\"dweb:/ipfs/QmSJmwtPrhCD27J59PLse1ECmJrdbPoKBfH5VCJkWFa5cZ\"]},\"src/interfaces/internals/USG/IDebtIR.sol\":{\"keccak256\":\"0xf1b17238a3c8a96ce1ad44f5e772016a7a35722f7a76bb4f552516f949295943\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e556853a4f5be1dd697de721a258e0183c5c6cb691eafbfc461884dca2b17026\",\"dweb:/ipfs/QmXhbrRBFTpYKKBR9GiLQuL5n1c9hedZkfAC1W5RNRfJch\"]},\"src/interfaces/internals/USG/IIRCalculator.sol\":{\"keccak256\":\"0xec390b63b76bfdbf7165e66d652210b6774427d6cce7a38346babd016dc6c275\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b83dfe894d175e626c4f6004f841b3817603e83bc08439ce6da9e94fdfe89efb\",\"dweb:/ipfs/Qme99R42frMKaizYzo36FFLmWnNRiywnD8n6GsrEbaK6LK\"]},\"src/interfaces/internals/USG/IMarketCore.sol\":{\"keccak256\":\"0x1735a67e3ecc02afa53455ee5a3dd6444362dcb73ed3deeae48f35642a47ce70\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d67495a8d2327d30c0407860af2f3b46e9c532d82c82ba3a4cfd6124af504297\",\"dweb:/ipfs/QmSLp9C98kSFLpMyj72Tm8gHCzWAQDQ3kREvsCscpT2w7t\"]},\"src/interfaces/internals/USG/IPriceOracle.sol\":{\"keccak256\":\"0x1d696fafdc5f4d3a3eba8249ba885d76061d2767a1891f0fb27b88ffadcb091c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2d098310848e34010993e80e23276d50a2ce7bed605d7cf6835b5953b62147d7\",\"dweb:/ipfs/Qmak9vsPkcLhSLGVDbb3Lvna72tNPvUVFZ3QrhCjuqCAgw\"]},\"src/interfaces/internals/USG/IRewardAccumulator.sol\":{\"keccak256\":\"0xd68ae48cf25d77fc53ee202c3e32fa2437d8f57de62bdfcad1eda8e997c09e0c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://07632ade2c266a7d7b70177672e5d5acacae551e1298b356303a54a668fbb111\",\"dweb:/ipfs/QmRT6sRbwo1amdxcGJdqhnCcoU5nNvFbv6msxBcpFfEieB\"]},\"src/interfaces/internals/USG/IStakeDaoVaultV2Market.sol\":{\"keccak256\":\"0xd12d8c289e20ce4636ef5c2a09a1f95fe90044bf0534d7ac35c63808ac7d2766\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bd132112213871546786cd8665aef06ce8a3ea4a9ee68c2894f5c3837a36cc4a\",\"dweb:/ipfs/QmPWuGVzmo7VmdmB5Gca3xB9gLxcb4vhRiCPtPVAyP66mL\"]},\"src/interfaces/internals/USG/IUSG.sol\":{\"keccak256\":\"0x39eb5da91c763740799025f16e060d8347a9c1bccbe8875c3a2d2942f9c600df\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://35c366e2978750d024de951ccf256d497c1d1b595084f1f785f4a860cb579a07\",\"dweb:/ipfs/QmQpgHN6ub6H7DhYzGjAc4pzTjmpfmSzcj4xYcVnJo6rf7\"]},\"src/interfaces/internals/USG/IZappingProxy.sol\":{\"keccak256\":\"0xd32034c54886fe61815df81216157775bbec18d3687f9e8d073d327a27def691\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e533f5e10391b9b2721a409a156ddc399a4d9947a33305b4b9dcd999a79b0f5d\",\"dweb:/ipfs/QmUpAQvcbFCmRNizmvPP1qT5P3DVWRmfaEh9PTpjNbM8Tv\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Factory to deploy market following the Minimal proxy implementation","methods":{"USG()":{"notice":"USG token"},"controlTower()":{"notice":"Control tower"},"irCalculator()":{"notice":"IR Calculator"},"zappingProxy()":{"notice":"Zapping proxy"},"marketConvexCrv()":{"notice":"Convex CRV market implementation"},"marketConvexFxn()":{"notice":"Convex FXN market implementation"},"marketBasicERC20()":{"notice":"Basic ERC20 market implementation"},"marketCurveGauge()":{"notice":"Market Curve gauge implementation"},"rewardAccumulator()":{"notice":"Reward accumulator"},"marketStakeDaoVaultV2()":{"notice":"Market Curve gauge implementation"},"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a basic ERC20 as collateral, without reward streaming coming from the collateral."},"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."},"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a FXN Convex LP as Collateral."},"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."},"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"notice":"Creates a market with a Curve Convex LP as Collateral."}},"version":1},"devdoc":{"kind":"dev","title":"MarketCreator","author":"Tangent Finance","errors":{"FailedDeployment()":[{"details":"The deployment failed."}],"InsufficientBalance(uint256,uint256)":[{"details":"The ETH balance of the account is not enough to perform the operation."}]},"methods":{"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_pid":"Pool ID of Curve Convex LP","_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_pid":"Pool ID of FXN Convex LP","_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"},"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))":{"params":{"_irParams":"Interest Rate parameters of the market","_rcParams":"Reward Cut parameters of the market","_marketInit":"Market init parameter containing all data related to the market"},"details":"Only on callable by DAO"}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_contract(IUSG)3581":{"label":"contract IUSG","encoding":"inplace","numberOfBytes":"20"},"t_contract(IControlTower)3005":{"label":"contract IControlTower","encoding":"inplace","numberOfBytes":"20"},"t_contract(IIRCalculator)3232":{"label":"contract IIRCalculator","encoding":"inplace","numberOfBytes":"20"},"t_contract(IZappingProxy)3606":{"label":"contract IZappingProxy","encoding":"inplace","numberOfBytes":"20"},"t_contract(IRewardAccumulator)3530":{"label":"contract IRewardAccumulator","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":1126,"label":"owner","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"1","type":"t_contract(IControlTower)3005","astId":673,"label":"controlTower","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"2","type":"t_contract(IUSG)3581","astId":677,"label":"USG","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"3","type":"t_contract(IIRCalculator)3232","astId":681,"label":"irCalculator","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"4","type":"t_contract(IRewardAccumulator)3530","astId":685,"label":"rewardAccumulator","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"5","type":"t_contract(IZappingProxy)3606","astId":689,"label":"zappingProxy","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"6","type":"t_address","astId":692,"label":"marketConvexCrv","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"7","type":"t_address","astId":695,"label":"marketConvexFxn","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"8","type":"t_address","astId":698,"label":"marketCurveGauge","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"9","type":"t_address","astId":701,"label":"marketStakeDaoVaultV2","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"},{"slot":"10","type":"t_address","astId":704,"label":"marketBasicERC20","offset":0,"contract":"src/USG/Utilities/MarketCreator.sol:MarketCreator"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"1694:7590:6:-:0;;;3038:858;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3445:12;:28;;-1:-1:-1;;;;;;3445:28:6;;;-1:-1:-1;;;;;3445:28:6;;;;;;;;;;3483:3;:10;;;;;;;;;;3503:12;:28;;;;;;;;;;3541:17;:38;;;;;;;;;;3589:12;:28;;;;;;;;;;3627:15;:34;;;;;;;;;;3671:15;:34;;;;;;;;;;3715:16;:36;;;;;;;;;;3761:21;:46;;;;;;;;;;3817:16;:36;;;;;;;;;;;;;;3863:26;3882:6;3863:18;:26::i;:::-;3038:858;;;;;;;;;;;1694:7590;;1213:185:7;1286:16;1305:5;;-1:-1:-1;;;;;1320:16:7;;;-1:-1:-1;;;;;;1320:16:7;;;;;;1351:40;;1305:5;;;;;;;1351:40;;1286:16;1351:40;1276:122;1213:185;:::o;14:131:28:-;-1:-1:-1;;;;;89:31:28;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:138::-;229:13;;251:31;229:13;251:31;:::i;:::-;150:138;;;:::o;293:1553::-;559:6;567;575;583;591;599;607;615;623;631;639:7;693:3;681:9;672:7;668:23;664:33;661:53;;;710:1;707;700:12;661:53;742:9;736:16;761:31;786:5;761:31;:::i;:::-;861:2;846:18;;840:25;811:5;;-1:-1:-1;874:33:28;840:25;874:33;:::i;:::-;978:2;963:18;;957:25;926:7;;-1:-1:-1;991:33:28;957:25;991:33;:::i;:::-;1095:2;1080:18;;1074:25;1043:7;;-1:-1:-1;1108:33:28;1074:25;1108:33;:::i;:::-;1212:3;1197:19;;1191:26;1160:7;;-1:-1:-1;1226:33:28;1191:26;1226:33;:::i;:::-;1351:3;1336:19;;1330:26;1278:7;;-1:-1:-1;1365:33:28;1330:26;1365:33;:::i;:::-;1490:3;1475:19;;1469:26;1417:7;;-1:-1:-1;1504:33:28;1469:26;1504:33;:::i;:::-;1556:7;-1:-1:-1;1582:50:28;1627:3;1612:19;;1582:50;:::i;:::-;1572:60;;1651:50;1696:3;1685:9;1681:19;1651:50;:::i;:::-;1641:60;;1720:50;1765:3;1754:9;1750:19;1720:50;:::i;:::-;1710:60;;1790:50;1835:3;1824:9;1820:19;1790:50;:::i;:::-;1779:61;;293:1553;;;;;;;;;;;;;;:::o;:::-;1694:7590:6;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1694:7590:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2423:36;;;;;;;;;;;;190:42:28;178:55;;;160:74;;148:2;133:18;2423:36:6;;;;;;;1800:33;;;;;;;;;2248:30;;;;;;;;;5628:480;;;;;;:::i;:::-;;:::i;7323:553::-;;;;;;:::i;:::-;;:::i;2335:31::-;;;;;;;;;2073:33;;;;;;;;;1866:15;;;;;;;;;102:20:7;;;;;;;;;8290:462:6;;;;;;:::i;:::-;;:::i;1918:33::-;;;;;;;;;6473:485;;;;;;:::i;:::-;;:::i;2516:31::-;;;;;;;;;1993:43;;;;;;;;;844:215:7;;;;;;:::i;:::-;;:::i;:::-;;4729:480:6;;;;;;:::i;:::-;;:::i;2162:30::-;;;;;;;;;5628:480;5792:7;435:13:7;:11;:13::i;:::-;5827:15:6::1;::::0;5811:13:::1;::::0;5827:23:::1;::::0;:15:::1;;:21;:23::i;:::-;5811:39;;5879:5;5860:36;;;5897:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;5897:18:::1;5917:11;5930:4;5860:75;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5945:72;5963:5;5970:9;5981:11;:24;;;;;;;;:::i;:::-;6007:9;5945:17;:72::i;:::-;6032:47;6055:5:::0;6062:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;:::-;6032:47;;;;;;;;:::i;:::-;;;;;;;;6096:5:::0;5628:480;-1:-1:-1;;;;;5628:480:6:o;7323:553::-;7542:7;435:13:7;:11;:13::i;:::-;7577:21:6::1;::::0;7561:13:::1;::::0;7577:29:::1;::::0;:21:::1;;:27;:29::i;:::-;7561:45;;7639:5;7616:40;;;7657:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;7657:18:::1;7677:11;7690:6;7616:81;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7707:72;7725:5;7732:9;7743:11;:24;;;;;;;;:::i;7707:72::-;7794:53;7823:5:::0;7830:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;8290:462::-:0;8441:7;435:13:7;:11;:13::i;:::-;8476:16:6::1;::::0;8460:13:::1;::::0;8476:24:::1;::::0;:16:::1;;:22;:24::i;:::-;8460:40;;8528:5;8510:35;;;8546:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;8546:18:::1;8566:11;8510:68;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8588:72;8606:5;8613:9;8624:11;:24;;;;;;;;:::i;8588:72::-;8675:48;8699:5:::0;8706:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;:::-;8675:48;;;;;;;;:::i;:::-;;;;;;;;8740:5:::0;8290:462;-1:-1:-1;;;;8290:462:6:o;6473:485::-;6639:7;435:13:7;:11;:13::i;:::-;6674:16:6::1;::::0;6658:13:::1;::::0;6674:24:::1;::::0;:16:::1;;:22;:24::i;:::-;6658:40;;6726:5;6708:35;;;6744:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;6744:18:::1;6764:11;6777:6;6708:76;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6794:72;6812:5;6819:9;6830:11;:24;;;;;;;;:::i;6794:72::-;6881:48;6905:5:::0;6912:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;844:215:7:-:0;435:13;:11;:13::i;:::-;928:22:::1;::::0;::::1;924:91;;973:31;::::0;::::1;::::0;;1001:1:::1;973:31;::::0;::::1;160:74:28::0;133:18;;973:31:7::1;;;;;;;;924:91;1024:28;1043:8;1024:18;:28::i;:::-;844:215:::0;:::o;4729:480:6:-;4893:7;435:13:7;:11;:13::i;:::-;4928:15:6::1;::::0;4912:13:::1;::::0;4928:23:::1;::::0;:15:::1;;:21;:23::i;:::-;4912:39;;4980:5;4961:36;;;4998:18;-1:-1:-1::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4013:286:6;;;;;;;;-1:-1:-1;4062:5:6;;;;;4013:286;;4091:3;;;;4013:286;;;;4062:5;4127:12;;;4013:286;;;;;;;4172:12;;;;4013:286;;;;4222:17;;;;4013:286;;;;4272:12;;;;;4013:286;;;;;3902:404;4998:18:::1;5018:11;5031:4;4961:75;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5046:72;5064:5;5071:9;5082:11;:24;;;;;;;;:::i;5046:72::-;5133:47;5156:5:::0;5163:16:::1;;::::0;::::1;:11:::0;:16:::1;:::i;539:156:7:-:0;598:5;;:19;:5;607:10;598:19;594:95;;640:38;;;;;667:10;640:38;;;160:74:28;133:18;;640:38:7;14:226:28;594:95:7;539:156::o;1071:123:1:-;1128:16;1163:24;1169:14;1185:1;1163:5;:24::i;:::-;1156:31;1071:123;-1:-1:-1;;1071:123:1:o;8758:524:6:-;8962:3;;:30;;;;;:3;178:55:28;;;8962:30:6;;;160:74:28;8962:3:6;;;;:20;;133:18:28;;8962:30:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9070:12:6;;:50;;;;;:12;;;;;-1:-1:-1;9070:29:6;;-1:-1:-1;9070:50:6;;9100:8;;9110:9;;9070:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9206:17:6;;;:69;;;;;:17;;;;;-1:-1:-1;9206:34:6;;-1:-1:-1;9206:69:6;;9241:8;;9251:12;;;;9265:9;;9206:69;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8758:524;;;;;:::o;1213:185:7:-;1286:16;1305:5;;;1320:16;;;;;;;;;;1351:40;;1305:5;;;;;;;1351:40;;1286:16;1351:40;1276:122;1213:185;:::o;1586:910:1:-;1658:16;1714:5;1690:21;:29;1686:123;;;1742:56;;;;;1769:21;1742:56;;;17887:25:28;17928:18;;;17921:34;;;17860:18;;1742:56:1;17713:248:28;1686:123:1;2095:48;2077:14;2071:4;2067:25;2061:4;2057:36;2054:90;2048:4;2041:104;2302:32;2285:14;2279:4;2275:25;2272:63;2266:4;2259:77;2381:4;2375;2368:5;2361:25;2349:37;-1:-1:-1;2409:22:1;;;2405:85;;2454:25;;;;;;;;;;;;;;645:159:28;708:5;753:3;744:6;739:3;735:16;731:26;728:46;;;770:1;767;760:12;728:46;-1:-1:-1;792:6:28;645:159;-1:-1:-1;645:159:28:o;809:157::-;870:5;915:3;906:6;901:3;897:16;893:26;890:46;;;932:1;929;922:12;971:736;1143:6;1151;1159;1167;1220:3;1208:9;1199:7;1195:23;1191:33;1188:53;;;1237:1;1234;1227:12;1188:53;1277:9;1264:23;1310:18;1302:6;1299:30;1296:50;;;1342:1;1339;1332:12;1296:50;1365:70;1427:7;1418:6;1407:9;1403:22;1365:70;:::i;:::-;1355:80;-1:-1:-1;;1504:2:28;1489:18;;1476:32;;-1:-1:-1;1551:66:28;1609:7;1604:2;1589:18;;1551:66;:::i;:::-;1541:76;;1636:65;1693:7;1687:3;1676:9;1672:19;1636:65;:::i;:::-;1626:75;;971:736;;;;;;;:::o;1712:172::-;1816:42;1809:5;1805:54;1798:5;1795:65;1785:93;;1874:1;1871;1864:12;1889:800;2086:6;2094;2102;2110;2163:3;2151:9;2142:7;2138:23;2134:33;2131:53;;;2180:1;2177;2170:12;2131:53;2220:9;2207:23;2253:18;2245:6;2242:30;2239:50;;;2285:1;2282;2275:12;2239:50;2308:70;2370:7;2361:6;2350:9;2346:22;2308:70;:::i;:::-;2298:80;;;2428:2;2417:9;2413:18;2400:32;2441:49;2484:5;2441:49;:::i;:::-;2509:5;-1:-1:-1;2533:66:28;2591:7;2586:2;2571:18;;2533:66;:::i;3191:622::-;3354:6;3362;3370;3423:3;3411:9;3402:7;3398:23;3394:33;3391:53;;;3440:1;3437;3430:12;3391:53;3480:9;3467:23;3513:18;3505:6;3502:30;3499:50;;;3545:1;3542;3535:12;3499:50;3568:70;3630:7;3621:6;3610:9;3606:22;3568:70;:::i;:::-;3558:80;;;3657:66;3715:7;3710:2;3699:9;3695:18;3657:66;:::i;:::-;3647:76;;3742:65;3799:7;3793:3;3782:9;3778:19;3742:65;:::i;:::-;3732:75;;3191:622;;;;;:::o;5124:265::-;5183:6;5236:2;5224:9;5215:7;5211:23;5207:32;5204:52;;;5252:1;5249;5242:12;5204:52;5291:9;5278:23;5310:49;5353:5;5310:49;:::i;:::-;5378:5;5124:265;-1:-1:-1;;;5124:265:28:o;6080:168::-;6164:20;;6193:49;6164:20;6193:49;:::i;:::-;6080:168;;;:::o;6253:587::-;6331:5;6338:6;6398:3;6385:17;6480:66;6469:8;6453:14;6449:29;6445:102;6425:18;6421:127;6411:155;;6562:1;6559;6552:12;6411:155;6590:33;;6694:4;6681:18;;;-1:-1:-1;6642:21:28;;-1:-1:-1;6722:18:28;6711:30;;6708:50;;;6754:1;6751;6744:12;6708:50;6808:6;6805:1;6801:14;6785;6781:35;6774:5;6770:47;6767:67;;;6830:1;6827;6820:12;6767:67;6253:587;;;;;:::o;7048:623::-;7156:6;7151:3;7144:19;7188:4;7183:3;7179:14;7172:21;;7126:3;7216:5;7239:1;7249:397;7263:6;7260:1;7257:13;7249:397;;;7340:6;7327:20;7360:51;7403:7;7360:51;:::i;:::-;7481:42;7468:56;7456:69;;7561:4;7552:14;;;;7619:17;;;;;7285:1;7278:9;7249:397;;;-1:-1:-1;7662:3:28;;7048:623;-1:-1:-1;;;;7048:623:28:o;7676:560::-;7735:5;7742:6;7802:3;7789:17;7884:66;7873:8;7857:14;7853:29;7849:102;7829:18;7825:127;7815:155;;7966:1;7963;7956:12;7815:155;7994:33;;8098:4;8085:18;;;-1:-1:-1;8046:21:28;;-1:-1:-1;8126:18:28;8115:30;;8112:50;;;8158:1;8155;8148:12;8112:50;8205:6;8189:14;8185:27;8178:5;8174:39;8171:59;;;8226:1;8223;8216:12;8241:326;8330:6;8325:3;8318:19;8382:6;8375:5;8368:4;8363:3;8359:14;8346:43;;8434:1;8427:4;8418:6;8413:3;8409:16;8405:27;8398:38;8300:3;8556:4;8486:66;8481:2;8473:6;8469:15;8465:88;8460:3;8456:98;8452:109;8445:116;;8241:326;;;;:::o;8572:1402::-;8652:81;8729:3;8686:41;8721:5;8686:41;:::i;:::-;337:42;326:54;314:67;;245:142;8652:81;8634:3;8762:52;8808:4;8801:5;8797:16;8762:52;:::i;:::-;337:42;326:54;8880:4;8871:14;;314:67;8955:4;8944:16;;;8931:30;8977:14;;;8970:31;9070:4;9059:16;;;9046:30;9092:14;;;9085:31;9185:4;9174:16;;;9161:30;9207:14;;;9200:31;9300:4;9289:16;;;9276:30;9322:14;;;9315:31;9415:4;9404:16;;;9391:30;9437:14;;;9430:31;9506:75;9575:4;9564:16;;8944;9506:75;:::i;:::-;9613:6;9606:4;9601:3;9597:14;9590:30;9641:93;9726:6;9721:3;9717:16;9703:12;9687:14;9641:93;:::i;:::-;9629:105;;;9781:58;9831:6;9824:5;9820:18;9813:5;9781:58;:::i;:::-;9883:3;9877:4;9873:14;9864:6;9859:3;9855:16;9848:40;9904:64;9963:4;9947:14;9931;9904:64;:::i;:::-;9897:71;8572:1402;-1:-1:-1;;;;;;8572:1402:28:o;9979:538::-;10284:59;10333:9;10325:6;5500:42;5492:5;5486:12;5482:61;5477:3;5470:74;5605:42;5597:4;5590:5;5586:16;5580:23;5576:72;5569:4;5564:3;5560:14;5553:96;5710:42;5702:4;5695:5;5691:16;5685:23;5681:72;5674:4;5669:3;5665:14;5658:96;5815:42;5807:4;5800:5;5796:16;5790:23;5786:72;5779:4;5774:3;5770:14;5763:96;5920:42;5912:4;5905:5;5901:16;5895:23;5891:72;5884:4;5879:3;5875:14;5868:96;6025:42;6017:4;6010:5;6006:16;6000:23;5996:72;5989:4;5984:3;5980:14;5973:96;;;5394:681;10284:59;10380:3;10374;10363:9;10359:19;10352:32;10265:4;10401:66;10462:3;10451:9;10447:19;10439:6;10401:66;:::i;:::-;10393:74;;10504:6;10498:3;10487:9;10483:19;10476:35;9979:538;;;;;;:::o;10522:618::-;10629:4;10635:6;10695:11;10682:25;10785:66;10774:8;10758:14;10754:29;10750:102;10730:18;10726:127;10716:155;;10867:1;10864;10857:12;10716:155;10894:33;;10946:20;;;-1:-1:-1;10989:18:28;10978:30;;10975:50;;;11021:1;11018;11011:12;10975:50;11054:4;11042:17;;-1:-1:-1;11105:1:28;11101:14;;;11085;11081:35;11071:46;;11068:66;;;11130:1;11127;11120:12;11145:581;11223:4;11229:6;11289:11;11276:25;11379:66;11368:8;11352:14;11348:29;11344:102;11324:18;11320:127;11310:155;;11461:1;11458;11451:12;11310:155;11488:33;;11540:20;;;-1:-1:-1;11583:18:28;11572:30;;11569:50;;;11615:1;11612;11605:12;11569:50;11648:4;11636:17;;-1:-1:-1;11679:14:28;11675:27;;;11665:38;;11662:58;;;11716:1;11713;11706:12;11731:367;11930:42;11922:6;11918:55;11907:9;11900:74;12010:2;12005;11994:9;11990:18;11983:30;11881:4;12030:62;12088:2;12077:9;12073:18;12065:6;12057;12030:62;:::i;:::-;12022:70;11731:367;-1:-1:-1;;;;;11731:367:28:o;12103:612::-;12433:59;12482:9;12474:6;5500:42;5492:5;5486:12;5482:61;5477:3;5470:74;5605:42;5597:4;5590:5;5586:16;5580:23;5576:72;5569:4;5564:3;5560:14;5553:96;5710:42;5702:4;5695:5;5691:16;5685:23;5681:72;5674:4;5669:3;5665:14;5658:96;5815:42;5807:4;5800:5;5796:16;5790:23;5786:72;5779:4;5774:3;5770:14;5763:96;5920:42;5912:4;5905:5;5901:16;5895:23;5891:72;5884:4;5879:3;5875:14;5868:96;6025:42;6017:4;6010:5;6006:16;6000:23;5996:72;5989:4;5984:3;5980:14;5973:96;;;5394:681;12433:59;12529:3;12523;12512:9;12508:19;12501:32;12414:4;12550:66;12611:3;12600:9;12596:19;12588:6;12550:66;:::i;:::-;12542:74;;12665:42;12657:6;12653:55;12647:3;12636:9;12632:19;12625:84;12103:612;;;;;;:::o;12720:466::-;12997:59;13046:9;13038:6;5500:42;5492:5;5486:12;5482:61;5477:3;5470:74;5605:42;5597:4;5590:5;5586:16;5580:23;5576:72;5569:4;5564:3;5560:14;5553:96;5710:42;5702:4;5695:5;5691:16;5685:23;5681:72;5674:4;5669:3;5665:14;5658:96;5815:42;5807:4;5800:5;5796:16;5790:23;5786:72;5779:4;5774:3;5770:14;5763:96;5920:42;5912:4;5905:5;5901:16;5895:23;5891:72;5884:4;5879:3;5875:14;5868:96;6025:42;6017:4;6010:5;6006:16;6000:23;5996:72;5989:4;5984:3;5980:14;5973:96;;;5394:681;12997:59;13093:3;13087;13076:9;13072:19;13065:32;12978:4;13114:66;13175:3;13164:9;13160:19;13152:6;13114:66;:::i;:::-;13106:74;12720:466;-1:-1:-1;;;;12720:466:28:o;13894:161::-;13961:20;;14021:8;14010:20;;14000:31;;13990:59;;14045:1;14042;14035:12;14157:163;14224:20;;14284:10;14273:22;;14263:33;;14253:61;;14310:1;14307;14300:12;14424:1494;14683:42;14671:55;;14653:74;;14640:3;14625:19;;14749:20;;14805:13;;14798:21;14788:32;;14778:60;;14834:1;14831;14824:12;14778:60;13868:13;;13861:21;14885:2;14870:18;;13849:34;14847:42;14918:34;14948:2;14940:6;14936:15;14918:34;:::i;:::-;14136:8;14125:20;;15008:2;14993:18;;14113:33;14961:51;15043:34;15073:2;15065:6;15061:15;15043:34;:::i;:::-;14401:10;14390:22;;15135:2;15120:18;;14378:35;15086:53;15170:34;15200:2;15192:6;15188:15;15170:34;:::i;:::-;14401:10;14390:22;;15262:3;15247:19;;14378:35;15213:54;15298:35;15328:3;15320:6;15316:16;15298:35;:::i;:::-;14401:10;14390:22;;15391:3;15376:19;;14378:35;15342:54;15427:35;15457:3;15449:6;15445:16;15427:35;:::i;:::-;14401:10;14390:22;;15520:3;15505:19;;14378:35;15471:54;15556:35;15586:3;15578:6;15574:16;15556:35;:::i;:::-;14401:10;14390:22;;15649:3;15634:19;;14378:35;15600:54;15685:35;15715:3;15707:6;15703:16;15685:35;:::i;:::-;14401:10;14390:22;;15778:3;15763:19;;14378:35;15729:54;15814:35;15844:3;15836:6;15832:16;15814:35;:::i;:::-;14401:10;14390:22;;15907:3;15892:19;;14378:35;15858:54;14424:1494;;;;;:::o;15923:159::-;15990:20;;16050:6;16039:18;;16029:29;;16019:57;;16072:1;16069;16062:12;16087:175;16154:20;;16214:22;16203:34;;16193:45;;16183:73;;16252:1;16249;16242:12;16267:1441;16634:42;16622:55;;16604:74;;16591:3;16709:2;16694:18;;16687:31;;;16576:19;;16753:22;;;16543:4;16833:6;16806:3;16791:19;;16543:4;16867:274;16881:6;16878:1;16875:13;16867:274;;;16956:6;16943:20;16976:49;17019:5;16976:49;:::i;:::-;6956:42;6944:55;6932:68;;7032:4;17116:15;;;;7023:14;;;;16903:1;16896:9;16867:274;;;-1:-1:-1;17158:3:28;-1:-1:-1;17228:6:28;;-1:-1:-1;17201:25:28;17219:6;17201:25;:::i;:::-;17197:38;17192:2;17181:9;17177:18;17170:66;17312:6;17276:34;17306:2;17298:6;17294:15;17276:34;:::i;:::-;17272:47;17267:2;17256:9;17252:18;17245:75;17397:10;17361:34;17391:2;17383:6;17379:15;17361:34;:::i;:::-;17357:51;17351:3;17340:9;17336:19;17329:80;17486:10;17450:34;17480:2;17472:6;17468:15;17450:34;:::i;:::-;17446:51;17440:3;17429:9;17425:19;17418:80;17576:22;17539:35;17569:3;17561:6;17557:16;17539:35;:::i;:::-;17535:64;17529:3;17518:9;17514:19;17507:93;17678:22;17641:35;17671:3;17663:6;17659:16;17641:35;:::i;:::-;17637:64;17631:3;17620:9;17616:19;17609:93;16267:1441;;;;;;;:::o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"controlTower()","signatureHash4":"0x0975bb7e","signatureHash32":"0x0975bb7ed245b00394f75fd58fe46d89d50595432bbe7197c7f738b87ae7bd1a"},{"signature":"createBasicERC20Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))","signatureHash4":"0x945f35de","signatureHash32":"0x945f35de2fd5a679ec7b692e12acefd5f728c2dafa56ef14f138049d03faaef6"},{"signature":"createConvexCrvMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))","signatureHash4":"0xf7d8a914","signatureHash32":"0xf7d8a914f7592bc51ab89739db2802fb12351b44baad03f76c463d797b3b99b1"},{"signature":"createConvexFxnMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),uint256,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))","signatureHash4":"0x1fcaec12","signatureHash32":"0x1fcaec120ffbefa784e8075dbd825040c9b6eb2752a9bb2c300c021a08c24206"},{"signature":"createCurveGaugeMarket((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))","signatureHash4":"0xb6a5dfa0","signatureHash32":"0xb6a5dfa04aecba0be92379c65fc1479e54bdd3992305699cfdeb9b0feef3128e"},{"signature":"createStakeDaoVaultV2Market((address,address,uint256,uint256,uint256,uint256,uint256,address[],string),address,(bool,uint24,uint32,uint32,uint32,uint32,uint32,uint32,uint32),(uint16,uint16,uint32,uint32,uint80,uint80))","signatureHash4":"0x42613f74","signatureHash32":"0x42613f74bd5a04f7eb1cbb6ef08d1cbcd28722c53da78f8fb1b83dad1a832459"},{"signature":"irCalculator()","signatureHash4":"0xa043d6d7","signatureHash32":"0xa043d6d7e5641d351be31d641e3af20fbb1385ac8199b458030f0eb190f1b814"},{"signature":"marketBasicERC20()","signatureHash4":"0xc86cb873","signatureHash32":"0xc86cb873f1353003f127d1946adcbcff5d409e07b503363acf7d340c99e1e2e5"},{"signature":"marketConvexCrv()","signatureHash4":"0xfa5d47b6","signatureHash32":"0xfa5d47b6c36428305ba17e3f64afd2e7d67ab5f71e8b45745326e37691b02387"},{"signature":"marketConvexFxn()","signatureHash4":"0x1e9d00ec","signatureHash32":"0x1e9d00ec324df37a5d6172b5c1ae4eb8d6b2ff003f8d93449c80b307a771ccd8"},{"signature":"marketCurveGauge()","signatureHash4":"0x56ac1f03","signatureHash32":"0x56ac1f03e705781a7fa51673803399e040eaa04c9da228ca8932f228646424b0"},{"signature":"marketStakeDaoVaultV2()","signatureHash4":"0x08f7f4e3","signatureHash32":"0x08f7f4e3dcb8aed8c7e02125a629d78ed7bebbb1bf868da428b3ec65619c0fa4"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"rewardAccumulator()","signatureHash4":"0xec60b844","signatureHash32":"0xec60b844e9ac6197f8f8d1db35d569dbc49221528821134cdfca22f666979f50"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"USG()","signatureHash4":"0x733103b8","signatureHash32":"0x733103b8d6908462ad85dda24597260850874f73379ebec0046b019505baec67"},{"signature":"zappingProxy()","signatureHash4":"0x6a959886","signatureHash32":"0x6a9598865c25d95b24b046c9a708f522131469c55767c8fcb8519923e215a19a"}],"event":[{"signature":"BasicERC20MarketCreated(address,string)","signatureHash4":"0x7d0023c8","signatureHash32":"0x7d0023c8dab8072ef01fd570986a66c559694be63f8cde73808fd68a8b2ac18b"},{"signature":"MarketConvexCrvCreated(address,string)","signatureHash4":"0x5fb5c3ce","signatureHash32":"0x5fb5c3ceaccec1bb21205ea8971185feab1fdafa59cf95247368722e712af1ec"},{"signature":"MarketConvexFxnCreated(address,string)","signatureHash4":"0xd0709b1a","signatureHash32":"0xd0709b1a4e4f29a49f78ba94736ff09b840a804f6c3aaa812726474bfe71576b"},{"signature":"MarketCurveGaugeCreated(address,string)","signatureHash4":"0x992f81e8","signatureHash32":"0x992f81e8d4692441a7ae6d9151c6afa685ddc4bb07527a8ea33e67067fc751eb"},{"signature":"MarketStakeDaoVaultV2Created(address,string)","signatureHash4":"0x28495cb7","signatureHash32":"0x28495cb735e65b01653047d1953f2c288aa048b029ac6dbd40e762112bbdaea1"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"}],"error":[{"signature":"FailedDeployment()","signatureHash4":"0xb06ebf3d","signatureHash32":"0xb06ebf3d5067824a3fe5d5ba19471e035a7de6c88dac362c77b162830a5b9093"},{"signature":"InsufficientBalance(uint256,uint256)","signatureHash4":"0xcf479181","signatureHash32":"0xcf4791818fba6e019216eb4864093b4947f674afada5d305e57d598b641dad1d"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x214C8A1023B30032a2Eded109146658C6D6F2781"}