{"matchId":"28771409","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-05-11T16:18:32Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"446:6237:6:-:0;;;1349:150;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1601:113:2;;;;;;;;;;;;;-1:-1:-1;;;1601:113:2;;;;;;;;;;;;;;;;-1:-1:-1;;;1601:113:2;;;1675:5;1667;:13;;;;;;:::i;:::-;-1:-1:-1;1690:7:2;:17;1700:7;1690;:17;:::i;:::-;-1:-1:-1;;1442:5:6::1;:12:::0;;-1:-1:-1;;;;;1442:12:6;;::::1;-1:-1:-1::0;;;;;;1442:12:6;;::::1;;::::0;;;1464::::1;:28:::0;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;-1:-1:-1;446:6237:6;;14:131:12;-1:-1:-1;;;;;89:31:12;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:407::-;251:6;259;312:2;300:9;291:7;287:23;283:32;280:52;;;328:1;325;318:12;280:52;360:9;354:16;379:31;404:5;379:31;:::i;:::-;479:2;464:18;;458:25;429:5;;-1:-1:-1;492:33:12;458:25;492:33;:::i;:::-;544:7;534:17;;;150:407;;;;;:::o;562:127::-;623:10;618:3;614:20;611:1;604:31;654:4;651:1;644:15;678:4;675:1;668:15;694:380;773:1;769:12;;;;816;;;837:61;;891:4;883:6;879:17;869:27;;837:61;944:2;936:6;933:14;913:18;910:38;907:161;;990:10;985:3;981:20;978:1;971:31;1025:4;1022:1;1015:15;1053:4;1050:1;1043:15;907:161;;694:380;;;:::o;1205:518::-;1307:2;1302:3;1299:11;1296:421;;;1343:5;1340:1;1333:16;1387:4;1384:1;1374:18;1457:2;1445:10;1441:19;1438:1;1434:27;1428:4;1424:38;1493:4;1481:10;1478:20;1475:47;;;-1:-1:-1;1516:4:12;1475:47;1571:2;1566:3;1562:12;1559:1;1555:20;1549:4;1545:31;1535:41;;1626:81;1644:2;1637:5;1634:13;1626:81;;;1703:1;1689:16;;1670:1;1659:13;1626:81;;;1630:3;;1296:421;1205:518;;;:::o;1899:1299::-;2019:10;;-1:-1:-1;;;;;2041:30:12;;2038:56;;;2074:18;;:::i;:::-;2103:97;2193:6;2153:38;2185:4;2179:11;2153:38;:::i;:::-;2147:4;2103:97;:::i;:::-;2249:4;2280:2;2269:14;;2297:1;2292:649;;;;2985:1;3002:6;2999:89;;;-1:-1:-1;3054:19:12;;;3048:26;2999:89;-1:-1:-1;;1856:1:12;1852:11;;;1848:24;1844:29;1834:40;1880:1;1876:11;;;1831:57;3101:81;;2262:930;;2292:649;1152:1;1145:14;;;1189:4;1176:18;;-1:-1:-1;;2328:20:12;;;2446:222;2460:7;2457:1;2454:14;2446:222;;;2542:19;;;2536:26;2521:42;;2649:4;2634:20;;;;2602:1;2590:14;;;;2476:12;2446:222;;;2450:3;2696:6;2687:7;2684:19;2681:201;;;2757:19;;;2751:26;-1:-1:-1;;2840:1:12;2836:14;;;2852:3;2832:24;2828:37;2824:42;2809:58;2794:74;;2681:201;-1:-1:-1;;;;2928:1:12;2912:14;;;2908:22;2895:36;;-1:-1:-1;1899:1299:12:o;:::-;446:6237:6;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220b5418256195e6b1307342d24590c1035dc39edb1c7e6a3eea3cce84df01d46b064736f6c634300081c0033","offset":5717}},"transformations":[{"type":"insert","offset":5770,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000461b62cb3a7e9df8f800ae058ae92f855f2c27ca000000000000000000000000f3f7669dceed2f985815011c19ed68f667267215"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"446:6237:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3998:186;;;;;;:::i;:::-;;:::i;:::-;;;1192:14:12;;1185:22;1167:41;;1155:2;1140:18;3998:186:2;1027:187:12;494:33:6;;;;;;;;;;;;1417:42:12;1405:55;;;1387:74;;1375:2;1360:18;494:33:6;1219:248:12;2849:97:2;2927:12;;2849:97;;;1618:25:12;;;1606:2;1591:18;2849:97:2;1472:177:12;4776:244:2;;;;;;:::i;:::-;;:::i;4438:204:6:-;;;;;;:::i;:::-;;:::i;:::-;;2707:82:2;;;2780:2;2561:36:12;;2549:2;2534:18;2707:82:2;2419:184:12;4037:81:6;;;;;;:::i;:::-;;:::i;581:40::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;6492:189;;;;;;:::i;:::-;;:::i;4962:162::-;;;;;;:::i;:::-;;:::i;3004:116:2:-;;;;;;:::i;:::-;3095:18;;3069:7;3095:18;;;;;;;;;;;;3004:116;3684:184:6;;;;;;:::i;:::-;;:::i;102:20:7:-;;;;;;;;;3222:152:6;;;;;;:::i;:::-;;:::i;1981:93:2:-;;;:::i;1841:148:6:-;;;;;;:::i;:::-;;:::i;3315:178:2:-;;;;;;:::i;:::-;;:::i;534:40:6:-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;5444:162;;;;;;:::i;:::-;;:::i;2668:182::-;;;;;;:::i;:::-;;:::i;679:43::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;5953:198;;;;;;:::i;:::-;;:::i;3551:140:2:-;;;;;;:::i;:::-;3657:18;;;;3631:7;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3551:140;628:44:6;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2229:160;;;;;;:::i;:::-;;:::i;844:215:7:-;;;;;;:::i;:::-;;:::i;1779:89:2:-;1824:13;1856:5;1849:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89;:::o;3998:186::-;4071:4;735:10:5;4125:31:2;735:10:5;4141:7:2;4150:5;4125:8;:31::i;:::-;4173:4;4166:11;;;3998:186;;;;;:::o;4776:244::-;4863:4;735:10:5;4919:37:2;4935:4;735:10:5;4950:5:2;4919:15;:37::i;:::-;4966:26;4976:4;4982:2;4986:5;4966:9;:26::i;:::-;-1:-1:-1;5009:4:2;;4776:244;-1:-1:-1;;;;4776:244:2:o;4438:204:6:-;4507:12;;:40;;;;;4536:10;4507:40;;;1387:74:12;4507:12:6;;;;;:28;;1360:18:12;;4507:40:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4499:70;;;;;;;;;;;;;;;;;4579:16;;;;;;:8;:16;;;;;;;;:23;;4598:4;4579:23;;;;;;;;;4612:8;:16;;;;;:23;;;;;;;;;;4438:204::o;4037:81::-;4086:25;4092:10;4104:6;4086:5;:25::i;:::-;4037:81;:::o;6492:189::-;435:13:7;:11;:13::i;:::-;6583:22:6::1;::::0;::::1;;::::0;;;:11:::1;:22;::::0;;;;;;;;:37;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;6635:39;;4833:74:12;;;4923:18;;;4916:50;6635:39:6::1;::::0;4806:18:12;6635:39:6::1;;;;;;;;6492:189:::0;;:::o;4962:162::-;435:13:7;:11;:13::i;:::-;5044:16:6::1;::::0;::::1;;::::0;;;:8:::1;:16;::::0;;;;;;;;:28;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;5087:30;;4833:74:12;;;4923:18;;;4916:50;5087:30:6::1;::::0;4806:18:12;5087:30:6::1;4665:307:12::0;3684:184:6;435:13:7;:11;:13::i;:::-;3779:22:6::1;::::0;::::1;;::::0;;;:11:::1;:22;::::0;;;;;::::1;;3771:56;;;;;;;;;;;;;;;;;3837:24;3843:9;3854:6;3837:5;:24::i;:::-;3684:184:::0;;:::o;3222:152::-;3306:10;3297:20;;;;:8;:20;;;;;;;;3289:49;;;;;;;;;;;;;;;;1981:93:2;2028:13;2060:7;2053:14;;;;;:::i;1841:148:6:-;1923:10;1914:20;;;;:8;:20;;;;;;;;1906:49;;;;;;;;;;;;;;;;;1965:17;1971:2;1975:6;1965:5;:17::i;3315:178:2:-;3384:4;735:10:5;3438:27:2;735:10:5;3455:2:2;3459:5;3438:9;:27::i;5444:162:6:-;435:13:7;:11;:13::i;:::-;5526:16:6::1;::::0;::::1;;::::0;;;:8:::1;:16;::::0;;;;;;;;:28;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;5569:30;;4833:74:12;;;4923:18;;;4916:50;5569:30:6::1;::::0;4806:18:12;5569:30:6::1;4665:307:12::0;2668:182:6;435:13:7;:11;:13::i;:::-;2763:22:6::1;::::0;::::1;;::::0;;;:11:::1;:22;::::0;;;;;::::1;;2755:54;;;;;;;;;;;;;;;;5953:198:::0;435:13:7;:11;:13::i;:::-;6047:24:6::1;::::0;::::1;;::::0;;;:12:::1;:24;::::0;;;;;;;;:40;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;6102:42;;4833:74:12;;;4923:18;;;4916:50;6102:42:6::1;::::0;4806:18:12;6102:42:6::1;4665:307:12::0;2229:160:6;2301:10;2288:24;;;;:12;:24;;;;;;;;2280:51;;;;;;;;;;;;;;;;;2347:12;;:26;;;;;;;;2341:41;;2347:12;;;:24;;:26;;;;;;;;;;;;;;:12;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2375:6;2341:5;:41::i;844:215:7:-;435:13;:11;:13::i;:::-;928:22:::1;::::0;::::1;924:91;;973:31;::::0;::::1;::::0;;1001:1:::1;973:31;::::0;::::1;1387:74:12::0;1360:18;;973:31:7::1;;;;;;;;924:91;1024:28;1043:8;1024:18;:28::i;8726:128:2:-:0;8810:37;8819:5;8826:7;8835:5;8842:4;8810:8;:37::i;:::-;8726:128;;;:::o;10415:476::-;3657:18;;;;10514:24;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;10599:17;10580:36;;10576:309;;;10655:5;10636:16;:24;10632:130;;;10687:60;;;;;5465:42:12;5453:55;;10687:60:2;;;5435:74:12;5525:18;;;5518:34;;;5568:18;;;5561:34;;;5408:18;;10687:60:2;5233:368:12;10632:130:2;10803:57;10812:5;10819:7;10847:5;10828:16;:24;10854:5;10803:8;:57::i;:::-;10504:387;10415:476;;;:::o;5393:300::-;5476:18;;;5472:86;;5517:30;;;;;5544:1;5517:30;;;1387:74:12;1360:18;;5517:30:2;1219:248:12;5472:86:2;5571:16;;;5567:86;;5610:32;;;;;5639:1;5610:32;;;1387:74:12;1360:18;;5610:32:2;1219:248:12;5567:86:2;5662:24;5670:4;5676:2;5680:5;5662:7;:24::i;7984:206::-;8054:21;;;8050:89;;8098:30;;;;;8125:1;8098:30;;;1387:74:12;1360:18;;8098:30:2;1219:248:12;8050:89:2;8148:35;8156:7;8173:1;8177:5;8148:7;:35::i;539:156:7:-;598:5;;:19;:5;607:10;598:19;594:95;;640:38;;;;;667:10;640:38;;;1387:74:12;1360:18;;640:38:7;1219:248:12;594:95:7;539:156::o;7458:208:2:-;7528:21;;;7524:91;;7572:32;;;;;7601:1;7572:32;;;1387:74:12;1360:18;;7572:32:2;1219:248:12;7524:91:2;7624:35;7640:1;7644:7;7653:5;7624:7;:35::i;1213:185:7:-;1305:5;;;;1320:16;;;;;;;;;;;1351:40;;1305:5;;;1320:16;1305:5;;1351:40;;1286:16;;1351:40;1276:122;1213:185;:::o;9701:432:2:-;9813:19;;;9809:89;;9855:32;;;;;9884:1;9855:32;;;1387:74:12;1360:18;;9855:32:2;1219:248:12;9809:89:2;9911:21;;;9907:90;;9955:31;;;;;9983:1;9955:31;;;1387:74:12;1360:18;;9955:31:2;1219:248:12;9907:90:2;10006:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;10051:76;;;;10101:7;10085:31;;10094:5;10085:31;;;10110:5;10085:31;;;;1618:25:12;;1606:2;1591:18;;1472:177;10085:31:2;;;;;;;;9701:432;;;;:::o;6008:1107::-;6097:18;;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:2;;-1:-1:-1;6093:540:2;;6307:15;;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;;;;5465:42:12;5453:55;;6386:50:2;;;5435:74:12;5525:18;;;5518:34;;;5568:18;;;5561:34;;;5408:18;;6386:50:2;5233:368:12;6336:115:2;6571:15;;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;6647:16;;;6643:425;;6810:12;:21;;;;;;;6643:425;;;7021:13;;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;7083:25;;7092:4;7083:25;;;7102:5;7083:25;;;;1618::12;;1606:2;1591:18;;1472:177;7083:25:2;;;;;;;;6008:1107;;;:::o;14:477:12:-;163:2;152:9;145:21;126:4;195:6;189:13;238:6;233:2;222:9;218:18;211:34;297:6;292:2;284:6;280:15;275:2;264:9;260:18;254:50;353:1;348:2;339:6;328:9;324:22;320:31;313:42;482:2;412:66;407:2;399:6;395:15;391:88;380:9;376:104;372:113;364:121;;;14:477;;;;:::o;496:154::-;582:42;575:5;571:54;564:5;561:65;551:93;;640:1;637;630:12;655:367;723:6;731;784:2;772:9;763:7;759:23;755:32;752:52;;;800:1;797;790:12;752:52;839:9;826:23;858:31;883:5;858:31;:::i;:::-;908:5;986:2;971:18;;;;958:32;;-1:-1:-1;;;655:367:12:o;1654:508::-;1731:6;1739;1747;1800:2;1788:9;1779:7;1775:23;1771:32;1768:52;;;1816:1;1813;1806:12;1768:52;1855:9;1842:23;1874:31;1899:5;1874:31;:::i;:::-;1924:5;-1:-1:-1;1981:2:12;1966:18;;1953:32;1994:33;1953:32;1994:33;:::i;:::-;1654:508;;2046:7;;-1:-1:-1;;;2126:2:12;2111:18;;;;2098:32;;1654:508::o;2167:247::-;2226:6;2279:2;2267:9;2258:7;2254:23;2250:32;2247:52;;;2295:1;2292;2285:12;2247:52;2334:9;2321:23;2353:31;2378:5;2353:31;:::i;:::-;2403:5;2167:247;-1:-1:-1;;;2167:247:12:o;2608:226::-;2667:6;2720:2;2708:9;2699:7;2695:23;2691:32;2688:52;;;2736:1;2733;2726:12;2688:52;-1:-1:-1;2781:23:12;;2608:226;-1:-1:-1;2608:226:12:o;2839:118::-;2925:5;2918:13;2911:21;2904:5;2901:32;2891:60;;2947:1;2944;2937:12;2962:382;3027:6;3035;3088:2;3076:9;3067:7;3063:23;3059:32;3056:52;;;3104:1;3101;3094:12;3056:52;3143:9;3130:23;3162:31;3187:5;3162:31;:::i;:::-;3212:5;-1:-1:-1;3269:2:12;3254:18;;3241:32;3282:30;3241:32;3282:30;:::i;:::-;3331:7;3321:17;;;2962:382;;;;;:::o;3580:388::-;3648:6;3656;3709:2;3697:9;3688:7;3684:23;3680:32;3677:52;;;3725:1;3722;3715:12;3677:52;3764:9;3751:23;3783:31;3808:5;3783:31;:::i;:::-;3833:5;-1:-1:-1;3890:2:12;3875:18;;3862:32;3903:33;3862:32;3903:33;:::i;3973:437::-;4052:1;4048:12;;;;4095;;;4116:61;;4170:4;4162:6;4158:17;4148:27;;4116:61;4223:2;4215:6;4212:14;4192:18;4189:38;4186:218;;4260:77;4257:1;4250:88;4361:4;4358:1;4351:15;4389:4;4386:1;4379:15;4186:218;;3973:437;;;:::o;4415:245::-;4482:6;4535:2;4523:9;4514:7;4510:23;4506:32;4503:52;;;4551:1;4548;4541:12;4503:52;4583:9;4577:16;4602:28;4624:5;4602:28;:::i;4977:251::-;5047:6;5100:2;5088:9;5079:7;5075:23;5071:32;5068:52;;;5116:1;5113;5106:12;5068:52;5148:9;5142:16;5167:31;5192:5;5167:31;:::i;5606:279::-;5671:9;;;5692:10;;;5689:190;;;5735:77;5732:1;5725:88;5836:4;5833:1;5826:15;5864:4;5861:1;5854:15","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220b5418256195e6b1307342d24590c1035dc39edb1c7e6a3eea3cce84df01d46b064736f6c634300081c0033","offset":5093}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xeae86c6a45b049ab20cb3d7e13b6dcd39e2a5b4b47ac05d79a35cf7c2018a1ed","blockNumber":"24442033","transactionIndex":"175","deployer":"0xe08c2512F87cF63fb7D2325EDd08aEC7920aC2f6"},"sources":{"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/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/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"@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/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"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/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/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/USG/Tokens/USG.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.22;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\nimport {IUSG} from \"../../interfaces/internals/USG/IUSG.sol\";\nimport {IControlTower} from \"../../interfaces/internals/USG/IControlTower.sol\";\nimport {LightOwnable} from \"../../USG/Utilities/abstract/LightOwnable.sol\";\n\n/// @title Tangent USG\n/// @author Tangent Finance\n/// @notice Locking NFT contract of TAN.\ncontract USG is ERC20, IUSG, LightOwnable {\n    IControlTower public controlTower;\n\n    mapping(address => bool) public isMinter;\n\n    mapping(address => bool) public isBurner;\n\n    mapping(address => bool) public isIRProducer;\n\n    mapping(address => bool) public isPegKeeper;\n\n    error OnlyMinterCaller();\n    error OnlyBurnerCaller();\n    error OnlyIRProducer();\n    error OnlyMarketCreator();\n    error MintOnlyOnPegKeeper();\n    error BurnOnlyFromPegKeeper();\n\n    event SetIsMinter(address minter, bool isMinter);\n    event SetIsBurner(address burner, bool isBurner);\n    event SetIsIRProducer(address irProducer, bool isIRProducer);\n    event SetIsPegKeeper(address pegKeeper, bool isPegKeeper);\n\n    /**\n     * @notice Constructor of USG\n     * @param _dao           Address of the DAO that becomes the owner of the contract\n     * @param _controlTower Address of the control tower\n     */\n    constructor(address _dao, IControlTower _controlTower) ERC20(\"Tangent USD\", \"USG\") {\n        owner = _dao;\n        controlTower = _controlTower;\n    }\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                        MINT\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    /**\n     * @notice Markets call this function to mint USG when users borrow.\n     * @param to     Receiver of the USG\n     * @param amount Amount of USG borrowed to mint\n     */\n    function mintDebt(address to, uint256 amount) external {\n        require(isMinter[msg.sender], OnlyMinterCaller());\n        _mint(to, amount);\n    }\n\n    /**\n     * @notice IRCalculator call this function to mint USG inflated through interests.\n     * @dev    Only callable by an ir producer\n     * @param amount Amount of USG produced by interest rate since last mint on the\n     */\n    function mintIR(uint256 amount) external {\n        require(isIRProducer[msg.sender], OnlyIRProducer());\n        _mint(controlTower.feeTreasury(), amount);\n    }\n\n    /**\n     * @notice Mints USG on a pegKeeper to be able to provide LP in USG in case USG is overpeg.\n     * @dev    Only callable by the DAO.\n     * @param pegKeeper PegKeeper address to mint USG on\n     * @param amount    Amount of USG to mint on the pegKeeper\n     */\n    function mintPegKeeper(address pegKeeper, uint256 amount) external onlyOwner {\n        require(isPegKeeper[pegKeeper], MintOnlyOnPegKeeper());\n        _mint(pegKeeper, amount);\n    }\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                        BURN\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    /**\n     * @notice Markets call this function to burn USG when users repay their loans.\n     * @param from    Address to burn the USG from\n     * @param amount  Amount of USG to burn from the address\n     */\n    function burnDebt(address from, uint256 amount) external {\n        require(isBurner[msg.sender], OnlyBurnerCaller());\n        _burn(from, amount);\n    }\n\n    /**\n     * @notice Burn USG from a pegKeeper if we deprecate a pegkeeper or want to reduce debt to be allocated to peg keeping\n     * @dev    Only callable by the DAO.\n     * @param pegKeeper PegKeeper address to burn USG from\n     * @param amount    Amount of USG to burn from the pegKeeper\n     */\n    function burnPegKeeper(address pegKeeper, uint256 amount) external onlyOwner {\n        require(isPegKeeper[pegKeeper], BurnOnlyFromPegKeeper());\n        _burn(pegKeeper, amount);\n    }\n\n    /**\n     * @notice Burns USG of the caller\n     * @dev    Callable by anyone that have USG.\n     * @param amount Amount of USG to burn from the caller\n     */\n    function burn(uint256 amount) external {\n        _burn(msg.sender, amount);\n    }\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                        SETTERS\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    /**\n     *  @notice Called by a Market Creator to set a new market as minter and burner\n     *  @param  market  Address set as minter and burner\n     */\n    function initializeMarket(address market) external {\n        require(controlTower.isMarketCreator(msg.sender), OnlyMarketCreator());\n        isMinter[market] = true;\n        isBurner[market] = true;\n    }\n\n    /**\n     * @notice Adds or removes an address from the minter role.\n     * @dev Updates the `isMinter` mapping. Callable only by the contract owner.\n     * @param minter    The address whose minter status will be updated.\n     * @param _isMinter `true` to assign the minter role, `false` to revoke it.\n     */\n    function setIsMinter(address minter, bool _isMinter) external onlyOwner {\n        isMinter[minter] = _isMinter;\n        emit SetIsMinter(minter, _isMinter);\n    }\n\n    /**\n     * @notice Adds or removes an address from the burner role.\n     * @dev Updates the `isBurner` mapping. Callable only by the contract owner.\n     * @param burner    The address whose burner status will be updated.\n     * @param _isBurner `true` to assign the burner role, `false` to revoke it.\n     */\n    function setIsBurner(address burner, bool _isBurner) external onlyOwner {\n        isBurner[burner] = _isBurner;\n        emit SetIsBurner(burner, _isBurner);\n    }\n\n    /**\n     * @notice Adds or removes an address from the ir producer role.\n     * @dev Updates the `isIRProducer` mapping. Callable only by the contract owner.\n     * @param irProducer    The address whose ir Producer status will be updated.\n     * @param _isIRProducer `true` to assign the ir producer role, `false` to revoke it.\n     */\n    function setIsIRProducer(address irProducer, bool _isIRProducer) external onlyOwner {\n        isIRProducer[irProducer] = _isIRProducer;\n        emit SetIsIRProducer(irProducer, _isIRProducer);\n    }\n\n    /**\n     * @notice Adds or removes an address from the peg keeper role.\n     * @dev Updates the `isPegKeeper` mapping. Callable only by the contract owner.\n     * @param pegKeeper    The address whose peg keeper status will be updated.\n     * @param _isPegKeeper `true` to assign the peg keeper role, `false` to revoke it.\n     */\n    function setIsPegKeeper(address pegKeeper, bool _isPegKeeper) external onlyOwner {\n        isPegKeeper[pegKeeper] = _isPegKeeper;\n        emit SetIsPegKeeper(pegKeeper, _isPegKeeper);\n    }\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"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun"},"name":"USG","fullyQualifiedName":"src/USG/Tokens/USG.sol:USG"},"abi":[{"type":"constructor","inputs":[{"name":"_dao","type":"address","internalType":"address"},{"name":"_controlTower","type":"address","internalType":"contract IControlTower"}],"stateMutability":"nonpayable"},{"name":"BurnOnlyFromPegKeeper","type":"error","inputs":[]},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"MintOnlyOnPegKeeper","type":"error","inputs":[]},{"name":"OnlyBurnerCaller","type":"error","inputs":[]},{"name":"OnlyIRProducer","type":"error","inputs":[]},{"name":"OnlyMarketCreator","type":"error","inputs":[]},{"name":"OnlyMinterCaller","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"SetIsBurner","type":"event","inputs":[{"name":"burner","type":"address","indexed":false,"internalType":"address"},{"name":"isBurner","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsIRProducer","type":"event","inputs":[{"name":"irProducer","type":"address","indexed":false,"internalType":"address"},{"name":"isIRProducer","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsMinter","type":"event","inputs":[{"name":"minter","type":"address","indexed":false,"internalType":"address"},{"name":"isMinter","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsPegKeeper","type":"event","inputs":[{"name":"pegKeeper","type":"address","indexed":false,"internalType":"address"},{"name":"isPegKeeper","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burn","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burnDebt","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burnPegKeeper","type":"function","inputs":[{"name":"pegKeeper","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"controlTower","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IControlTower"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"initializeMarket","type":"function","inputs":[{"name":"market","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isBurner","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isIRProducer","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isMinter","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isPegKeeper","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mintDebt","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"mintIR","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"mintPegKeeper","type":"function","inputs":[{"name":"pegKeeper","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"setIsBurner","type":"function","inputs":[{"name":"burner","type":"address","internalType":"address"},{"name":"_isBurner","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsIRProducer","type":"function","inputs":[{"name":"irProducer","type":"address","internalType":"address"},{"name":"_isIRProducer","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsMinter","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"},{"name":"_isMinter","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsPegKeeper","type":"function","inputs":[{"name":"pegKeeper","type":"address","internalType":"address"},{"name":"_isPegKeeper","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_dao","type":"address"},{"internalType":"contract IControlTower","name":"_controlTower","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BurnOnlyFromPegKeeper","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"MintOnlyOnPegKeeper","type":"error"},{"inputs":[],"name":"OnlyBurnerCaller","type":"error"},{"inputs":[],"name":"OnlyIRProducer","type":"error"},{"inputs":[],"name":"OnlyMarketCreator","type":"error"},{"inputs":[],"name":"OnlyMinterCaller","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":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"burner","type":"address"},{"indexed":false,"internalType":"bool","name":"isBurner","type":"bool"}],"name":"SetIsBurner","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"irProducer","type":"address"},{"indexed":false,"internalType":"bool","name":"isIRProducer","type":"bool"}],"name":"SetIsIRProducer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"bool","name":"isMinter","type":"bool"}],"name":"SetIsMinter","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pegKeeper","type":"address"},{"indexed":false,"internalType":"bool","name":"isPegKeeper","type":"bool"}],"name":"SetIsPegKeeper","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnDebt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pegKeeper","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnPegKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controlTower","outputs":[{"internalType":"contract IControlTower","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"market","type":"address"}],"name":"initializeMarket","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isBurner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isIRProducer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isPegKeeper","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintDebt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintIR","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pegKeeper","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintPegKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"burner","type":"address"},{"internalType":"bool","name":"_isBurner","type":"bool"}],"name":"setIsBurner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"irProducer","type":"address"},{"internalType":"bool","name":"_isIRProducer","type":"bool"}],"name":"setIsIRProducer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"},{"internalType":"bool","name":"_isMinter","type":"bool"}],"name":"setIsMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pegKeeper","type":"address"},{"internalType":"bool","name":"_isPegKeeper","type":"bool"}],"name":"setIsPegKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"author":"Tangent Finance","errors":{"ERC20InsufficientAllowance(address,uint256,uint256)":[{"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers.","params":{"allowance":"Amount of tokens a `spender` is allowed to operate with.","needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers.","params":{"balance":"Current balance for the interacting account.","needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred."}}],"ERC20InvalidApprover(address)":[{"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals.","params":{"approver":"Address initiating an approval operation."}}],"ERC20InvalidReceiver(address)":[{"details":"Indicates a failure with the token `receiver`. Used in transfers.","params":{"receiver":"Address to which tokens are being transferred."}}],"ERC20InvalidSender(address)":[{"details":"Indicates a failure with the token `sender`. Used in transfers.","params":{"sender":"Address whose tokens are being transferred."}}],"ERC20InvalidSpender(address)":[{"details":"Indicates a failure with the `spender` to be approved. Used in approvals.","params":{"spender":"Address that may be allowed to operate on tokens without being their owner."}}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"kind":"dev","methods":{"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"burn(uint256)":{"details":"Callable by anyone that have USG.","params":{"amount":"Amount of USG to burn from the caller"}},"burnDebt(address,uint256)":{"params":{"amount":"Amount of USG to burn from the address","from":"Address to burn the USG from"}},"burnPegKeeper(address,uint256)":{"details":"Only callable by the DAO.","params":{"amount":"Amount of USG to burn from the pegKeeper","pegKeeper":"PegKeeper address to burn USG from"}},"constructor":{"params":{"_controlTower":"Address of the control tower","_dao":"Address of the DAO that becomes the owner of the contract"}},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"initializeMarket(address)":{"params":{"market":"Address set as minter and burner"}},"mintDebt(address,uint256)":{"params":{"amount":"Amount of USG borrowed to mint","to":"Receiver of the USG"}},"mintIR(uint256)":{"details":"Only callable by an ir producer","params":{"amount":"Amount of USG produced by interest rate since last mint on the"}},"mintPegKeeper(address,uint256)":{"details":"Only callable by the DAO.","params":{"amount":"Amount of USG to mint on the pegKeeper","pegKeeper":"PegKeeper address to mint USG on"}},"name()":{"details":"Returns the name of the token."},"setIsBurner(address,bool)":{"details":"Updates the `isBurner` mapping. Callable only by the contract owner.","params":{"_isBurner":"`true` to assign the burner role, `false` to revoke it.","burner":"The address whose burner status will be updated."}},"setIsIRProducer(address,bool)":{"details":"Updates the `isIRProducer` mapping. Callable only by the contract owner.","params":{"_isIRProducer":"`true` to assign the ir producer role, `false` to revoke it.","irProducer":"The address whose ir Producer status will be updated."}},"setIsMinter(address,bool)":{"details":"Updates the `isMinter` mapping. Callable only by the contract owner.","params":{"_isMinter":"`true` to assign the minter role, `false` to revoke it.","minter":"The address whose minter status will be updated."}},"setIsPegKeeper(address,bool)":{"details":"Updates the `isPegKeeper` mapping. Callable only by the contract owner.","params":{"_isPegKeeper":"`true` to assign the peg keeper role, `false` to revoke it.","pegKeeper":"The address whose peg keeper status will be updated."}},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"title":"Tangent USG","version":1},"userdoc":{"kind":"user","methods":{"burn(uint256)":{"notice":"Burns USG of the caller"},"burnDebt(address,uint256)":{"notice":"Markets call this function to burn USG when users repay their loans."},"burnPegKeeper(address,uint256)":{"notice":"Burn USG from a pegKeeper if we deprecate a pegkeeper or want to reduce debt to be allocated to peg keeping"},"constructor":{"notice":"Constructor of USG"},"initializeMarket(address)":{"notice":"Called by a Market Creator to set a new market as minter and burner"},"mintDebt(address,uint256)":{"notice":"Markets call this function to mint USG when users borrow."},"mintIR(uint256)":{"notice":"IRCalculator call this function to mint USG inflated through interests."},"mintPegKeeper(address,uint256)":{"notice":"Mints USG on a pegKeeper to be able to provide LP in USG in case USG is overpeg."},"setIsBurner(address,bool)":{"notice":"Adds or removes an address from the burner role."},"setIsIRProducer(address,bool)":{"notice":"Adds or removes an address from the ir producer role."},"setIsMinter(address,bool)":{"notice":"Adds or removes an address from the minter role."},"setIsPegKeeper(address,bool)":{"notice":"Adds or removes an address from the peg keeper role."}},"notice":"Locking NFT contract of TAN.","version":1}},"settings":{"compilationTarget":{"src/USG/Tokens/USG.sol":"USG"},"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/interfaces/draft-IERC6093.sol":{"keccak256":"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b","license":"MIT","urls":["bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b","dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz"]},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"keccak256":"0x6ef9389a2c07bc40d8a7ba48914724ab2c108fac391ce12314f01321813e6368","license":"MIT","urls":["bzz-raw://b7a5cb39b1e6df68f4dd9a5e76e853d745a74ffb3dfd7df4ae4d2ace6992a171","dweb:/ipfs/QmPbzKR19rdM8X3PLQjsmHRepUKhvoZnedSR63XyGtXZib"]},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7","license":"MIT","urls":["bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db","dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"]},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330","license":"MIT","urls":["bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf","dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r"]},"@openzeppelin/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"src/USG/Tokens/USG.sol":{"keccak256":"0x61895892022d56fe4c8097f85b4ba351ba33e0c177475462187f8c0ff4d5b227","license":"UNLICENSED","urls":["bzz-raw://24feebe91add0507fcf45f1102907bef724e752785abe64346433cf286f6a34f","dweb:/ipfs/QmVw1pTZJNtgDrGKAmouKz68C4qNvJqd4G9WyJgTq2vkRm"]},"src/USG/Utilities/abstract/LightOwnable.sol":{"keccak256":"0x88c4c115ff0ba91e7d911c9d4dace8626f4622f56c1ee19dfbd612aff283e3b7","license":"UNLICENSED","urls":["bzz-raw://29ca7e825aca8d14f45c6ac7a17cb3995a9167b091fb8acf555bd501e8f65c90","dweb:/ipfs/QmfEAaoxwwnELfg3VW5yDu9rV3Q9hdXUCKkcvwQo9HCbyq"]},"src/interfaces/internals/USG/IControlTower.sol":{"keccak256":"0xa762b09652859e007148df15d5fe60b6678197c2f1aea19e53b453bd53d96eaf","license":"MIT","urls":["bzz-raw://cf3e1494e9e6df32bb48ac64e404341c626aad0d9dd633c958b07c085f3ededc","dweb:/ipfs/QmYhYCghWLjv8WzExcigYhPCANgyx67njKxisNj9tbjBjT"]},"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/IUSG.sol":{"keccak256":"0x39eb5da91c763740799025f16e060d8347a9c1bccbe8875c3a2d2942f9c600df","license":"MIT","urls":["bzz-raw://35c366e2978750d024de951ccf256d497c1d1b595084f1f785f4a860cb579a07","dweb:/ipfs/QmQpgHN6ub6H7DhYzGjAc4pzTjmpfmSzcj4xYcVnJo6rf7"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_contract(IControlTower)1256":{"label":"contract IControlTower","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":163,"label":"_balances","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":169,"label":"_allowances","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"2","type":"t_uint256","astId":171,"label":"_totalSupply","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"3","type":"t_string_storage","astId":173,"label":"_name","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"4","type":"t_string_storage","astId":175,"label":"_symbol","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"5","type":"t_address","astId":1135,"label":"owner","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"6","type":"t_contract(IControlTower)1256","astId":809,"label":"controlTower","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"7","type":"t_mapping(t_address,t_bool)","astId":813,"label":"isMinter","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"8","type":"t_mapping(t_address,t_bool)","astId":817,"label":"isBurner","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"9","type":"t_mapping(t_address,t_bool)","astId":821,"label":"isIRProducer","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"10","type":"t_mapping(t_address,t_bool)","astId":825,"label":"isPegKeeper","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Locking NFT contract of TAN.","methods":{"constructor":{"notice":"Constructor of USG"},"burn(uint256)":{"notice":"Burns USG of the caller"},"mintIR(uint256)":{"notice":"IRCalculator call this function to mint USG inflated through interests."},"burnDebt(address,uint256)":{"notice":"Markets call this function to burn USG when users repay their loans."},"initializeMarket(address)":{"notice":"Called by a Market Creator to set a new market as minter and burner"},"mintDebt(address,uint256)":{"notice":"Markets call this function to mint USG when users borrow."},"setIsBurner(address,bool)":{"notice":"Adds or removes an address from the burner role."},"setIsMinter(address,bool)":{"notice":"Adds or removes an address from the minter role."},"setIsPegKeeper(address,bool)":{"notice":"Adds or removes an address from the peg keeper role."},"setIsIRProducer(address,bool)":{"notice":"Adds or removes an address from the ir producer role."},"burnPegKeeper(address,uint256)":{"notice":"Burn USG from a pegKeeper if we deprecate a pegkeeper or want to reduce debt to be allocated to peg keeping"},"mintPegKeeper(address,uint256)":{"notice":"Mints USG on a pegKeeper to be able to provide LP in USG in case USG is overpeg."}},"version":1},"devdoc":{"kind":"dev","title":"Tangent USG","author":"Tangent Finance","errors":{"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"constructor":{"params":{"_dao":"Address of the DAO that becomes the owner of the contract","_controlTower":"Address of the control tower"}},"burn(uint256)":{"params":{"amount":"Amount of USG to burn from the caller"},"details":"Callable by anyone that have USG."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"mintIR(uint256)":{"params":{"amount":"Amount of USG produced by interest rate since last mint on the"},"details":"Only callable by an ir producer"},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"burnDebt(address,uint256)":{"params":{"from":"Address to burn the USG from","amount":"Amount of USG to burn from the address"}},"initializeMarket(address)":{"params":{"market":"Address set as minter and burner"}},"mintDebt(address,uint256)":{"params":{"to":"Receiver of the USG","amount":"Amount of USG borrowed to mint"}},"setIsBurner(address,bool)":{"params":{"burner":"The address whose burner status will be updated.","_isBurner":"`true` to assign the burner role, `false` to revoke it."},"details":"Updates the `isBurner` mapping. Callable only by the contract owner."},"setIsMinter(address,bool)":{"params":{"minter":"The address whose minter status will be updated.","_isMinter":"`true` to assign the minter role, `false` to revoke it."},"details":"Updates the `isMinter` mapping. Callable only by the contract owner."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"setIsPegKeeper(address,bool)":{"params":{"pegKeeper":"The address whose peg keeper status will be updated.","_isPegKeeper":"`true` to assign the peg keeper role, `false` to revoke it."},"details":"Updates the `isPegKeeper` mapping. Callable only by the contract owner."},"setIsIRProducer(address,bool)":{"params":{"irProducer":"The address whose ir Producer status will be updated.","_isIRProducer":"`true` to assign the ir producer role, `false` to revoke it."},"details":"Updates the `isIRProducer` mapping. Callable only by the contract owner."},"burnPegKeeper(address,uint256)":{"params":{"amount":"Amount of USG to burn from the pegKeeper","pegKeeper":"PegKeeper address to burn USG from"},"details":"Only callable by the DAO."},"mintPegKeeper(address,uint256)":{"params":{"amount":"Amount of USG to mint on the pegKeeper","pegKeeper":"PegKeeper address to mint USG on"},"details":"Only callable by the DAO."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."}},"version":1},"sourceIds":{"src/USG/Tokens/USG.sol":{"id":6},"src/interfaces/internals/USG/IUSG.sol":{"id":11},"src/interfaces/internals/USG/IDebtIR.sol":{"id":9},"@openzeppelin/contracts/utils/Context.sol":{"id":5},"src/USG/Utilities/abstract/LightOwnable.sol":{"id":7},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":3},"src/interfaces/internals/USG/IControlTower.sol":{"id":8},"src/interfaces/internals/USG/IIRCalculator.sol":{"id":10},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":4}},"additionalInput":null,"stdJsonInput":{"sources":{"src/USG/Tokens/USG.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.22;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\nimport {IUSG} from \"../../interfaces/internals/USG/IUSG.sol\";\nimport {IControlTower} from \"../../interfaces/internals/USG/IControlTower.sol\";\nimport {LightOwnable} from \"../../USG/Utilities/abstract/LightOwnable.sol\";\n\n/// @title Tangent USG\n/// @author Tangent Finance\n/// @notice Locking NFT contract of TAN.\ncontract USG is ERC20, IUSG, LightOwnable {\n    IControlTower public controlTower;\n\n    mapping(address => bool) public isMinter;\n\n    mapping(address => bool) public isBurner;\n\n    mapping(address => bool) public isIRProducer;\n\n    mapping(address => bool) public isPegKeeper;\n\n    error OnlyMinterCaller();\n    error OnlyBurnerCaller();\n    error OnlyIRProducer();\n    error OnlyMarketCreator();\n    error MintOnlyOnPegKeeper();\n    error BurnOnlyFromPegKeeper();\n\n    event SetIsMinter(address minter, bool isMinter);\n    event SetIsBurner(address burner, bool isBurner);\n    event SetIsIRProducer(address irProducer, bool isIRProducer);\n    event SetIsPegKeeper(address pegKeeper, bool isPegKeeper);\n\n    /**\n     * @notice Constructor of USG\n     * @param _dao           Address of the DAO that becomes the owner of the contract\n     * @param _controlTower Address of the control tower\n     */\n    constructor(address _dao, IControlTower _controlTower) ERC20(\"Tangent USD\", \"USG\") {\n        owner = _dao;\n        controlTower = _controlTower;\n    }\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                        MINT\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    /**\n     * @notice Markets call this function to mint USG when users borrow.\n     * @param to     Receiver of the USG\n     * @param amount Amount of USG borrowed to mint\n     */\n    function mintDebt(address to, uint256 amount) external {\n        require(isMinter[msg.sender], OnlyMinterCaller());\n        _mint(to, amount);\n    }\n\n    /**\n     * @notice IRCalculator call this function to mint USG inflated through interests.\n     * @dev    Only callable by an ir producer\n     * @param amount Amount of USG produced by interest rate since last mint on the\n     */\n    function mintIR(uint256 amount) external {\n        require(isIRProducer[msg.sender], OnlyIRProducer());\n        _mint(controlTower.feeTreasury(), amount);\n    }\n\n    /**\n     * @notice Mints USG on a pegKeeper to be able to provide LP in USG in case USG is overpeg.\n     * @dev    Only callable by the DAO.\n     * @param pegKeeper PegKeeper address to mint USG on\n     * @param amount    Amount of USG to mint on the pegKeeper\n     */\n    function mintPegKeeper(address pegKeeper, uint256 amount) external onlyOwner {\n        require(isPegKeeper[pegKeeper], MintOnlyOnPegKeeper());\n        _mint(pegKeeper, amount);\n    }\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                        BURN\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    /**\n     * @notice Markets call this function to burn USG when users repay their loans.\n     * @param from    Address to burn the USG from\n     * @param amount  Amount of USG to burn from the address\n     */\n    function burnDebt(address from, uint256 amount) external {\n        require(isBurner[msg.sender], OnlyBurnerCaller());\n        _burn(from, amount);\n    }\n\n    /**\n     * @notice Burn USG from a pegKeeper if we deprecate a pegkeeper or want to reduce debt to be allocated to peg keeping\n     * @dev    Only callable by the DAO.\n     * @param pegKeeper PegKeeper address to burn USG from\n     * @param amount    Amount of USG to burn from the pegKeeper\n     */\n    function burnPegKeeper(address pegKeeper, uint256 amount) external onlyOwner {\n        require(isPegKeeper[pegKeeper], BurnOnlyFromPegKeeper());\n        _burn(pegKeeper, amount);\n    }\n\n    /**\n     * @notice Burns USG of the caller\n     * @dev    Callable by anyone that have USG.\n     * @param amount Amount of USG to burn from the caller\n     */\n    function burn(uint256 amount) external {\n        _burn(msg.sender, amount);\n    }\n\n    /* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=\n                        SETTERS\n    =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-=-= */\n\n    /**\n     *  @notice Called by a Market Creator to set a new market as minter and burner\n     *  @param  market  Address set as minter and burner\n     */\n    function initializeMarket(address market) external {\n        require(controlTower.isMarketCreator(msg.sender), OnlyMarketCreator());\n        isMinter[market] = true;\n        isBurner[market] = true;\n    }\n\n    /**\n     * @notice Adds or removes an address from the minter role.\n     * @dev Updates the `isMinter` mapping. Callable only by the contract owner.\n     * @param minter    The address whose minter status will be updated.\n     * @param _isMinter `true` to assign the minter role, `false` to revoke it.\n     */\n    function setIsMinter(address minter, bool _isMinter) external onlyOwner {\n        isMinter[minter] = _isMinter;\n        emit SetIsMinter(minter, _isMinter);\n    }\n\n    /**\n     * @notice Adds or removes an address from the burner role.\n     * @dev Updates the `isBurner` mapping. Callable only by the contract owner.\n     * @param burner    The address whose burner status will be updated.\n     * @param _isBurner `true` to assign the burner role, `false` to revoke it.\n     */\n    function setIsBurner(address burner, bool _isBurner) external onlyOwner {\n        isBurner[burner] = _isBurner;\n        emit SetIsBurner(burner, _isBurner);\n    }\n\n    /**\n     * @notice Adds or removes an address from the ir producer role.\n     * @dev Updates the `isIRProducer` mapping. Callable only by the contract owner.\n     * @param irProducer    The address whose ir Producer status will be updated.\n     * @param _isIRProducer `true` to assign the ir producer role, `false` to revoke it.\n     */\n    function setIsIRProducer(address irProducer, bool _isIRProducer) external onlyOwner {\n        isIRProducer[irProducer] = _isIRProducer;\n        emit SetIsIRProducer(irProducer, _isIRProducer);\n    }\n\n    /**\n     * @notice Adds or removes an address from the peg keeper role.\n     * @dev Updates the `isPegKeeper` mapping. Callable only by the contract owner.\n     * @param pegKeeper    The address whose peg keeper status will be updated.\n     * @param _isPegKeeper `true` to assign the peg keeper role, `false` to revoke it.\n     */\n    function setIsPegKeeper(address pegKeeper, bool _isPegKeeper) external onlyOwner {\n        isPegKeeper[pegKeeper] = _isPegKeeper;\n        emit SetIsPegKeeper(pegKeeper, _isPegKeeper);\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"},"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/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"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"},"@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/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"@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"},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"@openzeppelin/contracts/token/ERC20/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/Tokens/USG.sol":{"id":6},"src/interfaces/internals/USG/IUSG.sol":{"id":11},"src/interfaces/internals/USG/IDebtIR.sol":{"id":9},"@openzeppelin/contracts/utils/Context.sol":{"id":5},"src/USG/Utilities/abstract/LightOwnable.sol":{"id":7},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":3},"src/interfaces/internals/USG/IControlTower.sol":{"id":8},"src/interfaces/internals/USG/IIRCalculator.sol":{"id":10},"@openzeppelin/contracts/interfaces/draft-IERC6093.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":4}},"contracts":{"src/USG/Tokens/USG.sol":{"USG":{"abi":[{"type":"constructor","inputs":[{"name":"_dao","type":"address","internalType":"address"},{"name":"_controlTower","type":"address","internalType":"contract IControlTower"}],"stateMutability":"nonpayable"},{"name":"BurnOnlyFromPegKeeper","type":"error","inputs":[]},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"MintOnlyOnPegKeeper","type":"error","inputs":[]},{"name":"OnlyBurnerCaller","type":"error","inputs":[]},{"name":"OnlyIRProducer","type":"error","inputs":[]},{"name":"OnlyMarketCreator","type":"error","inputs":[]},{"name":"OnlyMinterCaller","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"SetIsBurner","type":"event","inputs":[{"name":"burner","type":"address","indexed":false,"internalType":"address"},{"name":"isBurner","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsIRProducer","type":"event","inputs":[{"name":"irProducer","type":"address","indexed":false,"internalType":"address"},{"name":"isIRProducer","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsMinter","type":"event","inputs":[{"name":"minter","type":"address","indexed":false,"internalType":"address"},{"name":"isMinter","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"SetIsPegKeeper","type":"event","inputs":[{"name":"pegKeeper","type":"address","indexed":false,"internalType":"address"},{"name":"isPegKeeper","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"burn","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burnDebt","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"burnPegKeeper","type":"function","inputs":[{"name":"pegKeeper","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"controlTower","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract IControlTower"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"initializeMarket","type":"function","inputs":[{"name":"market","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isBurner","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isIRProducer","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isMinter","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"isPegKeeper","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mintDebt","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"mintIR","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"mintPegKeeper","type":"function","inputs":[{"name":"pegKeeper","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"setIsBurner","type":"function","inputs":[{"name":"burner","type":"address","internalType":"address"},{"name":"_isBurner","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsIRProducer","type":"function","inputs":[{"name":"irProducer","type":"address","internalType":"address"},{"name":"_isIRProducer","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsMinter","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"},{"name":"_isMinter","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setIsPegKeeper","type":"function","inputs":[{"name":"pegKeeper","type":"address","internalType":"address"},{"name":"_isPegKeeper","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_dao\",\"type\":\"address\"},{\"internalType\":\"contract IControlTower\",\"name\":\"_controlTower\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"BurnOnlyFromPegKeeper\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"allowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"approver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidApprover\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidReceiver\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSpender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MintOnlyOnPegKeeper\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyBurnerCaller\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyIRProducer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyMarketCreator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyMinterCaller\",\"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\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"burner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isBurner\",\"type\":\"bool\"}],\"name\":\"SetIsBurner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"irProducer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isIRProducer\",\"type\":\"bool\"}],\"name\":\"SetIsIRProducer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isMinter\",\"type\":\"bool\"}],\"name\":\"SetIsMinter\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"pegKeeper\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isPegKeeper\",\"type\":\"bool\"}],\"name\":\"SetIsPegKeeper\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnDebt\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pegKeeper\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnPegKeeper\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"controlTower\",\"outputs\":[{\"internalType\":\"contract IControlTower\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"market\",\"type\":\"address\"}],\"name\":\"initializeMarket\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isBurner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isIRProducer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isPegKeeper\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mintDebt\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mintIR\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pegKeeper\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mintPegKeeper\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"burner\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_isBurner\",\"type\":\"bool\"}],\"name\":\"setIsBurner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"irProducer\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_isIRProducer\",\"type\":\"bool\"}],\"name\":\"setIsIRProducer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_isMinter\",\"type\":\"bool\"}],\"name\":\"setIsMinter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pegKeeper\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_isPegKeeper\",\"type\":\"bool\"}],\"name\":\"setIsPegKeeper\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Tangent Finance\",\"errors\":{\"ERC20InsufficientAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failure with the `spender`’s `allowance`. Used in transfers.\",\"params\":{\"allowance\":\"Amount of tokens a `spender` is allowed to operate with.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC20InsufficientBalance(address,uint256,uint256)\":[{\"details\":\"Indicates an error related to the current `balance` of a `sender`. Used in transfers.\",\"params\":{\"balance\":\"Current balance for the interacting account.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidApprover(address)\":[{\"details\":\"Indicates a failure with the `approver` of a token to be approved. Used in approvals.\",\"params\":{\"approver\":\"Address initiating an approval operation.\"}}],\"ERC20InvalidReceiver(address)\":[{\"details\":\"Indicates a failure with the token `receiver`. Used in transfers.\",\"params\":{\"receiver\":\"Address to which tokens are being transferred.\"}}],\"ERC20InvalidSender(address)\":[{\"details\":\"Indicates a failure with the token `sender`. Used in transfers.\",\"params\":{\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidSpender(address)\":[{\"details\":\"Indicates a failure with the `spender` to be approved. Used in approvals.\",\"params\":{\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}]},\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"burn(uint256)\":{\"details\":\"Callable by anyone that have USG.\",\"params\":{\"amount\":\"Amount of USG to burn from the caller\"}},\"burnDebt(address,uint256)\":{\"params\":{\"amount\":\"Amount of USG to burn from the address\",\"from\":\"Address to burn the USG from\"}},\"burnPegKeeper(address,uint256)\":{\"details\":\"Only callable by the DAO.\",\"params\":{\"amount\":\"Amount of USG to burn from the pegKeeper\",\"pegKeeper\":\"PegKeeper address to burn USG from\"}},\"constructor\":{\"params\":{\"_controlTower\":\"Address of the control tower\",\"_dao\":\"Address of the DAO that becomes the owner of the contract\"}},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"initializeMarket(address)\":{\"params\":{\"market\":\"Address set as minter and burner\"}},\"mintDebt(address,uint256)\":{\"params\":{\"amount\":\"Amount of USG borrowed to mint\",\"to\":\"Receiver of the USG\"}},\"mintIR(uint256)\":{\"details\":\"Only callable by an ir producer\",\"params\":{\"amount\":\"Amount of USG produced by interest rate since last mint on the\"}},\"mintPegKeeper(address,uint256)\":{\"details\":\"Only callable by the DAO.\",\"params\":{\"amount\":\"Amount of USG to mint on the pegKeeper\",\"pegKeeper\":\"PegKeeper address to mint USG on\"}},\"name()\":{\"details\":\"Returns the name of the token.\"},\"setIsBurner(address,bool)\":{\"details\":\"Updates the `isBurner` mapping. Callable only by the contract owner.\",\"params\":{\"_isBurner\":\"`true` to assign the burner role, `false` to revoke it.\",\"burner\":\"The address whose burner status will be updated.\"}},\"setIsIRProducer(address,bool)\":{\"details\":\"Updates the `isIRProducer` mapping. Callable only by the contract owner.\",\"params\":{\"_isIRProducer\":\"`true` to assign the ir producer role, `false` to revoke it.\",\"irProducer\":\"The address whose ir Producer status will be updated.\"}},\"setIsMinter(address,bool)\":{\"details\":\"Updates the `isMinter` mapping. Callable only by the contract owner.\",\"params\":{\"_isMinter\":\"`true` to assign the minter role, `false` to revoke it.\",\"minter\":\"The address whose minter status will be updated.\"}},\"setIsPegKeeper(address,bool)\":{\"details\":\"Updates the `isPegKeeper` mapping. Callable only by the contract owner.\",\"params\":{\"_isPegKeeper\":\"`true` to assign the peg keeper role, `false` to revoke it.\",\"pegKeeper\":\"The address whose peg keeper status will be updated.\"}},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"title\":\"Tangent USG\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"burn(uint256)\":{\"notice\":\"Burns USG of the caller\"},\"burnDebt(address,uint256)\":{\"notice\":\"Markets call this function to burn USG when users repay their loans.\"},\"burnPegKeeper(address,uint256)\":{\"notice\":\"Burn USG from a pegKeeper if we deprecate a pegkeeper or want to reduce debt to be allocated to peg keeping\"},\"constructor\":{\"notice\":\"Constructor of USG\"},\"initializeMarket(address)\":{\"notice\":\"Called by a Market Creator to set a new market as minter and burner\"},\"mintDebt(address,uint256)\":{\"notice\":\"Markets call this function to mint USG when users borrow.\"},\"mintIR(uint256)\":{\"notice\":\"IRCalculator call this function to mint USG inflated through interests.\"},\"mintPegKeeper(address,uint256)\":{\"notice\":\"Mints USG on a pegKeeper to be able to provide LP in USG in case USG is overpeg.\"},\"setIsBurner(address,bool)\":{\"notice\":\"Adds or removes an address from the burner role.\"},\"setIsIRProducer(address,bool)\":{\"notice\":\"Adds or removes an address from the ir producer role.\"},\"setIsMinter(address,bool)\":{\"notice\":\"Adds or removes an address from the minter role.\"},\"setIsPegKeeper(address,bool)\":{\"notice\":\"Adds or removes an address from the peg keeper role.\"}},\"notice\":\"Locking NFT contract of TAN.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/USG/Tokens/USG.sol\":\"USG\"},\"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/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b\",\"dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz\"]},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0x6ef9389a2c07bc40d8a7ba48914724ab2c108fac391ce12314f01321813e6368\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7a5cb39b1e6df68f4dd9a5e76e853d745a74ffb3dfd7df4ae4d2ace6992a171\",\"dweb:/ipfs/QmPbzKR19rdM8X3PLQjsmHRepUKhvoZnedSR63XyGtXZib\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf\",\"dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r\"]},\"@openzeppelin/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"src/USG/Tokens/USG.sol\":{\"keccak256\":\"0x61895892022d56fe4c8097f85b4ba351ba33e0c177475462187f8c0ff4d5b227\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://24feebe91add0507fcf45f1102907bef724e752785abe64346433cf286f6a34f\",\"dweb:/ipfs/QmVw1pTZJNtgDrGKAmouKz68C4qNvJqd4G9WyJgTq2vkRm\"]},\"src/USG/Utilities/abstract/LightOwnable.sol\":{\"keccak256\":\"0x88c4c115ff0ba91e7d911c9d4dace8626f4622f56c1ee19dfbd612aff283e3b7\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://29ca7e825aca8d14f45c6ac7a17cb3995a9167b091fb8acf555bd501e8f65c90\",\"dweb:/ipfs/QmfEAaoxwwnELfg3VW5yDu9rV3Q9hdXUCKkcvwQo9HCbyq\"]},\"src/interfaces/internals/USG/IControlTower.sol\":{\"keccak256\":\"0xa762b09652859e007148df15d5fe60b6678197c2f1aea19e53b453bd53d96eaf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cf3e1494e9e6df32bb48ac64e404341c626aad0d9dd633c958b07c085f3ededc\",\"dweb:/ipfs/QmYhYCghWLjv8WzExcigYhPCANgyx67njKxisNj9tbjBjT\"]},\"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/IUSG.sol\":{\"keccak256\":\"0x39eb5da91c763740799025f16e060d8347a9c1bccbe8875c3a2d2942f9c600df\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://35c366e2978750d024de951ccf256d497c1d1b595084f1f785f4a860cb579a07\",\"dweb:/ipfs/QmQpgHN6ub6H7DhYzGjAc4pzTjmpfmSzcj4xYcVnJo6rf7\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Locking NFT contract of TAN.","methods":{"constructor":{"notice":"Constructor of USG"},"burn(uint256)":{"notice":"Burns USG of the caller"},"mintIR(uint256)":{"notice":"IRCalculator call this function to mint USG inflated through interests."},"burnDebt(address,uint256)":{"notice":"Markets call this function to burn USG when users repay their loans."},"initializeMarket(address)":{"notice":"Called by a Market Creator to set a new market as minter and burner"},"mintDebt(address,uint256)":{"notice":"Markets call this function to mint USG when users borrow."},"setIsBurner(address,bool)":{"notice":"Adds or removes an address from the burner role."},"setIsMinter(address,bool)":{"notice":"Adds or removes an address from the minter role."},"setIsPegKeeper(address,bool)":{"notice":"Adds or removes an address from the peg keeper role."},"setIsIRProducer(address,bool)":{"notice":"Adds or removes an address from the ir producer role."},"burnPegKeeper(address,uint256)":{"notice":"Burn USG from a pegKeeper if we deprecate a pegkeeper or want to reduce debt to be allocated to peg keeping"},"mintPegKeeper(address,uint256)":{"notice":"Mints USG on a pegKeeper to be able to provide LP in USG in case USG is overpeg."}},"version":1},"devdoc":{"kind":"dev","title":"Tangent USG","author":"Tangent Finance","errors":{"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"constructor":{"params":{"_dao":"Address of the DAO that becomes the owner of the contract","_controlTower":"Address of the control tower"}},"burn(uint256)":{"params":{"amount":"Amount of USG to burn from the caller"},"details":"Callable by anyone that have USG."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"mintIR(uint256)":{"params":{"amount":"Amount of USG produced by interest rate since last mint on the"},"details":"Only callable by an ir producer"},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"burnDebt(address,uint256)":{"params":{"from":"Address to burn the USG from","amount":"Amount of USG to burn from the address"}},"initializeMarket(address)":{"params":{"market":"Address set as minter and burner"}},"mintDebt(address,uint256)":{"params":{"to":"Receiver of the USG","amount":"Amount of USG borrowed to mint"}},"setIsBurner(address,bool)":{"params":{"burner":"The address whose burner status will be updated.","_isBurner":"`true` to assign the burner role, `false` to revoke it."},"details":"Updates the `isBurner` mapping. Callable only by the contract owner."},"setIsMinter(address,bool)":{"params":{"minter":"The address whose minter status will be updated.","_isMinter":"`true` to assign the minter role, `false` to revoke it."},"details":"Updates the `isMinter` mapping. Callable only by the contract owner."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"setIsPegKeeper(address,bool)":{"params":{"pegKeeper":"The address whose peg keeper status will be updated.","_isPegKeeper":"`true` to assign the peg keeper role, `false` to revoke it."},"details":"Updates the `isPegKeeper` mapping. Callable only by the contract owner."},"setIsIRProducer(address,bool)":{"params":{"irProducer":"The address whose ir Producer status will be updated.","_isIRProducer":"`true` to assign the ir producer role, `false` to revoke it."},"details":"Updates the `isIRProducer` mapping. Callable only by the contract owner."},"burnPegKeeper(address,uint256)":{"params":{"amount":"Amount of USG to burn from the pegKeeper","pegKeeper":"PegKeeper address to burn USG from"},"details":"Only callable by the DAO."},"mintPegKeeper(address,uint256)":{"params":{"amount":"Amount of USG to mint on the pegKeeper","pegKeeper":"PegKeeper address to mint USG on"},"details":"Only callable by the DAO."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_contract(IControlTower)1256":{"label":"contract IControlTower","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":163,"label":"_balances","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":169,"label":"_allowances","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"2","type":"t_uint256","astId":171,"label":"_totalSupply","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"3","type":"t_string_storage","astId":173,"label":"_name","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"4","type":"t_string_storage","astId":175,"label":"_symbol","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"5","type":"t_address","astId":1135,"label":"owner","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"6","type":"t_contract(IControlTower)1256","astId":809,"label":"controlTower","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"7","type":"t_mapping(t_address,t_bool)","astId":813,"label":"isMinter","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"8","type":"t_mapping(t_address,t_bool)","astId":817,"label":"isBurner","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"9","type":"t_mapping(t_address,t_bool)","astId":821,"label":"isIRProducer","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"},{"slot":"10","type":"t_mapping(t_address,t_bool)","astId":825,"label":"isPegKeeper","offset":0,"contract":"src/USG/Tokens/USG.sol:USG"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"446:6237:6:-:0;;;1349:150;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1601:113:2;;;;;;;;;;;;;-1:-1:-1;;;1601:113:2;;;;;;;;;;;;;;;;-1:-1:-1;;;1601:113:2;;;1675:5;1667;:13;;;;;;:::i;:::-;-1:-1:-1;1690:7:2;:17;1700:7;1690;:17;:::i;:::-;-1:-1:-1;;1442:5:6::1;:12:::0;;-1:-1:-1;;;;;1442:12:6;;::::1;-1:-1:-1::0;;;;;;1442:12:6;;::::1;;::::0;;;1464::::1;:28:::0;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;-1:-1:-1;446:6237:6;;14:131:12;-1:-1:-1;;;;;89:31:12;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:407::-;251:6;259;312:2;300:9;291:7;287:23;283:32;280:52;;;328:1;325;318:12;280:52;360:9;354:16;379:31;404:5;379:31;:::i;:::-;479:2;464:18;;458:25;429:5;;-1:-1:-1;492:33:12;458:25;492:33;:::i;:::-;544:7;534:17;;;150:407;;;;;:::o;562:127::-;623:10;618:3;614:20;611:1;604:31;654:4;651:1;644:15;678:4;675:1;668:15;694:380;773:1;769:12;;;;816;;;837:61;;891:4;883:6;879:17;869:27;;837:61;944:2;936:6;933:14;913:18;910:38;907:161;;990:10;985:3;981:20;978:1;971:31;1025:4;1022:1;1015:15;1053:4;1050:1;1043:15;907:161;;694:380;;;:::o;1205:518::-;1307:2;1302:3;1299:11;1296:421;;;1343:5;1340:1;1333:16;1387:4;1384:1;1374:18;1457:2;1445:10;1441:19;1438:1;1434:27;1428:4;1424:38;1493:4;1481:10;1478:20;1475:47;;;-1:-1:-1;1516:4:12;1475:47;1571:2;1566:3;1562:12;1559:1;1555:20;1549:4;1545:31;1535:41;;1626:81;1644:2;1637:5;1634:13;1626:81;;;1703:1;1689:16;;1670:1;1659:13;1626:81;;;1630:3;;1296:421;1205:518;;;:::o;1899:1299::-;2019:10;;-1:-1:-1;;;;;2041:30:12;;2038:56;;;2074:18;;:::i;:::-;2103:97;2193:6;2153:38;2185:4;2179:11;2153:38;:::i;:::-;2147:4;2103:97;:::i;:::-;2249:4;2280:2;2269:14;;2297:1;2292:649;;;;2985:1;3002:6;2999:89;;;-1:-1:-1;3054:19:12;;;3048:26;2999:89;-1:-1:-1;;1856:1:12;1852:11;;;1848:24;1844:29;1834:40;1880:1;1876:11;;;1831:57;3101:81;;2262:930;;2292:649;1152:1;1145:14;;;1189:4;1176:18;;-1:-1:-1;;2328:20:12;;;2446:222;2460:7;2457:1;2454:14;2446:222;;;2542:19;;;2536:26;2521:42;;2649:4;2634:20;;;;2602:1;2590:14;;;;2476:12;2446:222;;;2450:3;2696:6;2687:7;2684:19;2681:201;;;2757:19;;;2751:26;-1:-1:-1;;2840:1:12;2836:14;;;2852:3;2832:24;2828:37;2824:42;2809:58;2794:74;;2681:201;-1:-1:-1;;;;2928:1:12;2912:14;;;2908:22;2895:36;;-1:-1:-1;1899:1299:12:o;:::-;446:6237:6;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"446:6237:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3998:186;;;;;;:::i;:::-;;:::i;:::-;;;1192:14:12;;1185:22;1167:41;;1155:2;1140:18;3998:186:2;1027:187:12;494:33:6;;;;;;;;;;;;1417:42:12;1405:55;;;1387:74;;1375:2;1360:18;494:33:6;1219:248:12;2849:97:2;2927:12;;2849:97;;;1618:25:12;;;1606:2;1591:18;2849:97:2;1472:177:12;4776:244:2;;;;;;:::i;:::-;;:::i;4438:204:6:-;;;;;;:::i;:::-;;:::i;:::-;;2707:82:2;;;2780:2;2561:36:12;;2549:2;2534:18;2707:82:2;2419:184:12;4037:81:6;;;;;;:::i;:::-;;:::i;581:40::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;6492:189;;;;;;:::i;:::-;;:::i;4962:162::-;;;;;;:::i;:::-;;:::i;3004:116:2:-;;;;;;:::i;:::-;3095:18;;3069:7;3095:18;;;;;;;;;;;;3004:116;3684:184:6;;;;;;:::i;:::-;;:::i;102:20:7:-;;;;;;;;;3222:152:6;;;;;;:::i;:::-;;:::i;1981:93:2:-;;;:::i;1841:148:6:-;;;;;;:::i;:::-;;:::i;3315:178:2:-;;;;;;:::i;:::-;;:::i;534:40:6:-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;5444:162;;;;;;:::i;:::-;;:::i;2668:182::-;;;;;;:::i;:::-;;:::i;679:43::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;5953:198;;;;;;:::i;:::-;;:::i;3551:140:2:-;;;;;;:::i;:::-;3657:18;;;;3631:7;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3551:140;628:44:6;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2229:160;;;;;;:::i;:::-;;:::i;844:215:7:-;;;;;;:::i;:::-;;:::i;1779:89:2:-;1824:13;1856:5;1849:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89;:::o;3998:186::-;4071:4;735:10:5;4125:31:2;735:10:5;4141:7:2;4150:5;4125:8;:31::i;:::-;4173:4;4166:11;;;3998:186;;;;;:::o;4776:244::-;4863:4;735:10:5;4919:37:2;4935:4;735:10:5;4950:5:2;4919:15;:37::i;:::-;4966:26;4976:4;4982:2;4986:5;4966:9;:26::i;:::-;-1:-1:-1;5009:4:2;;4776:244;-1:-1:-1;;;;4776:244:2:o;4438:204:6:-;4507:12;;:40;;;;;4536:10;4507:40;;;1387:74:12;4507:12:6;;;;;:28;;1360:18:12;;4507:40:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4499:70;;;;;;;;;;;;;;;;;4579:16;;;;;;:8;:16;;;;;;;;:23;;4598:4;4579:23;;;;;;;;;4612:8;:16;;;;;:23;;;;;;;;;;4438:204::o;4037:81::-;4086:25;4092:10;4104:6;4086:5;:25::i;:::-;4037:81;:::o;6492:189::-;435:13:7;:11;:13::i;:::-;6583:22:6::1;::::0;::::1;;::::0;;;:11:::1;:22;::::0;;;;;;;;:37;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;6635:39;;4833:74:12;;;4923:18;;;4916:50;6635:39:6::1;::::0;4806:18:12;6635:39:6::1;;;;;;;;6492:189:::0;;:::o;4962:162::-;435:13:7;:11;:13::i;:::-;5044:16:6::1;::::0;::::1;;::::0;;;:8:::1;:16;::::0;;;;;;;;:28;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;5087:30;;4833:74:12;;;4923:18;;;4916:50;5087:30:6::1;::::0;4806:18:12;5087:30:6::1;4665:307:12::0;3684:184:6;435:13:7;:11;:13::i;:::-;3779:22:6::1;::::0;::::1;;::::0;;;:11:::1;:22;::::0;;;;;::::1;;3771:56;;;;;;;;;;;;;;;;;3837:24;3843:9;3854:6;3837:5;:24::i;:::-;3684:184:::0;;:::o;3222:152::-;3306:10;3297:20;;;;:8;:20;;;;;;;;3289:49;;;;;;;;;;;;;;;;1981:93:2;2028:13;2060:7;2053:14;;;;;:::i;1841:148:6:-;1923:10;1914:20;;;;:8;:20;;;;;;;;1906:49;;;;;;;;;;;;;;;;;1965:17;1971:2;1975:6;1965:5;:17::i;3315:178:2:-;3384:4;735:10:5;3438:27:2;735:10:5;3455:2:2;3459:5;3438:9;:27::i;5444:162:6:-;435:13:7;:11;:13::i;:::-;5526:16:6::1;::::0;::::1;;::::0;;;:8:::1;:16;::::0;;;;;;;;:28;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;5569:30;;4833:74:12;;;4923:18;;;4916:50;5569:30:6::1;::::0;4806:18:12;5569:30:6::1;4665:307:12::0;2668:182:6;435:13:7;:11;:13::i;:::-;2763:22:6::1;::::0;::::1;;::::0;;;:11:::1;:22;::::0;;;;;::::1;;2755:54;;;;;;;;;;;;;;;;5953:198:::0;435:13:7;:11;:13::i;:::-;6047:24:6::1;::::0;::::1;;::::0;;;:12:::1;:24;::::0;;;;;;;;:40;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;6102:42;;4833:74:12;;;4923:18;;;4916:50;6102:42:6::1;::::0;4806:18:12;6102:42:6::1;4665:307:12::0;2229:160:6;2301:10;2288:24;;;;:12;:24;;;;;;;;2280:51;;;;;;;;;;;;;;;;;2347:12;;:26;;;;;;;;2341:41;;2347:12;;;:24;;:26;;;;;;;;;;;;;;:12;:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2375:6;2341:5;:41::i;844:215:7:-;435:13;:11;:13::i;:::-;928:22:::1;::::0;::::1;924:91;;973:31;::::0;::::1;::::0;;1001:1:::1;973:31;::::0;::::1;1387:74:12::0;1360:18;;973:31:7::1;;;;;;;;924:91;1024:28;1043:8;1024:18;:28::i;8726:128:2:-:0;8810:37;8819:5;8826:7;8835:5;8842:4;8810:8;:37::i;:::-;8726:128;;;:::o;10415:476::-;3657:18;;;;10514:24;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;10599:17;10580:36;;10576:309;;;10655:5;10636:16;:24;10632:130;;;10687:60;;;;;5465:42:12;5453:55;;10687:60:2;;;5435:74:12;5525:18;;;5518:34;;;5568:18;;;5561:34;;;5408:18;;10687:60:2;5233:368:12;10632:130:2;10803:57;10812:5;10819:7;10847:5;10828:16;:24;10854:5;10803:8;:57::i;:::-;10504:387;10415:476;;;:::o;5393:300::-;5476:18;;;5472:86;;5517:30;;;;;5544:1;5517:30;;;1387:74:12;1360:18;;5517:30:2;1219:248:12;5472:86:2;5571:16;;;5567:86;;5610:32;;;;;5639:1;5610:32;;;1387:74:12;1360:18;;5610:32:2;1219:248:12;5567:86:2;5662:24;5670:4;5676:2;5680:5;5662:7;:24::i;7984:206::-;8054:21;;;8050:89;;8098:30;;;;;8125:1;8098:30;;;1387:74:12;1360:18;;8098:30:2;1219:248:12;8050:89:2;8148:35;8156:7;8173:1;8177:5;8148:7;:35::i;539:156:7:-;598:5;;:19;:5;607:10;598:19;594:95;;640:38;;;;;667:10;640:38;;;1387:74:12;1360:18;;640:38:7;1219:248:12;594:95:7;539:156::o;7458:208:2:-;7528:21;;;7524:91;;7572:32;;;;;7601:1;7572:32;;;1387:74:12;1360:18;;7572:32:2;1219:248:12;7524:91:2;7624:35;7640:1;7644:7;7653:5;7624:7;:35::i;1213:185:7:-;1305:5;;;;1320:16;;;;;;;;;;;1351:40;;1305:5;;;1320:16;1305:5;;1351:40;;1286:16;;1351:40;1276:122;1213:185;:::o;9701:432:2:-;9813:19;;;9809:89;;9855:32;;;;;9884:1;9855:32;;;1387:74:12;1360:18;;9855:32:2;1219:248:12;9809:89:2;9911:21;;;9907:90;;9955:31;;;;;9983:1;9955:31;;;1387:74:12;1360:18;;9955:31:2;1219:248:12;9907:90:2;10006:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;10051:76;;;;10101:7;10085:31;;10094:5;10085:31;;;10110:5;10085:31;;;;1618:25:12;;1606:2;1591:18;;1472:177;10085:31:2;;;;;;;;9701:432;;;;:::o;6008:1107::-;6097:18;;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:2;;-1:-1:-1;6093:540:2;;6307:15;;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;;;;5465:42:12;5453:55;;6386:50:2;;;5435:74:12;5525:18;;;5518:34;;;5568:18;;;5561:34;;;5408:18;;6386:50:2;5233:368:12;6336:115:2;6571:15;;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;6647:16;;;6643:425;;6810:12;:21;;;;;;;6643:425;;;7021:13;;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;7083:25;;7092:4;7083:25;;;7102:5;7083:25;;;;1618::12;;1606:2;1591:18;;1472:177;7083:25:2;;;;;;;;6008:1107;;;:::o;14:477:12:-;163:2;152:9;145:21;126:4;195:6;189:13;238:6;233:2;222:9;218:18;211:34;297:6;292:2;284:6;280:15;275:2;264:9;260:18;254:50;353:1;348:2;339:6;328:9;324:22;320:31;313:42;482:2;412:66;407:2;399:6;395:15;391:88;380:9;376:104;372:113;364:121;;;14:477;;;;:::o;496:154::-;582:42;575:5;571:54;564:5;561:65;551:93;;640:1;637;630:12;655:367;723:6;731;784:2;772:9;763:7;759:23;755:32;752:52;;;800:1;797;790:12;752:52;839:9;826:23;858:31;883:5;858:31;:::i;:::-;908:5;986:2;971:18;;;;958:32;;-1:-1:-1;;;655:367:12:o;1654:508::-;1731:6;1739;1747;1800:2;1788:9;1779:7;1775:23;1771:32;1768:52;;;1816:1;1813;1806:12;1768:52;1855:9;1842:23;1874:31;1899:5;1874:31;:::i;:::-;1924:5;-1:-1:-1;1981:2:12;1966:18;;1953:32;1994:33;1953:32;1994:33;:::i;:::-;1654:508;;2046:7;;-1:-1:-1;;;2126:2:12;2111:18;;;;2098:32;;1654:508::o;2167:247::-;2226:6;2279:2;2267:9;2258:7;2254:23;2250:32;2247:52;;;2295:1;2292;2285:12;2247:52;2334:9;2321:23;2353:31;2378:5;2353:31;:::i;:::-;2403:5;2167:247;-1:-1:-1;;;2167:247:12:o;2608:226::-;2667:6;2720:2;2708:9;2699:7;2695:23;2691:32;2688:52;;;2736:1;2733;2726:12;2688:52;-1:-1:-1;2781:23:12;;2608:226;-1:-1:-1;2608:226:12:o;2839:118::-;2925:5;2918:13;2911:21;2904:5;2901:32;2891:60;;2947:1;2944;2937:12;2962:382;3027:6;3035;3088:2;3076:9;3067:7;3063:23;3059:32;3056:52;;;3104:1;3101;3094:12;3056:52;3143:9;3130:23;3162:31;3187:5;3162:31;:::i;:::-;3212:5;-1:-1:-1;3269:2:12;3254:18;;3241:32;3282:30;3241:32;3282:30;:::i;:::-;3331:7;3321:17;;;2962:382;;;;;:::o;3580:388::-;3648:6;3656;3709:2;3697:9;3688:7;3684:23;3680:32;3677:52;;;3725:1;3722;3715:12;3677:52;3764:9;3751:23;3783:31;3808:5;3783:31;:::i;:::-;3833:5;-1:-1:-1;3890:2:12;3875:18;;3862:32;3903:33;3862:32;3903:33;:::i;3973:437::-;4052:1;4048:12;;;;4095;;;4116:61;;4170:4;4162:6;4158:17;4148:27;;4116:61;4223:2;4215:6;4212:14;4192:18;4189:38;4186:218;;4260:77;4257:1;4250:88;4361:4;4358:1;4351:15;4389:4;4386:1;4379:15;4186:218;;3973:437;;;:::o;4415:245::-;4482:6;4535:2;4523:9;4514:7;4510:23;4506:32;4503:52;;;4551:1;4548;4541:12;4503:52;4583:9;4577:16;4602:28;4624:5;4602:28;:::i;4977:251::-;5047:6;5100:2;5088:9;5079:7;5075:23;5071:32;5068:52;;;5116:1;5113;5106:12;5068:52;5148:9;5142:16;5167:31;5192:5;5167:31;:::i;5606:279::-;5671:9;;;5692:10;;;5689:190;;;5735:77;5732:1;5725:88;5836:4;5833:1;5826:15;5864:4;5861:1;5854:15","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"burnDebt(address,uint256)","signatureHash4":"0x936474cc","signatureHash32":"0x936474cc2b1e4c90c6a092eba5995fc99bad36d3c1ed7b5fee150f2cf00a46e6"},{"signature":"burnPegKeeper(address,uint256)","signatureHash4":"0x82112b4f","signatureHash32":"0x82112b4f4d9d12251d74179b8362f2a81c144c5a7e6332c6b2426371920c5db0"},{"signature":"burn(uint256)","signatureHash4":"0x42966c68","signatureHash32":"0x42966c689b5afe9b9b3f8a7103b2a19980d59629bfd6a20a60972312ed41d836"},{"signature":"controlTower()","signatureHash4":"0x0975bb7e","signatureHash32":"0x0975bb7ed245b00394f75fd58fe46d89d50595432bbe7197c7f738b87ae7bd1a"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"initializeMarket(address)","signatureHash4":"0x2a869a4d","signatureHash32":"0x2a869a4d15a37585872d679c32545b14eea491c26aece3d3371a01da14d3ffa2"},{"signature":"isBurner(address)","signatureHash4":"0x4334614a","signatureHash32":"0x4334614afaa1316729aff7fe3d383a1fcc7c31f715ff24329a7441b41a39c075"},{"signature":"isIRProducer(address)","signatureHash4":"0xe3fef41a","signatureHash32":"0xe3fef41a2c979628a50e0ed18507c814c3efabb5b4eea32d73b30a9353f2e5de"},{"signature":"isMinter(address)","signatureHash4":"0xaa271e1a","signatureHash32":"0xaa271e1a9a41b51f5b4e2e4ce717c974174719a5ddc12cee839f0eabbdf42748"},{"signature":"isPegKeeper(address)","signatureHash4":"0xc4f654de","signatureHash32":"0xc4f654de91be6ce448d00ae6a3af9c68764ce5035b659f3c5400a57176755ea3"},{"signature":"mintDebt(address,uint256)","signatureHash4":"0x9d0bee03","signatureHash32":"0x9d0bee036ff6e6bfacffa8116a2f225c093235ba8e3c510f7928e78eb851824f"},{"signature":"mintIR(uint256)","signatureHash4":"0xe9734c12","signatureHash32":"0xe9734c12d132ce4400eaca7b77d07b319884109e7be0a9def2cc0eb39567e6ae"},{"signature":"mintPegKeeper(address,uint256)","signatureHash4":"0xbea688c3","signatureHash32":"0xbea688c369daf7e6b209c51c759eb5b984be15ca1fc15e0029c7ab222ff20beb"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"setIsBurner(address,bool)","signatureHash4":"0xb2080e95","signatureHash32":"0xb2080e95fe1116f3298361148aff360d080c789d3c1d866a0d2afd417456194f"},{"signature":"setIsIRProducer(address,bool)","signatureHash4":"0xcc13de9c","signatureHash32":"0xcc13de9cdc704b061058aab441266377970f1be23f17e9f3fcdab38789f3d99c"},{"signature":"setIsMinter(address,bool)","signatureHash4":"0x66eb399f","signatureHash32":"0x66eb399fdc33ecae7fe112783e470fe61921ec46639be7ac2f589fa0bc3c9de3"},{"signature":"setIsPegKeeper(address,bool)","signatureHash4":"0x46bf079b","signatureHash32":"0x46bf079b71c90211eeac4f56ce76d0cf769ce13b5a9b1ba80f12695a2ed28e86"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"SetIsBurner(address,bool)","signatureHash4":"0x8f28e0c9","signatureHash32":"0x8f28e0c96d86fa612e88ee0cf2f691757404c42d885120dd814919ea80db9660"},{"signature":"SetIsIRProducer(address,bool)","signatureHash4":"0x1cdf9da3","signatureHash32":"0x1cdf9da3d1ef2de401a96539c7c841dd5468148c7a4d1627b3a5c39ad3ac90e2"},{"signature":"SetIsMinter(address,bool)","signatureHash4":"0x60475603","signatureHash32":"0x60475603ebaf63fcfd229e007ed76eadd15ccbdede7e79bac0655826a9122936"},{"signature":"SetIsPegKeeper(address,bool)","signatureHash4":"0x504f1a49","signatureHash32":"0x504f1a49576a537f885e54bf1895e37ee914ea4b69f74d358470af30755b2818"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[{"signature":"BurnOnlyFromPegKeeper()","signatureHash4":"0x2583ce04","signatureHash32":"0x2583ce044be07df1ea559ace0ee6814a7657e75f66f861b4c06a524a14799aa4"},{"signature":"ERC20InsufficientAllowance(address,uint256,uint256)","signatureHash4":"0xfb8f41b2","signatureHash32":"0xfb8f41b23e99d2101d86da76cdfa87dd51c82ed07d3cb62cbc473e469dbc75c3"},{"signature":"ERC20InsufficientBalance(address,uint256,uint256)","signatureHash4":"0xe450d38c","signatureHash32":"0xe450d38cd8d9f7d95077d567d60ed49c7254716e6ad08fc9872816c97e0ffec6"},{"signature":"ERC20InvalidApprover(address)","signatureHash4":"0xe602df05","signatureHash32":"0xe602df05cc75712490294c6c104ab7c17f4030363910a7a2626411c6d3118847"},{"signature":"ERC20InvalidReceiver(address)","signatureHash4":"0xec442f05","signatureHash32":"0xec442f055133b72f3b2f9f0bb351c406b178527de2040a7d1feb4e058771f613"},{"signature":"ERC20InvalidSender(address)","signatureHash4":"0x96c6fd1e","signatureHash32":"0x96c6fd1edd0cd6ef7ff0ecc0facdf53148dc0048b57fe58af65755250a7a96bd"},{"signature":"ERC20InvalidSpender(address)","signatureHash4":"0x94280d62","signatureHash32":"0x94280d62c347d8d9f4d59a76ea321452406db88df38e0c9da304f58b57b373a2"},{"signature":"MintOnlyOnPegKeeper()","signatureHash4":"0x97b97604","signatureHash32":"0x97b976049df54ffc47ebaab729e8749f6fe78dfd8ac691a68db4db8c7c70f982"},{"signature":"OnlyBurnerCaller()","signatureHash4":"0x4c606fda","signatureHash32":"0x4c606fdae5a31c705b244bdfec21f06a592d13d1880519b6ff2302af6cf4dc45"},{"signature":"OnlyIRProducer()","signatureHash4":"0x621f6780","signatureHash32":"0x621f6780e67756ce1c173ea97c089225dbc629af7fd4ace0d4e69f262b2dd363"},{"signature":"OnlyMarketCreator()","signatureHash4":"0x38993a49","signatureHash32":"0x38993a4966e29e8a806113267196fb14c7afb133ab8be8179a749f9138b0822d"},{"signature":"OnlyMinterCaller()","signatureHash4":"0x868c71f6","signatureHash32":"0x868c71f6f9ed895a7e9b43186c5c6bdac2f1c405d7c6c3bcd48f68f2b2500fcb"},{"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":"0xB1c2Db5d6cA03FCe73dBd304d320bF76C55Ae1B1"}