{"matchId":"37134297","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-06-27T02:00:27Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x608060405234801561001057600080fd5b5061001961001e565b6100dd565b600054610100900460ff161561008a5760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b606482015260840160405180910390fd5b60005460ff908116146100db576000805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b611131806100ec6000396000f3fe608060405234801561001057600080fd5b50600436106101735760003560e01c8063668a0f02116100de5780639a6fc8f511610097578063a4381d1f11610071578063a4381d1f14610415578063bb23ae2514610428578063d74bc41d1461044b578063feaf968c1461047257600080fd5b80639a6fc8f51461039f5780639d6bb3e8146103e6578063a217fddf1461040d57600080fd5b8063668a0f021461032157806370da2f671461034c5780637284e4161461035957806378d3f14e1461036e57806389d6e95f146103775780638ffabcdb1461038c57600080fd5b8063313ce56711610130578063313ce5671461026f5780635245b9191461027e5780635300b4ba146102a557806354fd4d50146102cc5780635fdafbc1146102d357806362b199c5146102fa57600080fd5b80630ccb6a8e1461017857806313007d55146101ad57806315b9598a146101de57806319d8ac61146102055780631ed411631461022857806322adbc781461024f575b600080fd5b7f5ad51e524c557071e7424ecb78b8b2f23d4d06d730e4bd3cfa6eff5561aa8a5f5b6040519081526020015b60405180910390f35b6000546101c6906201000090046001600160a01b031681565b6040516001600160a01b0390911681526020016101a4565b61019a7f77c5b782690f31cd39b1abf2448215259a688a75920040c399d96a676bd1999d81565b6034546001600160501b031660009081526038602052604090206003015461019a565b61019a7fd2576bd6a4c5558421de15cb8ecdf4eb3282aac06b94d4f004e8cd0d00f3ebd881565b60365461025c9060170b81565b60405160179190910b81526020016101a4565b604051600881526020016101a4565b61019a7fc559c9124f407f8d569399f6abbb492717925cb609d14448fc3699033ab4306a81565b61019a7f2fdc6683bc8d03effec5b41d3834f28bd219e06ca0a6a26fc737e44b1c7889ff81565b600161019a565b61019a7fe5bc009db6d8a7d0985a5b10b94bad297196bbbf014a5f9cc72ca9e100f3a75481565b61019a7f548c7f0307ab2a7ea894e5c7e8c5353cc750bb9385ee2e945f189a9a83daa8ed81565b603454610334906001600160501b031681565b6040516001600160501b0390911681526020016101a4565b60375461025c9060170b81565b61036161047a565b6040516101a49190610cc4565b61019a60355481565b61038a610385366004610d19565b610508565b005b61038a61039a366004610d49565b610607565b6103b26103ad366004610e04565b610800565b604080516001600160501b03968716815260208101959095528401929092526060830152909116608082015260a0016101a4565b61019a7f5ad51e524c557071e7424ecb78b8b2f23d4d06d730e4bd3cfa6eff5561aa8a5f81565b61019a600081565b61038a610423366004610d19565b610867565b6034546001600160501b031660009081526038602052604090206001015461019a565b61019a7f49a103d47daa98d445728ba0f2e848dccbbd73dea56729c961450eeb09890acc81565b6103b26109c9565b6033805461048790610e34565b80601f01602080910402602001604051908101604052809291908181526020018280546104b390610e34565b80156105005780601f106104d557610100808354040283529160200191610500565b820191906000526020600020905b8154815290600101906020018083116104e357829003601f168201915b505050505081565b6034546001600160501b031660009081526038602052604090206003015480156105a0576034546001600160501b031660009081526038602052604081206001015461055490846109fa565b905060355481111561059e5760405162461bcd60e51b815260206004820152600e60248201526d21a09d1010b232bb34b0ba34b7b760911b60448201526064015b60405180910390fd5b505b610e106105ad8242610e85565b116105fa5760405162461bcd60e51b815260206004820152601a60248201527f43413a206e6f7420656e6f7567682074696d65207061737365640000000000006044820152606401610595565b61060382610867565b5050565b600054610100900460ff16158080156106275750600054600160ff909116105b806106415750303b158015610641575060005460ff166001145b6106a45760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b6064820152608401610595565b6000805460ff1916600117905580156106c7576000805461ff0019166101001790555b6106d087610a87565b8460170b8660170b126107145760405162461bcd60e51b815260206004820152600c60248201526b08682744042dad2dc5edac2f60a31b6044820152606401610595565b6107206008600a610f80565b61072b906064610f8f565b84111561076f5760405162461bcd60e51b815260206004820152601260248201527121a09d1010b6b0bc103232bb34b0ba34b7b760711b6044820152606401610595565b603680546001600160c01b038089166001600160c01b031992831617909255603780549288169290911691909117905560358490556107b060338484610c2b565b5080156107f7576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50505050505050565b6001600160501b03908116600090815260386020908152604091829020825160a08101845281548516808252600183015493820184905260028301549482018590526003830154606083018190526004909301549095166080909101819052939491939091565b6108917f5ad51e524c557071e7424ecb78b8b2f23d4d06d730e4bd3cfa6eff5561aa8a5f33610b61565b60365460170b81128015906108ab575060375460170b8113155b6108ee5760405162461bcd60e51b815260206004820152601460248201527343413a206f7574206f66205b6d696e3b6d61785d60601b6044820152606401610595565b603454600090610908906001600160501b03166001610fae565b6040805160a0810182526001600160501b038084168083526020808401888152428587018181526060870182815260808801868152600087815260389096528986209851895490891669ffffffffffffffffffff19918216178a55945160018a015591516002890155516003880155516004909601805496909516958216959095179093556034805490931682179092559251939450909285917f0559884fd3a460db3073b7fc896cc77986f16e378210ded43186175bf646fc5f91a45050565b60345460009081908190819081906109e9906001600160501b0316610800565b945094509450945094509091929394565b600081610a1f57610a0d6008600a610f80565b610a18906064610f8f565b9050610a81565b6000610a2d6008600a610f80565b90506000610a3b8585610fd9565b9050600085610a4a8484611018565b610a55906064611018565b610a5f919061109d565b905060008112610a6f5780610a7b565b610a7b81600019611018565b93505050505b92915050565b600054610100900460ff16610af25760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201526a6e697469616c697a696e6760a81b6064820152608401610595565b6001600160a01b038116610b375760405162461bcd60e51b815260206004820152600c60248201526b7a65726f206164647265737360a01b6044820152606401610595565b600080546001600160a01b03909216620100000262010000600160b01b0319909216919091179055565b600054604051632474521560e21b8152600481018490526001600160a01b03838116602483015262010000909204909116906391d148549060440160206040518083038186803b158015610bb457600080fd5b505afa158015610bc8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bec91906110d9565b6106035760405162461bcd60e51b815260206004820152601060248201526f574d41433a206861736e7420726f6c6560801b6044820152606401610595565b828054610c3790610e34565b90600052602060002090601f016020900481019282610c595760008555610c9f565b82601f10610c725782800160ff19823516178555610c9f565b82800160010185558215610c9f579182015b82811115610c9f578235825591602001919060010190610c84565b50610cab929150610caf565b5090565b5b80821115610cab5760008155600101610cb0565b600060208083528351808285015260005b81811015610cf157858101830151858201604001528201610cd5565b81811115610d03576000604083870101525b50601f01601f1916929092016040019392505050565b600060208284031215610d2b57600080fd5b5035919050565b8035601781900b8114610d4457600080fd5b919050565b60008060008060008060a08789031215610d6257600080fd5b86356001600160a01b0381168114610d7957600080fd5b9550610d8760208801610d32565b9450610d9560408801610d32565b935060608701359250608087013567ffffffffffffffff80821115610db957600080fd5b818901915089601f830112610dcd57600080fd5b813581811115610ddc57600080fd5b8a6020828501011115610dee57600080fd5b6020830194508093505050509295509295509295565b600060208284031215610e1657600080fd5b81356001600160501b0381168114610e2d57600080fd5b9392505050565b600181811c90821680610e4857607f821691505b60208210811415610e6957634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b600082821015610e9757610e97610e6f565b500390565b600181815b80851115610ed7578160001904821115610ebd57610ebd610e6f565b80851615610eca57918102915b93841c9390800290610ea1565b509250929050565b600082610eee57506001610a81565b81610efb57506000610a81565b8160018114610f115760028114610f1b57610f37565b6001915050610a81565b60ff841115610f2c57610f2c610e6f565b50506001821b610a81565b5060208310610133831016604e8410600b8410161715610f5a575081810a610a81565b610f648383610e9c565b8060001904821115610f7857610f78610e6f565b029392505050565b6000610e2d60ff841683610edf565b6000816000190483118215151615610fa957610fa9610e6f565b500290565b60006001600160501b03808316818516808303821115610fd057610fd0610e6f565b01949350505050565b60008083128015600160ff1b850184121615610ff757610ff7610e6f565b6001600160ff1b038401831381161561101257611012610e6f565b50500390565b60006001600160ff1b038184138284138082168684048611161561103e5761103e610e6f565b600160ff1b600087128281168783058912161561105d5761105d610e6f565b6000871292508782058712848416161561107957611079610e6f565b8785058712818416161561108f5761108f610e6f565b505050929093029392505050565b6000826110ba57634e487b7160e01b600052601260045260246000fd5b600160ff1b8214600019841416156110d4576110d4610e6f565b500590565b6000602082840312156110eb57600080fd5b81518015158114610e2d57600080fdfea26469706673582212204792733b27bf50f06954a314eb92c5e9d304545a958d884d91a4cf491653589f64736f6c63430008090033","sourceMap":"333:412:23:-:0;;;;;;;;;;;;-1:-1:-1;502:22:16;:20;:22::i;:::-;333:412:23;;5939:280:3;6007:13;;;;;;;6006:14;5998:66;;;;-1:-1:-1;;;5998:66:3;;216:2:25;5998:66:3;;;198:21:25;255:2;235:18;;;228:30;294:34;274:18;;;267:62;-1:-1:-1;;;345:18:25;;;338:37;392:19;;5998:66:3;;;;;;;;6078:12;;6094:15;6078:12;;;:31;6074:139;;6125:12;:30;;-1:-1:-1;;6125:30:3;6140:15;6125:30;;;;;;6174:28;;564:36:25;;;6174:28:3;;552:2:25;537:18;6174:28:3;;;;;;;6074:139;5939:280::o;422:184:25:-;333:412:23;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212204792733b27bf50f06954a314eb92c5e9d304545a958d884d91a4cf491653589f64736f6c63430008090033","offset":4584}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"333:412:23:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;616:127;808:52:24;616:127:23;;;160:25:25;;;148:2;133:18;616:127:23;;;;;;;;532:39:19;;;;;;;;-1:-1:-1;;;;;532:39:19;;;;;;-1:-1:-1;;;;;387:32:25;;;369:51;;357:2;342:18;532:39:19;196:230:25;320:94:18;;378:36;320:94;;5115:112:20;5198:11;;-1:-1:-1;;;;;5198:11:20;5161:7;5187:23;;;:10;:23;;;;;:33;;;5115:112;;665:72:18;;708:29;665:72;;1214:23:20;;;;;;;;;;;;786:2:25;775:22;;;;757:41;;745:2;730:18;1214:23:20;613:191:25;6097:73:20;;;6162:1;951:36:25;;939:2;924:18;6097:73:20;809:184:25;330:108:24;;395:43;330:108;;507:94:18;;565:36;507:94;;4787:76:20;4855:1;4787:76;;518:114:24;;586:46;518:114;;801:72:18;;844:29;801:72;;942:25:20;;;;;-1:-1:-1;;;;;942:25:20;;;;;;-1:-1:-1;;;;;1160:35:25;;;1142:54;;1130:2;1115:18;942:25:20;998:204:25;1320:23:20;;;;;;;;;856:34;;;:::i;:::-;;;;;;;:::i;1098:33::-;;;;;;3111:455;;;;;;:::i;:::-;;:::i;:::-;;2195:606;;;;;;:::i;:::-;;:::i;5290:510::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3750:15:25;;;3732:34;;3797:2;3782:18;;3775:34;;;;3825:18;;3818:34;;;;3883:2;3868:18;;3861:34;3932:15;;;3926:3;3911:19;;3904:44;3678:3;3663:19;5290:510:20;3438:516:25;734:126:24;;808:52;734:126;;409:49:19;;454:4;409:49;;3818:553:20;;;;;;:::i;:::-;;:::i;4935:105::-;5014:11;;-1:-1:-1;;;;;5014:11:20;4978:6;5003:23;;;:10;:23;;;;;5014:11;5003:30;;4935:105;;922:98:24;;982:38;922:98;;4434:290:20;;;:::i;856:34::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3111:455::-;5198:11;;-1:-1:-1;;;;;5198:11:20;3170:22;5187:23;;;:10;:23;;;;;:33;;;3225:19;;3221:176;;5014:11;;-1:-1:-1;;;;;5014:11:20;3260:17;5003:23;;;:10;:23;;;;;5014:11;5003:30;;3280:34;;3308:5;3280:13;:34::i;:::-;3260:54;;3349:18;;3336:9;:31;;3328:58;;;;-1:-1:-1;;;3328:58:20;;4726:2:25;3328:58:20;;;4708:21:25;4765:2;4745:18;;;4738:30;-1:-1:-1;;;4784:18:25;;;4777:44;4838:18;;3328:58:20;;;;;;;;;3246:151;3221:176;3463:7;3428:32;3446:14;3428:15;:32;:::i;:::-;:42;3407:115;;;;-1:-1:-1;;;3407:115:20;;5331:2:25;3407:115:20;;;5313:21:25;5370:2;5350:18;;;5343:30;5409:28;5389:18;;;5382:56;5455:18;;3407:115:20;5129:350:25;3407:115:20;3540:19;3553:5;3540:12;:19::i;:::-;3533:26;3111:455;:::o;2195:606::-;3279:19:3;3302:13;;;;;;3301:14;;3347:34;;;;-1:-1:-1;3365:12:3;;3380:1;3365:12;;;;:16;3347:34;3346:108;;;-1:-1:-1;3426:4:3;1713:19:9;:23;;;3387:66:3;;-1:-1:-1;3436:12:3;;;;;:17;3387:66;3325:201;;;;-1:-1:-1;;;3325:201:3;;5686:2:25;3325:201:3;;;5668:21:25;5725:2;5705:18;;;5698:30;5764:34;5744:18;;;5737:62;-1:-1:-1;;;5815:18:25;;;5808:44;5869:19;;3325:201:3;5484:410:25;3325:201:3;3536:12;:16;;-1:-1:-1;;3536:16:3;3551:1;3536:16;;;3562:65;;;;3596:13;:20;;-1:-1:-1;;3596:20:3;;;;;3562:65;2419:45:20::1;2449:14;2419:29;:45::i;:::-;2496:10;2483:23;;:10;:23;;;2475:48;;;::::0;-1:-1:-1;;;2475:48:20;;6101:2:25;2475:48:20::1;::::0;::::1;6083:21:25::0;6140:2;6120:18;;;6113:30;-1:-1:-1;;;6159:18:25;;;6152:42;6211:18;;2475:48:20::1;5899:336:25::0;2475:48:20::1;2584:14;6162:1:::0;2584:2:::1;:14;:::i;:::-;2577:22;::::0;:3:::1;:22;:::i;:::-;2554:19;:45;;2533:110;;;::::0;-1:-1:-1;;;2533:110:20;;7998:2:25;2533:110:20::1;::::0;::::1;7980:21:25::0;8037:2;8017:18;;;8010:30;-1:-1:-1;;;8056:18:25;;;8049:48;8114:18;;2533:110:20::1;7796:342:25::0;2533:110:20::1;2654:9;:22:::0;;-1:-1:-1;;;;;2654:22:20;;;-1:-1:-1;;;;;;2654:22:20;;::::1;;::::0;;;2686:9:::1;:22:::0;;;;;;;;::::1;::::0;;;::::1;::::0;;2718:18:::1;:40:::0;;;2768:26:::1;:11;2782:12:::0;;2768:26:::1;:::i;:::-;;3651:14:3::0;3647:99;;;3697:5;3681:21;;-1:-1:-1;;3681:21:3;;;3721:14;;-1:-1:-1;951:36:25;;3721:14:3;;939:2:25;924:18;3721:14:3;;;;;;;3647:99;3269:483;2195:606:20;;;;;;:::o;5290:510::-;-1:-1:-1;;;;;5580:20:20;;;5387:14;5580:20;;;:10;:20;;;;;;;;;5551:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5290:510::o;3818:553::-;1708:38;808:52:24;1735:10:20;1708:9;:38::i;:::-;3921:9:::1;::::0;::::1;;3912:18:::0;::::1;::::0;::::1;::::0;:40:::1;;-1:-1:-1::0;3943:9:20::1;::::0;::::1;;3934:18:::0;::::1;;3912:40;3891:107;;;::::0;-1:-1:-1;;;3891:107:20;;8544:2:25;3891:107:20::1;::::0;::::1;8526:21:25::0;8583:2;8563:18;;;8556:30;-1:-1:-1;;;8602:18:25;;;8595:50;8662:18;;3891:107:20::1;8342:344:25::0;3891:107:20::1;4026:11;::::0;4009:14:::1;::::0;4026:15:::1;::::0;-1:-1:-1;;;;;4026:11:20::1;::::0;:15:::1;:::i;:::-;4074:196;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;4074:196:20;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;4166:15:::1;4074:196:::0;;;;;;;;;;;;;;;;;;-1:-1:-1;4052:19:20;;;:10:::1;:19:::0;;;;;;:218;;;;;;::::1;-1:-1:-1::0;;4052:218:20;;::::1;;::::0;;;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;4281:11:::1;:21:::0;;;;::::1;::::0;::::1;::::0;;;4318:46;;4009:32;;-1:-1:-1;4166:15:20;;4136:5;;4318:46:::1;::::0;::::1;3881:490;3818:553:::0;:::o;4434:290::-;4705:11;;4521:14;;;;;;;;;;4692:25;;-1:-1:-1;;;;;4705:11:20;4692:12;:25::i;:::-;4685:32;;;;;;;;;;4434:290;;;;;:::o;6326:442::-;6433:7;6460:14;6456:47;;6489:14;6162:1;6489:2;:14;:::i;:::-;6483:20;;:3;:20;:::i;:::-;6476:27;;;;6456:47;6513:10;6533:14;6162:1;6533:2;:14;:::i;:::-;6513:35;-1:-1:-1;6558:15:20;6576:22;6588:10;6576:9;:22;:::i;:::-;6558:40;-1:-1:-1;6608:16:20;6652:10;6628:14;6639:3;6558:40;6628:14;:::i;:::-;:20;;6645:3;6628:20;:::i;:::-;6627:35;;;;:::i;:::-;6608:54;;6696:1;6684:9;:13;:42;;6717:9;6684:42;;;6700:14;:9;-1:-1:-1;;6700:14:20;:::i;:::-;6672:54;-1:-1:-1;;;;6326:442:20;;;;;:::o;1157:239:19:-;5374:13:3;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:3;;10263:2:25;5366:69:3;;;10245:21:25;10302:2;10282:18;;;10275:30;10341:34;10321:18;;;10314:62;-1:-1:-1;;;10392:18:25;;;10385:41;10443:19;;5366:69:3;10061:407:25;5366:69:3;-1:-1:-1;;;;;1284:28:19;::::1;1276:53;;;::::0;-1:-1:-1;;;1276:53:19;;10675:2:25;1276:53:19::1;::::0;::::1;10657:21:25::0;10714:2;10694:18;;;10687:30;-1:-1:-1;;;10733:18:25;;;10726:42;10785:18;;1276:53:19::1;10473:336:25::0;1276:53:19::1;1339:13;:50:::0;;-1:-1:-1;;;;;1339:50:19;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;1339:50:19;;::::1;::::0;;;::::1;::::0;;1157:239::o;1470:146::-;1552:13;;:36;;-1:-1:-1;;;1552:36:19;;;;;10988:25:25;;;-1:-1:-1;;;;;11049:32:25;;;11029:18;;;11022:60;1552:13:19;;;;;;;;:21;;10961:18:25;;1552:36:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1544:65;;;;-1:-1:-1;;;1544:65:19;;11577:2:25;1544:65:19;;;11559:21:25;11616:2;11596:18;;;11589:30;-1:-1:-1;;;11635:18:25;;;11628:46;11691:18;;1544:65:19;11375:340:25;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;1207:597:25;1319:4;1348:2;1377;1366:9;1359:21;1409:6;1403:13;1452:6;1447:2;1436:9;1432:18;1425:34;1477:1;1487:140;1501:6;1498:1;1495:13;1487:140;;;1596:14;;;1592:23;;1586:30;1562:17;;;1581:2;1558:26;1551:66;1516:10;;1487:140;;;1645:6;1642:1;1639:13;1636:91;;;1715:1;1710:2;1701:6;1690:9;1686:22;1682:31;1675:42;1636:91;-1:-1:-1;1788:2:25;1767:15;-1:-1:-1;;1763:29:25;1748:45;;;;1795:2;1744:54;;1207:597;-1:-1:-1;;;1207:597:25:o;1809:179::-;1867:6;1920:2;1908:9;1899:7;1895:23;1891:32;1888:52;;;1936:1;1933;1926:12;1888:52;-1:-1:-1;1959:23:25;;1809:179;-1:-1:-1;1809:179:25:o;1993:162::-;2060:20;;2120:2;2109:21;;;2099:32;;2089:60;;2145:1;2142;2135:12;2089:60;1993:162;;;:::o;2160:980::-;2265:6;2273;2281;2289;2297;2305;2358:3;2346:9;2337:7;2333:23;2329:33;2326:53;;;2375:1;2372;2365:12;2326:53;2401:23;;-1:-1:-1;;;;;2453:31:25;;2443:42;;2433:70;;2499:1;2496;2489:12;2433:70;2522:5;-1:-1:-1;2546:37:25;2579:2;2564:18;;2546:37;:::i;:::-;2536:47;;2602:37;2635:2;2624:9;2620:18;2602:37;:::i;:::-;2592:47;;2686:2;2675:9;2671:18;2658:32;2648:42;;2741:3;2730:9;2726:19;2713:33;2765:18;2806:2;2798:6;2795:14;2792:34;;;2822:1;2819;2812:12;2792:34;2860:6;2849:9;2845:22;2835:32;;2905:7;2898:4;2894:2;2890:13;2886:27;2876:55;;2927:1;2924;2917:12;2876:55;2967:2;2954:16;2993:2;2985:6;2982:14;2979:34;;;3009:1;3006;2999:12;2979:34;3054:7;3049:2;3040:6;3036:2;3032:15;3028:24;3025:37;3022:57;;;3075:1;3072;3065:12;3022:57;3106:2;3102;3098:11;3088:21;;3128:6;3118:16;;;;;2160:980;;;;;;;;:::o;3145:288::-;3203:6;3256:2;3244:9;3235:7;3231:23;3227:32;3224:52;;;3272:1;3269;3262:12;3224:52;3311:9;3298:23;-1:-1:-1;;;;;3354:5:25;3350:34;3343:5;3340:45;3330:73;;3399:1;3396;3389:12;3330:73;3422:5;3145:288;-1:-1:-1;;;3145:288:25:o;4139:380::-;4218:1;4214:12;;;;4261;;;4282:61;;4336:4;4328:6;4324:17;4314:27;;4282:61;4389:2;4381:6;4378:14;4358:18;4355:38;4352:161;;;4435:10;4430:3;4426:20;4423:1;4416:31;4470:4;4467:1;4460:15;4498:4;4495:1;4488:15;4352:161;;4139:380;;;:::o;4867:127::-;4928:10;4923:3;4919:20;4916:1;4909:31;4959:4;4956:1;4949:15;4983:4;4980:1;4973:15;4999:125;5039:4;5067:1;5064;5061:8;5058:34;;;5072:18;;:::i;:::-;-1:-1:-1;5109:9:25;;4999:125::o;6240:422::-;6329:1;6372:5;6329:1;6386:270;6407:7;6397:8;6394:21;6386:270;;;6466:4;6462:1;6458:6;6454:17;6448:4;6445:27;6442:53;;;6475:18;;:::i;:::-;6525:7;6515:8;6511:22;6508:55;;;6545:16;;;;6508:55;6624:22;;;;6584:15;;;;6386:270;;;6390:3;6240:422;;;;;:::o;6667:806::-;6716:5;6746:8;6736:80;;-1:-1:-1;6787:1:25;6801:5;;6736:80;6835:4;6825:76;;-1:-1:-1;6872:1:25;6886:5;;6825:76;6917:4;6935:1;6930:59;;;;7003:1;6998:130;;;;6910:218;;6930:59;6960:1;6951:10;;6974:5;;;6998:130;7035:3;7025:8;7022:17;7019:43;;;7042:18;;:::i;:::-;-1:-1:-1;;7098:1:25;7084:16;;7113:5;;6910:218;;7212:2;7202:8;7199:16;7193:3;7187:4;7184:13;7180:36;7174:2;7164:8;7161:16;7156:2;7150:4;7147:12;7143:35;7140:77;7137:159;;;-1:-1:-1;7249:19:25;;;7281:5;;7137:159;7328:34;7353:8;7347:4;7328:34;:::i;:::-;7398:6;7394:1;7390:6;7386:19;7377:7;7374:32;7371:58;;;7409:18;;:::i;:::-;7447:20;;6667:806;-1:-1:-1;;;6667:806:25:o;7478:140::-;7536:5;7565:47;7606:4;7596:8;7592:19;7586:4;7565:47;:::i;7623:168::-;7663:7;7729:1;7725;7721:6;7717:14;7714:1;7711:21;7706:1;7699:9;7692:17;7688:45;7685:71;;;7736:18;;:::i;:::-;-1:-1:-1;7776:9:25;;7623:168::o;8691:240::-;8730:3;-1:-1:-1;;;;;8807:2:25;8804:1;8800:10;8837:2;8834:1;8830:10;8868:3;8864:2;8860:12;8855:3;8852:21;8849:47;;;8876:18;;:::i;:::-;8912:13;;8691:240;-1:-1:-1;;;;8691:240:25:o;8936:267::-;8975:4;9004:9;;;9029:10;;-1:-1:-1;;;9048:19:25;;9041:27;;9025:44;9022:70;;;9072:18;;:::i;:::-;-1:-1:-1;;;;;9119:27:25;;9112:35;;9104:44;;9101:70;;;9151:18;;:::i;:::-;-1:-1:-1;;9188:9:25;;8936:267::o;9208:553::-;9247:7;-1:-1:-1;;;;;9317:9:25;;;9345;;;9370:11;;;9389:10;;;9383:17;;9366:35;9363:61;;;9404:18;;:::i;:::-;-1:-1:-1;;;9480:1:25;9473:9;;9498:11;;;9518;;;9511:19;;9494:37;9491:63;;;9534:18;;:::i;:::-;9580:1;9577;9573:9;9563:19;;9627:1;9623:2;9618:11;9615:1;9611:19;9606:2;9602;9598:11;9594:37;9591:63;;;9634:18;;:::i;:::-;9699:1;9695:2;9690:11;9687:1;9683:19;9678:2;9674;9670:11;9666:37;9663:63;;;9706:18;;:::i;:::-;-1:-1:-1;;;9746:9:25;;;;;9208:553;-1:-1:-1;;;9208:553:25:o;9766:290::-;9805:1;9831;9821:132;;9875:10;9870:3;9866:20;9863:1;9856:31;9910:4;9907:1;9900:15;9938:4;9935:1;9928:15;9821:132;-1:-1:-1;;;9969:18:25;;-1:-1:-1;;9989:13:25;;9965:38;9962:64;;;10006:18;;:::i;:::-;-1:-1:-1;10040:10:25;;9766:290::o;11093:277::-;11160:6;11213:2;11201:9;11192:7;11188:23;11184:32;11181:52;;;11229:1;11226;11219:12;11181:52;11261:9;11255:16;11314:5;11307:13;11300:21;11293:5;11290:32;11280:60;;11336:1;11333;11326:12","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212204792733b27bf50f06954a314eb92c5e9d304545a958d884d91a4cf491653589f64736f6c63430008090033","offset":4348}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x2c308f061a07e1e782a937c2bb9523d7815739ce1a38bc282edb60daf09cde92","blockNumber":"47368676","transactionIndex":"370","deployer":"0x0A70688e6A5a0f1C09E79A9975f11bdF0De7e872"},"sources":{"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n  function decimals() external view returns (uint8);\n\n  function description() external view returns (string memory);\n\n  function version() external view returns (uint256);\n\n  function getRoundData(uint80 _roundId)\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n\n  function latestRoundData()\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n}\n"},"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControlUpgradeable.sol\";\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n    function __AccessControl_init() internal onlyInitializing {\n    }\n\n    function __AccessControl_init_unchained() internal onlyInitializing {\n    }\n    struct RoleData {\n        mapping(address => bool) members;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with a standardized message including the required role.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     *\n     * _Available since v4.1._\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n        return _roles[role].members[account];\n    }\n\n    /**\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\n     *\n     * Format of the revert message is described in {_checkRole}.\n     *\n     * _Available since v4.6._\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Revert with a standard message if `account` is missing `role`.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert(\n                string(\n                    abi.encodePacked(\n                        \"AccessControl: account \",\n                        StringsUpgradeable.toHexString(account),\n                        \" is missing role \",\n                        StringsUpgradeable.toHexString(uint256(role), 32)\n                    )\n                )\n            );\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address account) public virtual override {\n        require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event. Note that unlike {grantRole}, this function doesn't perform any\n     * checks on the calling account.\n     *\n     * May emit a {RoleGranted} event.\n     *\n     * [WARNING]\n     * ====\n     * This function should only be called from the constructor when setting\n     * up the initial roles for the system.\n     *\n     * Using this function in any other way is effectively circumventing the admin\n     * system imposed by {AccessControl}.\n     * ====\n     *\n     * NOTE: This function is deprecated in favor of {_grantRole}.\n     */\n    function _setupRole(bytes32 role, address account) internal virtual {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual {\n        if (!hasRole(role, account)) {\n            _roles[role].members[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual {\n        if (hasRole(role, account)) {\n            _roles[role].members[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n}\n"},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized != type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    function __Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __Pausable_init_unchained() internal onlyInitializing {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.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 * For a generic mechanism see {ERC20PresetMinterPauser}.\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 ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => 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    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\n        __ERC20_init_unchained(name_, symbol_);\n    }\n\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override 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 override 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 override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override 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 `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\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 `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `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     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` 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    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[45] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20Upgradeable.sol\";\nimport \"../../../security/PausableUpgradeable.sol\";\nimport \"../../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev ERC20 token with pausable token transfers, minting and burning.\n *\n * Useful for scenarios such as preventing trades until the end of an evaluation\n * period, or having an emergency switch for freezing all token transfers in the\n * event of a large bug.\n *\n * IMPORTANT: This contract does not include public pause and unpause functions. In\n * addition to inheriting this contract, you must define both functions, invoking the\n * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate\n * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will\n * make the contract unpausable.\n */\nabstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {\n    function __ERC20Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __ERC20Pausable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {ERC20-_beforeTokenTransfer}.\n     *\n     * Requirements:\n     *\n     * - the contract must not be paused.\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {\n        super._beforeTokenTransfer(from, to, amount);\n\n        require(!paused(), \"ERC20Pausable: token transfer while paused\");\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\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-upgradeable/token/ERC20/IERC20Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\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 amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` 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 amount) 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 `amount` as the allowance of `spender` over the 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 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` 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 amount) external returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n    function __ERC165_init() internal onlyInitializing {\n    }\n\n    function __ERC165_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165Upgradeable).interfaceId;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary MathUpgradeable {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMathUpgradeable {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/MathUpgradeable.sol\";\nimport \"./math/SignedMathUpgradeable.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = MathUpgradeable.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMathUpgradeable.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"contracts/abstract/MidasInitializable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n/**\n * @title MidasInitializable\n * @author RedDuck Software\n * @notice Base Initializable contract that implements constructor\n * that calls _disableInitializers() to prevent\n * initialization of implementation contract\n */\nabstract contract MidasInitializable is Initializable {\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n}\n"},"contracts/access/MidasAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\nimport \"./MidasAccessControlRoles.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title MidasAccessControl\n * @notice Smart contract that stores all roles for Midas project\n * @author RedDuck Software\n */\ncontract MidasAccessControl is\n    AccessControlUpgradeable,\n    MidasInitializable,\n    MidasAccessControlRoles\n{\n    /**\n     * @notice upgradeable pattern contract`s initializer\n     */\n    function initialize() external initializer {\n        __AccessControl_init();\n        _setupRoles(msg.sender);\n    }\n\n    /**\n     * @notice grant multiple roles to multiple users\n     * in one transaction\n     * @dev length`s of 2 arays should match\n     * @param roles array of bytes32 roles\n     * @param addresses array of user addresses\n     */\n    function grantRoleMult(bytes32[] memory roles, address[] memory addresses)\n        external\n    {\n        require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n\n        for (uint256 i = 0; i < roles.length; i++) {\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\n            _grantRole(roles[i], addresses[i]);\n        }\n    }\n\n    /**\n     * @notice revoke multiple roles from multiple users\n     * in one transaction\n     * @dev length`s of 2 arays should match\n     * @param roles array of bytes32 roles\n     * @param addresses array of user addresses\n     */\n    function revokeRoleMult(bytes32[] memory roles, address[] memory addresses)\n        external\n    {\n        require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n        for (uint256 i = 0; i < roles.length; i++) {\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\n            _revokeRole(roles[i], addresses[i]);\n        }\n    }\n\n    //solhint-disable disable-next-line\n    function renounceRole(bytes32, address) public pure override {\n        revert(\"MAC: Forbidden\");\n    }\n\n    /**\n     * @dev setup roles during the contracts initialization\n     */\n    function _setupRoles(address admin) private {\n        _grantRole(DEFAULT_ADMIN_ROLE, admin);\n\n        _setRoleAdmin(BLACKLISTED_ROLE, BLACKLIST_OPERATOR_ROLE);\n        _setRoleAdmin(GREENLISTED_ROLE, GREENLIST_OPERATOR_ROLE);\n    }\n}\n"},"contracts/access/MidasAccessControlRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\n/**\n * @title MidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors\n * @author RedDuck Software\n */\nabstract contract MidasAccessControlRoles {\n    /**\n     * @notice actor that can change green list statuses of addresses\n     */\n    bytes32 public constant GREENLIST_OPERATOR_ROLE =\n        keccak256(\"GREENLIST_OPERATOR_ROLE\");\n\n    /**\n     * @notice actor that can change black list statuses of addresses\n     */\n    bytes32 public constant BLACKLIST_OPERATOR_ROLE =\n        keccak256(\"BLACKLIST_OPERATOR_ROLE\");\n\n    /**\n     * @notice actor that is greenlisted\n     */\n    bytes32 public constant GREENLISTED_ROLE = keccak256(\"GREENLISTED_ROLE\");\n\n    /**\n     * @notice actor that is blacklisted\n     */\n    bytes32 public constant BLACKLISTED_ROLE = keccak256(\"BLACKLISTED_ROLE\");\n}\n"},"contracts/access/WithMidasAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"./MidasAccessControl.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title WithMidasAccessControl\n * @notice Base contract that consumes MidasAccessControl\n * @author RedDuck Software\n */\nabstract contract WithMidasAccessControl is\n    MidasInitializable,\n    MidasAccessControlRoles\n{\n    /**\n     * @notice admin role\n     */\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @notice MidasAccessControl contract address\n     */\n    MidasAccessControl public accessControl;\n\n    /**\n     * @dev leaving a storage gap for futures updates\n     */\n    uint256[50] private __gap;\n\n    /**\n     * @dev checks that given `address` have `role`\n     */\n    modifier onlyRole(bytes32 role, address account) {\n        _onlyRole(role, account);\n        _;\n    }\n\n    /**\n     * @dev checks that given `address` do not have `role`\n     */\n    modifier onlyNotRole(bytes32 role, address account) {\n        _onlyNotRole(role, account);\n        _;\n    }\n\n    /**\n     * @dev upgradeable pattern contract`s initializer\n     */\n    // solhint-disable func-name-mixedcase\n    function __WithMidasAccessControl_init(address _accessControl)\n        internal\n        onlyInitializing\n    {\n        require(_accessControl != address(0), \"zero address\");\n        accessControl = MidasAccessControl(_accessControl);\n    }\n\n    /**\n     * @dev checks that given `address` have `role`\n     */\n    function _onlyRole(bytes32 role, address account) internal view {\n        require(accessControl.hasRole(role, account), \"WMAC: hasnt role\");\n    }\n\n    /**\n     * @dev checks that given `address` do not have `role`\n     */\n    function _onlyNotRole(bytes32 role, address account) internal view {\n        require(!accessControl.hasRole(role, account), \"WMAC: has role\");\n    }\n}\n"},"contracts/feeds/CustomAggregatorV3CompatibleFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\nimport \"../interfaces/IDataFeed.sol\";\n\n/**\n * @title CustomAggregatorV3CompatibleFeed\n * @notice AggregatorV3 compatible feed, where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract CustomAggregatorV3CompatibleFeed is\n    WithMidasAccessControl,\n    AggregatorV3Interface\n{\n    struct RoundData {\n        uint80 roundId;\n        int256 answer;\n        uint256 startedAt;\n        uint256 updatedAt;\n        uint80 answeredInRound;\n    }\n\n    /**\n     * @notice feed description\n     */\n    string public override description;\n\n    /**\n     * @notice last round id\n     */\n    uint80 public latestRound;\n\n    /**\n     * @notice max deviation from lattest price in %\n     * @dev 10 ** decimals() is a percentage precision\n     */\n    uint256 public maxAnswerDeviation;\n\n    /**\n     * @notice minimal possible answer that feed can return\n     */\n    int192 public minAnswer;\n\n    /**\n     * @notice maximal possible answer that feed can return\n     */\n    int192 public maxAnswer;\n\n    /**\n     * @dev holds round information\n     */\n    mapping(uint80 => RoundData) private _roundData;\n\n    event AnswerUpdated(\n        int256 indexed data,\n        uint256 indexed roundId,\n        uint256 indexed timestamp\n    );\n\n    /**\n     * @dev checks that msg.sender do have a feedAdminRole() role\n     */\n    modifier onlyAggregatorAdmin() {\n        _onlyRole(feedAdminRole(), msg.sender);\n        _;\n    }\n\n    /**\n     * @notice upgradeable pattern contract`s initializer\n     * @param _accessControl address of MidasAccessControll contract\n     * @param _minAnswer init value for `minAnswer`. Should be < `_maxAnswer`\n     * @param _maxAnswer init value for `maxAnswer`. Should be > `_minAnswer`\n     * @param _maxAnswerDeviation init value for `maxAnswerDeviation`\n     * @param _description init value for `description`\n     */\n    function initialize(\n        address _accessControl,\n        int192 _minAnswer,\n        int192 _maxAnswer,\n        uint256 _maxAnswerDeviation,\n        string calldata _description\n    ) public virtual initializer {\n        __WithMidasAccessControl_init(_accessControl);\n\n        require(_minAnswer < _maxAnswer, \"CA: !min/max\");\n        require(\n            _maxAnswerDeviation <= 100 * (10**decimals()),\n            \"CA: !max deviation\"\n        );\n\n        minAnswer = _minAnswer;\n        maxAnswer = _maxAnswer;\n        maxAnswerDeviation = _maxAnswerDeviation;\n        description = _description;\n    }\n\n    /**\n     * @notice works as `setRoundData()`, but also checks the\n     * deviation with the lattest submitted data, and that at least\n     * 1 hour passed since the lattest submission\n     * @dev deviation with previous data needs to be <= `maxAnswerDeviation`\n     * @param _data data value\n     */\n    function setRoundDataSafe(int256 _data) external {\n        uint256 _lastUpdatedAt = lastTimestamp();\n\n        if (_lastUpdatedAt != 0) {\n            uint256 deviation = _getDeviation(lastAnswer(), _data);\n            require(deviation <= maxAnswerDeviation, \"CA: !deviation\");\n        }\n\n        require(\n            block.timestamp - _lastUpdatedAt > 1 hours,\n            \"CA: not enough time passed\"\n        );\n\n        return setRoundData(_data);\n    }\n\n    /**\n     * @notice sets the data for `latestRound` + 1 round id\n     * @dev `_data` should be >= `minAnswer` and <= `maxAnswer`.\n     * Function should be called only from address with `feedAdminRole()`\n     * @param _data data value\n     */\n    function setRoundData(int256 _data) public onlyAggregatorAdmin {\n        require(\n            _data >= minAnswer && _data <= maxAnswer,\n            \"CA: out of [min;max]\"\n        );\n\n        uint80 roundId = latestRound + 1;\n\n        _roundData[roundId] = RoundData({\n            roundId: roundId,\n            answer: _data,\n            startedAt: block.timestamp,\n            updatedAt: block.timestamp,\n            answeredInRound: roundId\n        });\n\n        latestRound = roundId;\n\n        emit AnswerUpdated(_data, roundId, block.timestamp);\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function latestRoundData()\n        external\n        view\n        returns (\n            uint80 roundId,\n            int256 answer,\n            uint256 startedAt,\n            uint256 updatedAt,\n            uint80 answeredInRound\n        )\n    {\n        return getRoundData(latestRound);\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function version() external pure returns (uint256) {\n        return 1;\n    }\n\n    /**\n     * @return answer of lattest price submission\n     */\n    function lastAnswer() public view returns (int256) {\n        return _roundData[latestRound].answer;\n    }\n\n    /**\n     * @return timestamp of lattest price submission\n     */\n    function lastTimestamp() public view returns (uint256) {\n        return _roundData[latestRound].updatedAt;\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function getRoundData(uint80 _roundId)\n        public\n        view\n        returns (\n            uint80 roundId,\n            int256 answer,\n            uint256 startedAt,\n            uint256 updatedAt,\n            uint80 answeredInRound\n        )\n    {\n        RoundData memory roundData = _roundData[_roundId];\n        return (\n            roundData.roundId,\n            roundData.answer,\n            roundData.startedAt,\n            roundData.updatedAt,\n            roundData.answeredInRound\n        );\n    }\n\n    /**\n     * @dev describes a role, owner of which can update prices in this feed\n     * @return role descriptor\n     */\n    function feedAdminRole() public view virtual returns (bytes32) {\n        return DEFAULT_ADMIN_ROLE;\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function decimals() public pure returns (uint8) {\n        return 8;\n    }\n\n    /**\n     * @dev calculates a deviation in % between `_lastPrice` and `_newPrice`\n     * @return deviation in `10 ** decimals()` precision\n     */\n    function _getDeviation(int256 _lastPrice, int256 _newPrice)\n        internal\n        pure\n        returns (uint256)\n    {\n        if (_newPrice == 0) return 100 * 10**decimals();\n        int256 one = int256(10**decimals());\n        int256 priceDif = _newPrice - _lastPrice;\n        int256 deviation = (priceDif * one * 100) / _lastPrice;\n        deviation = deviation < 0 ? deviation * -1 : deviation;\n        return uint256(deviation);\n    }\n}\n"},"contracts/interfaces/IDataFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\n\n/**\n * @title IDataFeed\n * @author RedDuck Software\n */\ninterface IDataFeed {\n    /**\n     * @notice fetches answer from aggregator\n     * and converts it to the base18 precision\n     * @return answer fetched aggregator answer\n     */\n    function getDataInBase18() external view returns (uint256 answer);\n\n    /**\n     * @dev describes a role, owner of which can manage this feed\n     * @return role descriptor\n     */\n    function feedAdminRole() external view returns (bytes32);\n}\n"},"contracts/libraries/DecimalsCorrectionLibrary.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\n/**\n * @title DecimalsCorrectionLibrary\n * @author RedDuck Software\n */\nlibrary DecimalsCorrectionLibrary {\n    /**\n     * @dev converts `originalAmount` with `originalDecimals` into\n     * amount with `decidedDecimals`\n     * @param originalAmount amount to convert\n     * @param originalDecimals decimals of the original amount\n     * @param decidedDecimals decimals for the output amount\n     * @return amount converted amount with `decidedDecimals`\n     */\n    function convert(\n        uint256 originalAmount,\n        uint256 originalDecimals,\n        uint256 decidedDecimals\n    ) internal pure returns (uint256) {\n        if (originalAmount == 0) return 0;\n        if (originalDecimals == decidedDecimals) return originalAmount;\n\n        uint256 adjustedAmount;\n\n        if (originalDecimals > decidedDecimals) {\n            adjustedAmount =\n                originalAmount /\n                (10**(originalDecimals - decidedDecimals));\n        } else {\n            adjustedAmount =\n                originalAmount *\n                (10**(decidedDecimals - originalDecimals));\n        }\n\n        return adjustedAmount;\n    }\n\n    /**\n     * @dev converts `originalAmount` with decimals 18 into\n     * amount with `decidedDecimals`\n     * @param originalAmount amount to convert\n     * @param decidedDecimals decimals for the output amount\n     * @return amount converted amount with `decidedDecimals`\n     */\n    function convertFromBase18(uint256 originalAmount, uint256 decidedDecimals)\n        internal\n        pure\n        returns (uint256)\n    {\n        return convert(originalAmount, 18, decidedDecimals);\n    }\n\n    /**\n     * @dev converts `originalAmount` with `originalDecimals` into\n     * amount with decimals 18\n     * @param originalAmount amount to convert\n     * @param originalDecimals decimals of the original amount\n     * @return amount converted amount with 18 decimals\n     */\n    function convertToBase18(uint256 originalAmount, uint256 originalDecimals)\n        internal\n        pure\n        returns (uint256)\n    {\n        return convert(originalAmount, originalDecimals, 18);\n    }\n}\n"},"contracts/products/mGLO/MGloCustomAggregatorFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"../../feeds/CustomAggregatorV3CompatibleFeed.sol\";\nimport \"./MGloMidasAccessControlRoles.sol\";\n\n/**\n * @title MGloCustomAggregatorFeed\n * @notice AggregatorV3 compatible feed for mGLO,\n * where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract MGloCustomAggregatorFeed is\n    CustomAggregatorV3CompatibleFeed,\n    MGloMidasAccessControlRoles\n{\n    /**\n     * @dev leaving a storage gap for futures updates\n     */\n    uint256[50] private __gap;\n\n    /**\n     * @inheritdoc CustomAggregatorV3CompatibleFeed\n     */\n    function feedAdminRole() public pure override returns (bytes32) {\n        return M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE;\n    }\n}\n"},"contracts/products/mGLO/MGloMidasAccessControlRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\n/**\n * @title MGloMidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors for mGLO contracts\n * @author RedDuck Software\n */\nabstract contract MGloMidasAccessControlRoles {\n    /**\n     * @notice actor that can manage MGloDepositVault\n     */\n    bytes32 public constant M_GLO_DEPOSIT_VAULT_ADMIN_ROLE =\n        keccak256(\"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE\");\n\n    /**\n     * @notice actor that can manage MGloRedemptionVault\n     */\n    bytes32 public constant M_GLO_REDEMPTION_VAULT_ADMIN_ROLE =\n        keccak256(\"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE\");\n\n    /**\n     * @notice actor that can manage MGloCustomAggregatorFeed and MGloDataFeed\n     */\n    bytes32 public constant M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE =\n        keccak256(\"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE\");\n\n    /**\n     * @notice greenlist role for mGLO\n     */\n    bytes32 public constant M_GLOBAL_GREENLISTED_ROLE =\n        keccak256(\"M_GLOBAL_GREENLISTED_ROLE\");\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.9+commit.e5eed63a","compilerSettings":{"metadata":{"useLiteralContent":true},"optimizer":{"runs":200,"enabled":true}},"name":"MGloCustomAggregatorFeed","fullyQualifiedName":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},"abi":[{"name":"AnswerUpdated","type":"event","inputs":[{"name":"data","type":"int256","indexed":true,"internalType":"int256"},{"name":"roundId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"timestamp","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"name":"BLACKLISTED_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"BLACKLIST_OPERATOR_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"GREENLISTED_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"GREENLIST_OPERATOR_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLOBAL_GREENLISTED_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"accessControl","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract MidasAccessControl"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"pure"},{"name":"description","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"feedAdminRole","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"pure"},{"name":"getRoundData","type":"function","inputs":[{"name":"_roundId","type":"uint80","internalType":"uint80"}],"outputs":[{"name":"roundId","type":"uint80","internalType":"uint80"},{"name":"answer","type":"int256","internalType":"int256"},{"name":"startedAt","type":"uint256","internalType":"uint256"},{"name":"updatedAt","type":"uint256","internalType":"uint256"},{"name":"answeredInRound","type":"uint80","internalType":"uint80"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"_accessControl","type":"address","internalType":"address"},{"name":"_minAnswer","type":"int192","internalType":"int192"},{"name":"_maxAnswer","type":"int192","internalType":"int192"},{"name":"_maxAnswerDeviation","type":"uint256","internalType":"uint256"},{"name":"_description","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"lastAnswer","type":"function","inputs":[],"outputs":[{"name":"","type":"int256","internalType":"int256"}],"stateMutability":"view"},{"name":"lastTimestamp","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"latestRound","type":"function","inputs":[],"outputs":[{"name":"","type":"uint80","internalType":"uint80"}],"stateMutability":"view"},{"name":"latestRoundData","type":"function","inputs":[],"outputs":[{"name":"roundId","type":"uint80","internalType":"uint80"},{"name":"answer","type":"int256","internalType":"int256"},{"name":"startedAt","type":"uint256","internalType":"uint256"},{"name":"updatedAt","type":"uint256","internalType":"uint256"},{"name":"answeredInRound","type":"uint80","internalType":"uint80"}],"stateMutability":"view"},{"name":"maxAnswer","type":"function","inputs":[],"outputs":[{"name":"","type":"int192","internalType":"int192"}],"stateMutability":"view"},{"name":"maxAnswerDeviation","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"minAnswer","type":"function","inputs":[],"outputs":[{"name":"","type":"int192","internalType":"int192"}],"stateMutability":"view"},{"name":"setRoundData","type":"function","inputs":[{"name":"_data","type":"int256","internalType":"int256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRoundDataSafe","type":"function","inputs":[{"name":"_data","type":"int256","internalType":"int256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"version","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"}],"metadata":{"compiler":{"version":"0.8.9+commit.e5eed63a"},"language":"Solidity","output":{"abi":[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"int256","name":"data","type":"int256"},{"indexed":true,"internalType":"uint256","name":"roundId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AnswerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"inputs":[],"name":"BLACKLISTED_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BLACKLIST_OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GREENLISTED_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GREENLIST_OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLOBAL_GREENLISTED_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accessControl","outputs":[{"internalType":"contract MidasAccessControl","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"description","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feedAdminRole","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint80","name":"_roundId","type":"uint80"}],"name":"getRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_accessControl","type":"address"},{"internalType":"int192","name":"_minAnswer","type":"int192"},{"internalType":"int192","name":"_maxAnswer","type":"int192"},{"internalType":"uint256","name":"_maxAnswerDeviation","type":"uint256"},{"internalType":"string","name":"_description","type":"string"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastAnswer","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRound","outputs":[{"internalType":"uint80","name":"","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRoundData","outputs":[{"internalType":"uint80","name":"roundId","type":"uint80"},{"internalType":"int256","name":"answer","type":"int256"},{"internalType":"uint256","name":"startedAt","type":"uint256"},{"internalType":"uint256","name":"updatedAt","type":"uint256"},{"internalType":"uint80","name":"answeredInRound","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxAnswer","outputs":[{"internalType":"int192","name":"","type":"int192"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxAnswerDeviation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minAnswer","outputs":[{"internalType":"int192","name":"","type":"int192"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"_data","type":"int256"}],"name":"setRoundData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"_data","type":"int256"}],"name":"setRoundDataSafe","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"}],"devdoc":{"author":"RedDuck Software","kind":"dev","methods":{"feedAdminRole()":{"details":"describes a role, owner of which can update prices in this feed","returns":{"_0":"role descriptor"}},"initialize(address,int192,int192,uint256,string)":{"params":{"_accessControl":"address of MidasAccessControll contract","_description":"init value for `description`","_maxAnswer":"init value for `maxAnswer`. Should be > `_minAnswer`","_maxAnswerDeviation":"init value for `maxAnswerDeviation`","_minAnswer":"init value for `minAnswer`. Should be < `_maxAnswer`"}},"lastAnswer()":{"returns":{"_0":"answer of lattest price submission"}},"lastTimestamp()":{"returns":{"_0":"timestamp of lattest price submission"}},"setRoundData(int256)":{"details":"`_data` should be >= `minAnswer` and <= `maxAnswer`. Function should be called only from address with `feedAdminRole()`","params":{"_data":"data value"}},"setRoundDataSafe(int256)":{"details":"deviation with previous data needs to be <= `maxAnswerDeviation`","params":{"_data":"data value"}}},"stateVariables":{"__gap":{"details":"leaving a storage gap for futures updates"}},"title":"MGloCustomAggregatorFeed","version":1},"userdoc":{"kind":"user","methods":{"BLACKLISTED_ROLE()":{"notice":"actor that is blacklisted"},"BLACKLIST_OPERATOR_ROLE()":{"notice":"actor that can change black list statuses of addresses"},"DEFAULT_ADMIN_ROLE()":{"notice":"admin role"},"GREENLISTED_ROLE()":{"notice":"actor that is greenlisted"},"GREENLIST_OPERATOR_ROLE()":{"notice":"actor that can change green list statuses of addresses"},"M_GLOBAL_GREENLISTED_ROLE()":{"notice":"greenlist role for mGLO"},"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE()":{"notice":"actor that can manage MGloCustomAggregatorFeed and MGloDataFeed"},"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE()":{"notice":"actor that can manage MGloDepositVault"},"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE()":{"notice":"actor that can manage MGloRedemptionVault"},"accessControl()":{"notice":"MidasAccessControl contract address"},"description()":{"notice":"feed description"},"initialize(address,int192,int192,uint256,string)":{"notice":"upgradeable pattern contract`s initializer"},"latestRound()":{"notice":"last round id"},"maxAnswer()":{"notice":"maximal possible answer that feed can return"},"maxAnswerDeviation()":{"notice":"max deviation from lattest price in %"},"minAnswer()":{"notice":"minimal possible answer that feed can return"},"setRoundData(int256)":{"notice":"sets the data for `latestRound` + 1 round id"},"setRoundDataSafe(int256)":{"notice":"works as `setRoundData()`, but also checks the deviation with the lattest submitted data, and that at least 1 hour passed since the lattest submission"}},"notice":"AggregatorV3 compatible feed for mGLO, where price is submitted manually by feed admins","version":1}},"settings":{"compilationTarget":{"contracts/products/mGLO/MGloCustomAggregatorFeed.sol":"MGloCustomAggregatorFeed"},"evmVersion":"london","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n  function decimals() external view returns (uint8);\n\n  function description() external view returns (string memory);\n\n  function version() external view returns (uint256);\n\n  function getRoundData(uint80 _roundId)\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n\n  function latestRoundData()\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n}\n","keccak256":"0x6e6e4b0835904509406b070ee173b5bc8f677c19421b76be38aea3b1b3d30846","license":"MIT"},"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControlUpgradeable.sol\";\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n    function __AccessControl_init() internal onlyInitializing {\n    }\n\n    function __AccessControl_init_unchained() internal onlyInitializing {\n    }\n    struct RoleData {\n        mapping(address => bool) members;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with a standardized message including the required role.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     *\n     * _Available since v4.1._\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n        return _roles[role].members[account];\n    }\n\n    /**\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\n     *\n     * Format of the revert message is described in {_checkRole}.\n     *\n     * _Available since v4.6._\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Revert with a standard message if `account` is missing `role`.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert(\n                string(\n                    abi.encodePacked(\n                        \"AccessControl: account \",\n                        StringsUpgradeable.toHexString(account),\n                        \" is missing role \",\n                        StringsUpgradeable.toHexString(uint256(role), 32)\n                    )\n                )\n            );\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address account) public virtual override {\n        require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event. Note that unlike {grantRole}, this function doesn't perform any\n     * checks on the calling account.\n     *\n     * May emit a {RoleGranted} event.\n     *\n     * [WARNING]\n     * ====\n     * This function should only be called from the constructor when setting\n     * up the initial roles for the system.\n     *\n     * Using this function in any other way is effectively circumventing the admin\n     * system imposed by {AccessControl}.\n     * ====\n     *\n     * NOTE: This function is deprecated in favor of {_grantRole}.\n     */\n    function _setupRole(bytes32 role, address account) internal virtual {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual {\n        if (!hasRole(role, account)) {\n            _roles[role].members[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual {\n        if (hasRole(role, account)) {\n            _roles[role].members[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n","keccak256":"0xfeefb24d068524440e1ba885efdf105d91f83504af3c2d745ffacc4595396831","license":"MIT"},"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n}\n","keccak256":"0xb8f5302f12138c5561362e88a78d061573e6298b7a1a5afe84a1e2c8d4d5aeaa","license":"MIT"},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized != type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n","keccak256":"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794","license":"MIT"},"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    function __Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __Pausable_init_unchained() internal onlyInitializing {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n","keccak256":"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250","license":"MIT"},"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.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 * For a generic mechanism see {ERC20PresetMinterPauser}.\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 ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => 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    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\n        __ERC20_init_unchained(name_, symbol_);\n    }\n\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override 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 override 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 override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override 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 `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\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 `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `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     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` 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    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[45] private __gap;\n}\n","keccak256":"0xd14a627157b9a411d2410713e5dd3a377e9064bd5c194a90748bbf27ea625784","license":"MIT"},"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\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 amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` 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 amount) 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 `amount` as the allowance of `spender` over the 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 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` 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 amount) external returns (bool);\n}\n","keccak256":"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f","license":"MIT"},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20Upgradeable.sol\";\nimport \"../../../security/PausableUpgradeable.sol\";\nimport \"../../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev ERC20 token with pausable token transfers, minting and burning.\n *\n * Useful for scenarios such as preventing trades until the end of an evaluation\n * period, or having an emergency switch for freezing all token transfers in the\n * event of a large bug.\n *\n * IMPORTANT: This contract does not include public pause and unpause functions. In\n * addition to inheriting this contract, you must define both functions, invoking the\n * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate\n * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will\n * make the contract unpausable.\n */\nabstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {\n    function __ERC20Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __ERC20Pausable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {ERC20-_beforeTokenTransfer}.\n     *\n     * Requirements:\n     *\n     * - the contract must not be paused.\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {\n        super._beforeTokenTransfer(from, to, amount);\n\n        require(!paused(), \"ERC20Pausable: token transfer while paused\");\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n","keccak256":"0xf0bd7f71ffae5f0addd375e8511fbf2ad8ca0c9b2606c32d92bdda7d76a7a81c","license":"MIT"},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\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","keccak256":"0x605434219ebbe4653f703640f06969faa5a1d78f0bfef878e5ddbb1ca369ceeb","license":"MIT"},"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n","keccak256":"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422","license":"MIT"},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n","keccak256":"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149","license":"MIT"},"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/MathUpgradeable.sol\";\nimport \"./math/SignedMathUpgradeable.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = MathUpgradeable.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMathUpgradeable.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n","keccak256":"0xb96dc79b65b7c37937919dcdb356a969ce0aa2e8338322bf4dc027a3c9c9a7eb","license":"MIT"},"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n    function __ERC165_init() internal onlyInitializing {\n    }\n\n    function __ERC165_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165Upgradeable).interfaceId;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n","keccak256":"0x9a3b990bd56d139df3e454a9edf1c64668530b5a77fc32eb063bc206f958274a","license":"MIT"},"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n","keccak256":"0xc6cef87559d0aeffdf0a99803de655938a7779ec0a3cd5d4383483ad85565a09","license":"MIT"},"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary MathUpgradeable {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n","keccak256":"0x2bc0007987c229ae7624eb29be6a9b84f6a6a5872f76248b15208b131ea41c4e","license":"MIT"},"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMathUpgradeable {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n","keccak256":"0x88f6b7bba3ee33eeb741f9a0f5bc98b6e6e352d0fe4905377bb328590f84095a","license":"MIT"},"contracts/abstract/MidasInitializable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n/**\n * @title MidasInitializable\n * @author RedDuck Software\n * @notice Base Initializable contract that implements constructor\n * that calls _disableInitializers() to prevent\n * initialization of implementation contract\n */\nabstract contract MidasInitializable is Initializable {\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n}\n","keccak256":"0x33ddc23ee381434633c0458d410958d0363248dc0267c5aa6dcd5624a3849831","license":"MIT"},"contracts/access/MidasAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\nimport \"./MidasAccessControlRoles.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title MidasAccessControl\n * @notice Smart contract that stores all roles for Midas project\n * @author RedDuck Software\n */\ncontract MidasAccessControl is\n    AccessControlUpgradeable,\n    MidasInitializable,\n    MidasAccessControlRoles\n{\n    /**\n     * @notice upgradeable pattern contract`s initializer\n     */\n    function initialize() external initializer {\n        __AccessControl_init();\n        _setupRoles(msg.sender);\n    }\n\n    /**\n     * @notice grant multiple roles to multiple users\n     * in one transaction\n     * @dev length`s of 2 arays should match\n     * @param roles array of bytes32 roles\n     * @param addresses array of user addresses\n     */\n    function grantRoleMult(bytes32[] memory roles, address[] memory addresses)\n        external\n    {\n        require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n\n        for (uint256 i = 0; i < roles.length; i++) {\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\n            _grantRole(roles[i], addresses[i]);\n        }\n    }\n\n    /**\n     * @notice revoke multiple roles from multiple users\n     * in one transaction\n     * @dev length`s of 2 arays should match\n     * @param roles array of bytes32 roles\n     * @param addresses array of user addresses\n     */\n    function revokeRoleMult(bytes32[] memory roles, address[] memory addresses)\n        external\n    {\n        require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n        for (uint256 i = 0; i < roles.length; i++) {\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\n            _revokeRole(roles[i], addresses[i]);\n        }\n    }\n\n    //solhint-disable disable-next-line\n    function renounceRole(bytes32, address) public pure override {\n        revert(\"MAC: Forbidden\");\n    }\n\n    /**\n     * @dev setup roles during the contracts initialization\n     */\n    function _setupRoles(address admin) private {\n        _grantRole(DEFAULT_ADMIN_ROLE, admin);\n\n        _setRoleAdmin(BLACKLISTED_ROLE, BLACKLIST_OPERATOR_ROLE);\n        _setRoleAdmin(GREENLISTED_ROLE, GREENLIST_OPERATOR_ROLE);\n    }\n}\n","keccak256":"0xc5d361b87241702bf495381db842effafd2fe10231ad5ee6d0eac182029622e0","license":"MIT"},"contracts/access/MidasAccessControlRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\n/**\n * @title MidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors\n * @author RedDuck Software\n */\nabstract contract MidasAccessControlRoles {\n    /**\n     * @notice actor that can change green list statuses of addresses\n     */\n    bytes32 public constant GREENLIST_OPERATOR_ROLE =\n        keccak256(\"GREENLIST_OPERATOR_ROLE\");\n\n    /**\n     * @notice actor that can change black list statuses of addresses\n     */\n    bytes32 public constant BLACKLIST_OPERATOR_ROLE =\n        keccak256(\"BLACKLIST_OPERATOR_ROLE\");\n\n    /**\n     * @notice actor that is greenlisted\n     */\n    bytes32 public constant GREENLISTED_ROLE = keccak256(\"GREENLISTED_ROLE\");\n\n    /**\n     * @notice actor that is blacklisted\n     */\n    bytes32 public constant BLACKLISTED_ROLE = keccak256(\"BLACKLISTED_ROLE\");\n}\n","keccak256":"0x797d1e5236716608a0e2754dcd34099ef8d3bddba8557d2a0414daf47490e126","license":"MIT"},"contracts/access/WithMidasAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"./MidasAccessControl.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title WithMidasAccessControl\n * @notice Base contract that consumes MidasAccessControl\n * @author RedDuck Software\n */\nabstract contract WithMidasAccessControl is\n    MidasInitializable,\n    MidasAccessControlRoles\n{\n    /**\n     * @notice admin role\n     */\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @notice MidasAccessControl contract address\n     */\n    MidasAccessControl public accessControl;\n\n    /**\n     * @dev leaving a storage gap for futures updates\n     */\n    uint256[50] private __gap;\n\n    /**\n     * @dev checks that given `address` have `role`\n     */\n    modifier onlyRole(bytes32 role, address account) {\n        _onlyRole(role, account);\n        _;\n    }\n\n    /**\n     * @dev checks that given `address` do not have `role`\n     */\n    modifier onlyNotRole(bytes32 role, address account) {\n        _onlyNotRole(role, account);\n        _;\n    }\n\n    /**\n     * @dev upgradeable pattern contract`s initializer\n     */\n    // solhint-disable func-name-mixedcase\n    function __WithMidasAccessControl_init(address _accessControl)\n        internal\n        onlyInitializing\n    {\n        require(_accessControl != address(0), \"zero address\");\n        accessControl = MidasAccessControl(_accessControl);\n    }\n\n    /**\n     * @dev checks that given `address` have `role`\n     */\n    function _onlyRole(bytes32 role, address account) internal view {\n        require(accessControl.hasRole(role, account), \"WMAC: hasnt role\");\n    }\n\n    /**\n     * @dev checks that given `address` do not have `role`\n     */\n    function _onlyNotRole(bytes32 role, address account) internal view {\n        require(!accessControl.hasRole(role, account), \"WMAC: has role\");\n    }\n}\n","keccak256":"0xefec8ab41dcc890d353e2e7dedbe034a489f6ea348bda52ca3cb123c813996af","license":"MIT"},"contracts/feeds/CustomAggregatorV3CompatibleFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\nimport \"../interfaces/IDataFeed.sol\";\n\n/**\n * @title CustomAggregatorV3CompatibleFeed\n * @notice AggregatorV3 compatible feed, where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract CustomAggregatorV3CompatibleFeed is\n    WithMidasAccessControl,\n    AggregatorV3Interface\n{\n    struct RoundData {\n        uint80 roundId;\n        int256 answer;\n        uint256 startedAt;\n        uint256 updatedAt;\n        uint80 answeredInRound;\n    }\n\n    /**\n     * @notice feed description\n     */\n    string public override description;\n\n    /**\n     * @notice last round id\n     */\n    uint80 public latestRound;\n\n    /**\n     * @notice max deviation from lattest price in %\n     * @dev 10 ** decimals() is a percentage precision\n     */\n    uint256 public maxAnswerDeviation;\n\n    /**\n     * @notice minimal possible answer that feed can return\n     */\n    int192 public minAnswer;\n\n    /**\n     * @notice maximal possible answer that feed can return\n     */\n    int192 public maxAnswer;\n\n    /**\n     * @dev holds round information\n     */\n    mapping(uint80 => RoundData) private _roundData;\n\n    event AnswerUpdated(\n        int256 indexed data,\n        uint256 indexed roundId,\n        uint256 indexed timestamp\n    );\n\n    /**\n     * @dev checks that msg.sender do have a feedAdminRole() role\n     */\n    modifier onlyAggregatorAdmin() {\n        _onlyRole(feedAdminRole(), msg.sender);\n        _;\n    }\n\n    /**\n     * @notice upgradeable pattern contract`s initializer\n     * @param _accessControl address of MidasAccessControll contract\n     * @param _minAnswer init value for `minAnswer`. Should be < `_maxAnswer`\n     * @param _maxAnswer init value for `maxAnswer`. Should be > `_minAnswer`\n     * @param _maxAnswerDeviation init value for `maxAnswerDeviation`\n     * @param _description init value for `description`\n     */\n    function initialize(\n        address _accessControl,\n        int192 _minAnswer,\n        int192 _maxAnswer,\n        uint256 _maxAnswerDeviation,\n        string calldata _description\n    ) public virtual initializer {\n        __WithMidasAccessControl_init(_accessControl);\n\n        require(_minAnswer < _maxAnswer, \"CA: !min/max\");\n        require(\n            _maxAnswerDeviation <= 100 * (10**decimals()),\n            \"CA: !max deviation\"\n        );\n\n        minAnswer = _minAnswer;\n        maxAnswer = _maxAnswer;\n        maxAnswerDeviation = _maxAnswerDeviation;\n        description = _description;\n    }\n\n    /**\n     * @notice works as `setRoundData()`, but also checks the\n     * deviation with the lattest submitted data, and that at least\n     * 1 hour passed since the lattest submission\n     * @dev deviation with previous data needs to be <= `maxAnswerDeviation`\n     * @param _data data value\n     */\n    function setRoundDataSafe(int256 _data) external {\n        uint256 _lastUpdatedAt = lastTimestamp();\n\n        if (_lastUpdatedAt != 0) {\n            uint256 deviation = _getDeviation(lastAnswer(), _data);\n            require(deviation <= maxAnswerDeviation, \"CA: !deviation\");\n        }\n\n        require(\n            block.timestamp - _lastUpdatedAt > 1 hours,\n            \"CA: not enough time passed\"\n        );\n\n        return setRoundData(_data);\n    }\n\n    /**\n     * @notice sets the data for `latestRound` + 1 round id\n     * @dev `_data` should be >= `minAnswer` and <= `maxAnswer`.\n     * Function should be called only from address with `feedAdminRole()`\n     * @param _data data value\n     */\n    function setRoundData(int256 _data) public onlyAggregatorAdmin {\n        require(\n            _data >= minAnswer && _data <= maxAnswer,\n            \"CA: out of [min;max]\"\n        );\n\n        uint80 roundId = latestRound + 1;\n\n        _roundData[roundId] = RoundData({\n            roundId: roundId,\n            answer: _data,\n            startedAt: block.timestamp,\n            updatedAt: block.timestamp,\n            answeredInRound: roundId\n        });\n\n        latestRound = roundId;\n\n        emit AnswerUpdated(_data, roundId, block.timestamp);\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function latestRoundData()\n        external\n        view\n        returns (\n            uint80 roundId,\n            int256 answer,\n            uint256 startedAt,\n            uint256 updatedAt,\n            uint80 answeredInRound\n        )\n    {\n        return getRoundData(latestRound);\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function version() external pure returns (uint256) {\n        return 1;\n    }\n\n    /**\n     * @return answer of lattest price submission\n     */\n    function lastAnswer() public view returns (int256) {\n        return _roundData[latestRound].answer;\n    }\n\n    /**\n     * @return timestamp of lattest price submission\n     */\n    function lastTimestamp() public view returns (uint256) {\n        return _roundData[latestRound].updatedAt;\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function getRoundData(uint80 _roundId)\n        public\n        view\n        returns (\n            uint80 roundId,\n            int256 answer,\n            uint256 startedAt,\n            uint256 updatedAt,\n            uint80 answeredInRound\n        )\n    {\n        RoundData memory roundData = _roundData[_roundId];\n        return (\n            roundData.roundId,\n            roundData.answer,\n            roundData.startedAt,\n            roundData.updatedAt,\n            roundData.answeredInRound\n        );\n    }\n\n    /**\n     * @dev describes a role, owner of which can update prices in this feed\n     * @return role descriptor\n     */\n    function feedAdminRole() public view virtual returns (bytes32) {\n        return DEFAULT_ADMIN_ROLE;\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function decimals() public pure returns (uint8) {\n        return 8;\n    }\n\n    /**\n     * @dev calculates a deviation in % between `_lastPrice` and `_newPrice`\n     * @return deviation in `10 ** decimals()` precision\n     */\n    function _getDeviation(int256 _lastPrice, int256 _newPrice)\n        internal\n        pure\n        returns (uint256)\n    {\n        if (_newPrice == 0) return 100 * 10**decimals();\n        int256 one = int256(10**decimals());\n        int256 priceDif = _newPrice - _lastPrice;\n        int256 deviation = (priceDif * one * 100) / _lastPrice;\n        deviation = deviation < 0 ? deviation * -1 : deviation;\n        return uint256(deviation);\n    }\n}\n","keccak256":"0x7af534ae031ea188b70bc28acab2d900468ee70ccaacdf8541a4c58c5f775024","license":"MIT"},"contracts/interfaces/IDataFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\n\n/**\n * @title IDataFeed\n * @author RedDuck Software\n */\ninterface IDataFeed {\n    /**\n     * @notice fetches answer from aggregator\n     * and converts it to the base18 precision\n     * @return answer fetched aggregator answer\n     */\n    function getDataInBase18() external view returns (uint256 answer);\n\n    /**\n     * @dev describes a role, owner of which can manage this feed\n     * @return role descriptor\n     */\n    function feedAdminRole() external view returns (bytes32);\n}\n","keccak256":"0x9fa7605e7391d8fd6f377f45fd33f58eec1cfc97749aec33780c597ec095c706","license":"MIT"},"contracts/libraries/DecimalsCorrectionLibrary.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\n/**\n * @title DecimalsCorrectionLibrary\n * @author RedDuck Software\n */\nlibrary DecimalsCorrectionLibrary {\n    /**\n     * @dev converts `originalAmount` with `originalDecimals` into\n     * amount with `decidedDecimals`\n     * @param originalAmount amount to convert\n     * @param originalDecimals decimals of the original amount\n     * @param decidedDecimals decimals for the output amount\n     * @return amount converted amount with `decidedDecimals`\n     */\n    function convert(\n        uint256 originalAmount,\n        uint256 originalDecimals,\n        uint256 decidedDecimals\n    ) internal pure returns (uint256) {\n        if (originalAmount == 0) return 0;\n        if (originalDecimals == decidedDecimals) return originalAmount;\n\n        uint256 adjustedAmount;\n\n        if (originalDecimals > decidedDecimals) {\n            adjustedAmount =\n                originalAmount /\n                (10**(originalDecimals - decidedDecimals));\n        } else {\n            adjustedAmount =\n                originalAmount *\n                (10**(decidedDecimals - originalDecimals));\n        }\n\n        return adjustedAmount;\n    }\n\n    /**\n     * @dev converts `originalAmount` with decimals 18 into\n     * amount with `decidedDecimals`\n     * @param originalAmount amount to convert\n     * @param decidedDecimals decimals for the output amount\n     * @return amount converted amount with `decidedDecimals`\n     */\n    function convertFromBase18(uint256 originalAmount, uint256 decidedDecimals)\n        internal\n        pure\n        returns (uint256)\n    {\n        return convert(originalAmount, 18, decidedDecimals);\n    }\n\n    /**\n     * @dev converts `originalAmount` with `originalDecimals` into\n     * amount with decimals 18\n     * @param originalAmount amount to convert\n     * @param originalDecimals decimals of the original amount\n     * @return amount converted amount with 18 decimals\n     */\n    function convertToBase18(uint256 originalAmount, uint256 originalDecimals)\n        internal\n        pure\n        returns (uint256)\n    {\n        return convert(originalAmount, originalDecimals, 18);\n    }\n}\n","keccak256":"0x5d1b64b11adda6ea2ab56bb662706a46f76d8225c8db3c429f03a30f5e77a7aa","license":"MIT"},"contracts/products/mGLO/MGloCustomAggregatorFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"../../feeds/CustomAggregatorV3CompatibleFeed.sol\";\nimport \"./MGloMidasAccessControlRoles.sol\";\n\n/**\n * @title MGloCustomAggregatorFeed\n * @notice AggregatorV3 compatible feed for mGLO,\n * where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract MGloCustomAggregatorFeed is\n    CustomAggregatorV3CompatibleFeed,\n    MGloMidasAccessControlRoles\n{\n    /**\n     * @dev leaving a storage gap for futures updates\n     */\n    uint256[50] private __gap;\n\n    /**\n     * @inheritdoc CustomAggregatorV3CompatibleFeed\n     */\n    function feedAdminRole() public pure override returns (bytes32) {\n        return M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE;\n    }\n}\n","keccak256":"0x5ce4bda1de25e2d01808996d67f297a9ac7fab7aff0fbcafb2cef9bb2abfc7e2","license":"MIT"},"contracts/products/mGLO/MGloMidasAccessControlRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\n/**\n * @title MGloMidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors for mGLO contracts\n * @author RedDuck Software\n */\nabstract contract MGloMidasAccessControlRoles {\n    /**\n     * @notice actor that can manage MGloDepositVault\n     */\n    bytes32 public constant M_GLO_DEPOSIT_VAULT_ADMIN_ROLE =\n        keccak256(\"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE\");\n\n    /**\n     * @notice actor that can manage MGloRedemptionVault\n     */\n    bytes32 public constant M_GLO_REDEMPTION_VAULT_ADMIN_ROLE =\n        keccak256(\"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE\");\n\n    /**\n     * @notice actor that can manage MGloCustomAggregatorFeed and MGloDataFeed\n     */\n    bytes32 public constant M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE =\n        keccak256(\"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE\");\n\n    /**\n     * @notice greenlist role for mGLO\n     */\n    bytes32 public constant M_GLOBAL_GREENLISTED_ROLE =\n        keccak256(\"M_GLOBAL_GREENLISTED_ROLE\");\n}\n","keccak256":"0x15b0faa8feb2a18a31b4503d72622b194117da0098535adb1bebda876a80f995","license":"MIT"}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_int192":{"label":"int192","encoding":"inplace","numberOfBytes":"24"},"t_int256":{"label":"int256","encoding":"inplace","numberOfBytes":"32"},"t_uint80":{"label":"uint80","encoding":"inplace","numberOfBytes":"10"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_array(t_uint256)50_storage":{"base":"t_uint256","label":"uint256[50]","encoding":"inplace","numberOfBytes":"1600"},"t_struct(RoundData)3499_storage":{"label":"struct CustomAggregatorV3CompatibleFeed.RoundData","members":[{"slot":"0","type":"t_uint80","astId":3490,"label":"roundId","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"1","type":"t_int256","astId":3492,"label":"answer","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"2","type":"t_uint256","astId":3494,"label":"startedAt","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"3","type":"t_uint256","astId":3496,"label":"updatedAt","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"4","type":"t_uint80","astId":3498,"label":"answeredInRound","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"}],"encoding":"inplace","numberOfBytes":"160"},"t_contract(MidasAccessControl)3335":{"label":"contract MidasAccessControl","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_uint80,t_struct(RoundData)3499_storage)":{"key":"t_uint80","label":"mapping(uint80 => struct CustomAggregatorV3CompatibleFeed.RoundData)","value":"t_struct(RoundData)3499_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint8","astId":461,"label":"_initialized","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"0","type":"t_bool","astId":464,"label":"_initializing","offset":1,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"0","type":"t_contract(MidasAccessControl)3335","astId":3380,"label":"accessControl","offset":2,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"1","type":"t_array(t_uint256)50_storage","astId":3385,"label":"__gap","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"51","type":"t_string_storage","astId":3503,"label":"description","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"52","type":"t_uint80","astId":3506,"label":"latestRound","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"53","type":"t_uint256","astId":3509,"label":"maxAnswerDeviation","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"54","type":"t_int192","astId":3512,"label":"minAnswer","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"55","type":"t_int192","astId":3515,"label":"maxAnswer","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"56","type":"t_mapping(t_uint80,t_struct(RoundData)3499_storage)","astId":3521,"label":"_roundData","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"57","type":"t_array(t_uint256)50_storage","astId":4000,"label":"__gap","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"AggregatorV3 compatible feed for mGLO, where price is submitted manually by feed admins","methods":{"maxAnswer()":{"notice":"maximal possible answer that feed can return"},"minAnswer()":{"notice":"minimal possible answer that feed can return"},"description()":{"notice":"feed description"},"latestRound()":{"notice":"last round id"},"accessControl()":{"notice":"MidasAccessControl contract address"},"BLACKLISTED_ROLE()":{"notice":"actor that is blacklisted"},"GREENLISTED_ROLE()":{"notice":"actor that is greenlisted"},"DEFAULT_ADMIN_ROLE()":{"notice":"admin role"},"maxAnswerDeviation()":{"notice":"max deviation from lattest price in %"},"setRoundData(int256)":{"notice":"sets the data for `latestRound` + 1 round id"},"setRoundDataSafe(int256)":{"notice":"works as `setRoundData()`, but also checks the deviation with the lattest submitted data, and that at least 1 hour passed since the lattest submission"},"BLACKLIST_OPERATOR_ROLE()":{"notice":"actor that can change black list statuses of addresses"},"GREENLIST_OPERATOR_ROLE()":{"notice":"actor that can change green list statuses of addresses"},"M_GLOBAL_GREENLISTED_ROLE()":{"notice":"greenlist role for mGLO"},"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE()":{"notice":"actor that can manage MGloDepositVault"},"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE()":{"notice":"actor that can manage MGloRedemptionVault"},"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE()":{"notice":"actor that can manage MGloCustomAggregatorFeed and MGloDataFeed"},"initialize(address,int192,int192,uint256,string)":{"notice":"upgradeable pattern contract`s initializer"}},"version":1},"devdoc":{"kind":"dev","title":"MGloCustomAggregatorFeed","author":"RedDuck Software","methods":{"lastAnswer()":{"returns":{"_0":"answer of lattest price submission"}},"feedAdminRole()":{"details":"describes a role, owner of which can update prices in this feed","returns":{"_0":"role descriptor"}},"lastTimestamp()":{"returns":{"_0":"timestamp of lattest price submission"}},"setRoundData(int256)":{"params":{"_data":"data value"},"details":"`_data` should be >= `minAnswer` and <= `maxAnswer`. Function should be called only from address with `feedAdminRole()`"},"setRoundDataSafe(int256)":{"params":{"_data":"data value"},"details":"deviation with previous data needs to be <= `maxAnswerDeviation`"},"initialize(address,int192,int192,uint256,string)":{"params":{"_maxAnswer":"init value for `maxAnswer`. Should be > `_minAnswer`","_minAnswer":"init value for `minAnswer`. Should be < `_maxAnswer`","_description":"init value for `description`","_accessControl":"address of MidasAccessControll contract","_maxAnswerDeviation":"init value for `maxAnswerDeviation`"}}},"version":1,"stateVariables":{"__gap":{"details":"leaving a storage gap for futures updates"}}},"sourceIds":{"contracts/interfaces/IDataFeed.sol":{"id":21},"contracts/access/MidasAccessControl.sol":{"id":17},"contracts/abstract/MidasInitializable.sol":{"id":16},"contracts/access/WithMidasAccessControl.sol":{"id":19},"contracts/access/MidasAccessControlRoles.sol":{"id":18},"contracts/libraries/DecimalsCorrectionLibrary.sol":{"id":22},"contracts/feeds/CustomAggregatorV3CompatibleFeed.sol":{"id":20},"contracts/products/mGLO/MGloCustomAggregatorFeed.sol":{"id":23},"contracts/products/mGLO/MGloMidasAccessControlRoles.sol":{"id":24},"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol":{"id":9},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"id":10},"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol":{"id":11},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"id":3},"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol":{"id":0},"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol":{"id":14},"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol":{"id":4},"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol":{"id":5},"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol":{"id":6},"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol":{"id":1},"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol":{"id":2},"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol":{"id":15},"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol":{"id":12},"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol":{"id":13},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol":{"id":7},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol":{"id":8}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/interfaces/IDataFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\n\n/**\n * @title IDataFeed\n * @author RedDuck Software\n */\ninterface IDataFeed {\n    /**\n     * @notice fetches answer from aggregator\n     * and converts it to the base18 precision\n     * @return answer fetched aggregator answer\n     */\n    function getDataInBase18() external view returns (uint256 answer);\n\n    /**\n     * @dev describes a role, owner of which can manage this feed\n     * @return role descriptor\n     */\n    function feedAdminRole() external view returns (bytes32);\n}\n"},"contracts/access/MidasAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\nimport \"./MidasAccessControlRoles.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title MidasAccessControl\n * @notice Smart contract that stores all roles for Midas project\n * @author RedDuck Software\n */\ncontract MidasAccessControl is\n    AccessControlUpgradeable,\n    MidasInitializable,\n    MidasAccessControlRoles\n{\n    /**\n     * @notice upgradeable pattern contract`s initializer\n     */\n    function initialize() external initializer {\n        __AccessControl_init();\n        _setupRoles(msg.sender);\n    }\n\n    /**\n     * @notice grant multiple roles to multiple users\n     * in one transaction\n     * @dev length`s of 2 arays should match\n     * @param roles array of bytes32 roles\n     * @param addresses array of user addresses\n     */\n    function grantRoleMult(bytes32[] memory roles, address[] memory addresses)\n        external\n    {\n        require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n\n        for (uint256 i = 0; i < roles.length; i++) {\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\n            _grantRole(roles[i], addresses[i]);\n        }\n    }\n\n    /**\n     * @notice revoke multiple roles from multiple users\n     * in one transaction\n     * @dev length`s of 2 arays should match\n     * @param roles array of bytes32 roles\n     * @param addresses array of user addresses\n     */\n    function revokeRoleMult(bytes32[] memory roles, address[] memory addresses)\n        external\n    {\n        require(roles.length == addresses.length, \"MAC: mismatch arrays\");\n        for (uint256 i = 0; i < roles.length; i++) {\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\n            _revokeRole(roles[i], addresses[i]);\n        }\n    }\n\n    //solhint-disable disable-next-line\n    function renounceRole(bytes32, address) public pure override {\n        revert(\"MAC: Forbidden\");\n    }\n\n    /**\n     * @dev setup roles during the contracts initialization\n     */\n    function _setupRoles(address admin) private {\n        _grantRole(DEFAULT_ADMIN_ROLE, admin);\n\n        _setRoleAdmin(BLACKLISTED_ROLE, BLACKLIST_OPERATOR_ROLE);\n        _setRoleAdmin(GREENLISTED_ROLE, GREENLIST_OPERATOR_ROLE);\n    }\n}\n"},"contracts/abstract/MidasInitializable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\";\n\n/**\n * @title MidasInitializable\n * @author RedDuck Software\n * @notice Base Initializable contract that implements constructor\n * that calls _disableInitializers() to prevent\n * initialization of implementation contract\n */\nabstract contract MidasInitializable is Initializable {\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n}\n"},"contracts/access/WithMidasAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\nimport \"./MidasAccessControl.sol\";\nimport \"../abstract/MidasInitializable.sol\";\n\n/**\n * @title WithMidasAccessControl\n * @notice Base contract that consumes MidasAccessControl\n * @author RedDuck Software\n */\nabstract contract WithMidasAccessControl is\n    MidasInitializable,\n    MidasAccessControlRoles\n{\n    /**\n     * @notice admin role\n     */\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @notice MidasAccessControl contract address\n     */\n    MidasAccessControl public accessControl;\n\n    /**\n     * @dev leaving a storage gap for futures updates\n     */\n    uint256[50] private __gap;\n\n    /**\n     * @dev checks that given `address` have `role`\n     */\n    modifier onlyRole(bytes32 role, address account) {\n        _onlyRole(role, account);\n        _;\n    }\n\n    /**\n     * @dev checks that given `address` do not have `role`\n     */\n    modifier onlyNotRole(bytes32 role, address account) {\n        _onlyNotRole(role, account);\n        _;\n    }\n\n    /**\n     * @dev upgradeable pattern contract`s initializer\n     */\n    // solhint-disable func-name-mixedcase\n    function __WithMidasAccessControl_init(address _accessControl)\n        internal\n        onlyInitializing\n    {\n        require(_accessControl != address(0), \"zero address\");\n        accessControl = MidasAccessControl(_accessControl);\n    }\n\n    /**\n     * @dev checks that given `address` have `role`\n     */\n    function _onlyRole(bytes32 role, address account) internal view {\n        require(accessControl.hasRole(role, account), \"WMAC: hasnt role\");\n    }\n\n    /**\n     * @dev checks that given `address` do not have `role`\n     */\n    function _onlyNotRole(bytes32 role, address account) internal view {\n        require(!accessControl.hasRole(role, account), \"WMAC: has role\");\n    }\n}\n"},"contracts/access/MidasAccessControlRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.9;\n\n/**\n * @title MidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors\n * @author RedDuck Software\n */\nabstract contract MidasAccessControlRoles {\n    /**\n     * @notice actor that can change green list statuses of addresses\n     */\n    bytes32 public constant GREENLIST_OPERATOR_ROLE =\n        keccak256(\"GREENLIST_OPERATOR_ROLE\");\n\n    /**\n     * @notice actor that can change black list statuses of addresses\n     */\n    bytes32 public constant BLACKLIST_OPERATOR_ROLE =\n        keccak256(\"BLACKLIST_OPERATOR_ROLE\");\n\n    /**\n     * @notice actor that is greenlisted\n     */\n    bytes32 public constant GREENLISTED_ROLE = keccak256(\"GREENLISTED_ROLE\");\n\n    /**\n     * @notice actor that is blacklisted\n     */\n    bytes32 public constant BLACKLISTED_ROLE = keccak256(\"BLACKLISTED_ROLE\");\n}\n"},"contracts/libraries/DecimalsCorrectionLibrary.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\n/**\n * @title DecimalsCorrectionLibrary\n * @author RedDuck Software\n */\nlibrary DecimalsCorrectionLibrary {\n    /**\n     * @dev converts `originalAmount` with `originalDecimals` into\n     * amount with `decidedDecimals`\n     * @param originalAmount amount to convert\n     * @param originalDecimals decimals of the original amount\n     * @param decidedDecimals decimals for the output amount\n     * @return amount converted amount with `decidedDecimals`\n     */\n    function convert(\n        uint256 originalAmount,\n        uint256 originalDecimals,\n        uint256 decidedDecimals\n    ) internal pure returns (uint256) {\n        if (originalAmount == 0) return 0;\n        if (originalDecimals == decidedDecimals) return originalAmount;\n\n        uint256 adjustedAmount;\n\n        if (originalDecimals > decidedDecimals) {\n            adjustedAmount =\n                originalAmount /\n                (10**(originalDecimals - decidedDecimals));\n        } else {\n            adjustedAmount =\n                originalAmount *\n                (10**(decidedDecimals - originalDecimals));\n        }\n\n        return adjustedAmount;\n    }\n\n    /**\n     * @dev converts `originalAmount` with decimals 18 into\n     * amount with `decidedDecimals`\n     * @param originalAmount amount to convert\n     * @param decidedDecimals decimals for the output amount\n     * @return amount converted amount with `decidedDecimals`\n     */\n    function convertFromBase18(uint256 originalAmount, uint256 decidedDecimals)\n        internal\n        pure\n        returns (uint256)\n    {\n        return convert(originalAmount, 18, decidedDecimals);\n    }\n\n    /**\n     * @dev converts `originalAmount` with `originalDecimals` into\n     * amount with decimals 18\n     * @param originalAmount amount to convert\n     * @param originalDecimals decimals of the original amount\n     * @return amount converted amount with 18 decimals\n     */\n    function convertToBase18(uint256 originalAmount, uint256 originalDecimals)\n        internal\n        pure\n        returns (uint256)\n    {\n        return convert(originalAmount, originalDecimals, 18);\n    }\n}\n"},"contracts/feeds/CustomAggregatorV3CompatibleFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\";\nimport \"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\";\n\nimport \"../access/WithMidasAccessControl.sol\";\nimport \"../libraries/DecimalsCorrectionLibrary.sol\";\nimport \"../interfaces/IDataFeed.sol\";\n\n/**\n * @title CustomAggregatorV3CompatibleFeed\n * @notice AggregatorV3 compatible feed, where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract CustomAggregatorV3CompatibleFeed is\n    WithMidasAccessControl,\n    AggregatorV3Interface\n{\n    struct RoundData {\n        uint80 roundId;\n        int256 answer;\n        uint256 startedAt;\n        uint256 updatedAt;\n        uint80 answeredInRound;\n    }\n\n    /**\n     * @notice feed description\n     */\n    string public override description;\n\n    /**\n     * @notice last round id\n     */\n    uint80 public latestRound;\n\n    /**\n     * @notice max deviation from lattest price in %\n     * @dev 10 ** decimals() is a percentage precision\n     */\n    uint256 public maxAnswerDeviation;\n\n    /**\n     * @notice minimal possible answer that feed can return\n     */\n    int192 public minAnswer;\n\n    /**\n     * @notice maximal possible answer that feed can return\n     */\n    int192 public maxAnswer;\n\n    /**\n     * @dev holds round information\n     */\n    mapping(uint80 => RoundData) private _roundData;\n\n    event AnswerUpdated(\n        int256 indexed data,\n        uint256 indexed roundId,\n        uint256 indexed timestamp\n    );\n\n    /**\n     * @dev checks that msg.sender do have a feedAdminRole() role\n     */\n    modifier onlyAggregatorAdmin() {\n        _onlyRole(feedAdminRole(), msg.sender);\n        _;\n    }\n\n    /**\n     * @notice upgradeable pattern contract`s initializer\n     * @param _accessControl address of MidasAccessControll contract\n     * @param _minAnswer init value for `minAnswer`. Should be < `_maxAnswer`\n     * @param _maxAnswer init value for `maxAnswer`. Should be > `_minAnswer`\n     * @param _maxAnswerDeviation init value for `maxAnswerDeviation`\n     * @param _description init value for `description`\n     */\n    function initialize(\n        address _accessControl,\n        int192 _minAnswer,\n        int192 _maxAnswer,\n        uint256 _maxAnswerDeviation,\n        string calldata _description\n    ) public virtual initializer {\n        __WithMidasAccessControl_init(_accessControl);\n\n        require(_minAnswer < _maxAnswer, \"CA: !min/max\");\n        require(\n            _maxAnswerDeviation <= 100 * (10**decimals()),\n            \"CA: !max deviation\"\n        );\n\n        minAnswer = _minAnswer;\n        maxAnswer = _maxAnswer;\n        maxAnswerDeviation = _maxAnswerDeviation;\n        description = _description;\n    }\n\n    /**\n     * @notice works as `setRoundData()`, but also checks the\n     * deviation with the lattest submitted data, and that at least\n     * 1 hour passed since the lattest submission\n     * @dev deviation with previous data needs to be <= `maxAnswerDeviation`\n     * @param _data data value\n     */\n    function setRoundDataSafe(int256 _data) external {\n        uint256 _lastUpdatedAt = lastTimestamp();\n\n        if (_lastUpdatedAt != 0) {\n            uint256 deviation = _getDeviation(lastAnswer(), _data);\n            require(deviation <= maxAnswerDeviation, \"CA: !deviation\");\n        }\n\n        require(\n            block.timestamp - _lastUpdatedAt > 1 hours,\n            \"CA: not enough time passed\"\n        );\n\n        return setRoundData(_data);\n    }\n\n    /**\n     * @notice sets the data for `latestRound` + 1 round id\n     * @dev `_data` should be >= `minAnswer` and <= `maxAnswer`.\n     * Function should be called only from address with `feedAdminRole()`\n     * @param _data data value\n     */\n    function setRoundData(int256 _data) public onlyAggregatorAdmin {\n        require(\n            _data >= minAnswer && _data <= maxAnswer,\n            \"CA: out of [min;max]\"\n        );\n\n        uint80 roundId = latestRound + 1;\n\n        _roundData[roundId] = RoundData({\n            roundId: roundId,\n            answer: _data,\n            startedAt: block.timestamp,\n            updatedAt: block.timestamp,\n            answeredInRound: roundId\n        });\n\n        latestRound = roundId;\n\n        emit AnswerUpdated(_data, roundId, block.timestamp);\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function latestRoundData()\n        external\n        view\n        returns (\n            uint80 roundId,\n            int256 answer,\n            uint256 startedAt,\n            uint256 updatedAt,\n            uint80 answeredInRound\n        )\n    {\n        return getRoundData(latestRound);\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function version() external pure returns (uint256) {\n        return 1;\n    }\n\n    /**\n     * @return answer of lattest price submission\n     */\n    function lastAnswer() public view returns (int256) {\n        return _roundData[latestRound].answer;\n    }\n\n    /**\n     * @return timestamp of lattest price submission\n     */\n    function lastTimestamp() public view returns (uint256) {\n        return _roundData[latestRound].updatedAt;\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function getRoundData(uint80 _roundId)\n        public\n        view\n        returns (\n            uint80 roundId,\n            int256 answer,\n            uint256 startedAt,\n            uint256 updatedAt,\n            uint80 answeredInRound\n        )\n    {\n        RoundData memory roundData = _roundData[_roundId];\n        return (\n            roundData.roundId,\n            roundData.answer,\n            roundData.startedAt,\n            roundData.updatedAt,\n            roundData.answeredInRound\n        );\n    }\n\n    /**\n     * @dev describes a role, owner of which can update prices in this feed\n     * @return role descriptor\n     */\n    function feedAdminRole() public view virtual returns (bytes32) {\n        return DEFAULT_ADMIN_ROLE;\n    }\n\n    /**\n     * @inheritdoc AggregatorV3Interface\n     */\n    function decimals() public pure returns (uint8) {\n        return 8;\n    }\n\n    /**\n     * @dev calculates a deviation in % between `_lastPrice` and `_newPrice`\n     * @return deviation in `10 ** decimals()` precision\n     */\n    function _getDeviation(int256 _lastPrice, int256 _newPrice)\n        internal\n        pure\n        returns (uint256)\n    {\n        if (_newPrice == 0) return 100 * 10**decimals();\n        int256 one = int256(10**decimals());\n        int256 priceDif = _newPrice - _lastPrice;\n        int256 deviation = (priceDif * one * 100) / _lastPrice;\n        deviation = deviation < 0 ? deviation * -1 : deviation;\n        return uint256(deviation);\n    }\n}\n"},"contracts/products/mGLO/MGloCustomAggregatorFeed.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\nimport \"../../feeds/CustomAggregatorV3CompatibleFeed.sol\";\nimport \"./MGloMidasAccessControlRoles.sol\";\n\n/**\n * @title MGloCustomAggregatorFeed\n * @notice AggregatorV3 compatible feed for mGLO,\n * where price is submitted manually by feed admins\n * @author RedDuck Software\n */\ncontract MGloCustomAggregatorFeed is\n    CustomAggregatorV3CompatibleFeed,\n    MGloMidasAccessControlRoles\n{\n    /**\n     * @dev leaving a storage gap for futures updates\n     */\n    uint256[50] private __gap;\n\n    /**\n     * @inheritdoc CustomAggregatorV3CompatibleFeed\n     */\n    function feedAdminRole() public pure override returns (bytes32) {\n        return M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE;\n    }\n}\n"},"contracts/products/mGLO/MGloMidasAccessControlRoles.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.9;\n\n/**\n * @title MGloMidasAccessControlRoles\n * @notice Base contract that stores all roles descriptors for mGLO contracts\n * @author RedDuck Software\n */\nabstract contract MGloMidasAccessControlRoles {\n    /**\n     * @notice actor that can manage MGloDepositVault\n     */\n    bytes32 public constant M_GLO_DEPOSIT_VAULT_ADMIN_ROLE =\n        keccak256(\"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE\");\n\n    /**\n     * @notice actor that can manage MGloRedemptionVault\n     */\n    bytes32 public constant M_GLO_REDEMPTION_VAULT_ADMIN_ROLE =\n        keccak256(\"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE\");\n\n    /**\n     * @notice actor that can manage MGloCustomAggregatorFeed and MGloDataFeed\n     */\n    bytes32 public constant M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE =\n        keccak256(\"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE\");\n\n    /**\n     * @notice greenlist role for mGLO\n     */\n    bytes32 public constant M_GLOBAL_GREENLISTED_ROLE =\n        keccak256(\"M_GLOBAL_GREENLISTED_ROLE\");\n}\n"},"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/MathUpgradeable.sol\";\nimport \"./math/SignedMathUpgradeable.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary StringsUpgradeable {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = MathUpgradeable.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMathUpgradeable.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized != type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"},"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface AggregatorV3Interface {\n  function decimals() external view returns (uint8);\n\n  function description() external view returns (string memory);\n\n  function version() external view returns (uint256);\n\n  function getRoundData(uint80 _roundId)\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n\n  function latestRoundData()\n    external\n    view\n    returns (\n      uint80 roundId,\n      int256 answer,\n      uint256 startedAt,\n      uint256 updatedAt,\n      uint80 answeredInRound\n    );\n}\n"},"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary MathUpgradeable {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    function __Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __Pausable_init_unchained() internal onlyInitializing {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20Upgradeable.sol\";\nimport \"./extensions/IERC20MetadataUpgradeable.sol\";\nimport \"../../utils/ContextUpgradeable.sol\";\nimport \"../../proxy/utils/Initializable.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 * For a generic mechanism see {ERC20PresetMinterPauser}.\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 ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => 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    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\n        __ERC20_init_unchained(name_, symbol_);\n    }\n\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override 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 override 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 override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override 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 `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\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 `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `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     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` 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    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[45] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20Upgradeable {\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 amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` 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 amount) 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 `amount` as the allowance of `spender` over the 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 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` 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 amount) external returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControlUpgradeable.sol\";\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../utils/StringsUpgradeable.sol\";\nimport \"../utils/introspection/ERC165Upgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\n    function __AccessControl_init() internal onlyInitializing {\n    }\n\n    function __AccessControl_init_unchained() internal onlyInitializing {\n    }\n    struct RoleData {\n        mapping(address => bool) members;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with a standardized message including the required role.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     *\n     * _Available since v4.1._\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n        return _roles[role].members[account];\n    }\n\n    /**\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\n     *\n     * Format of the revert message is described in {_checkRole}.\n     *\n     * _Available since v4.6._\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Revert with a standard message if `account` is missing `role`.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert(\n                string(\n                    abi.encodePacked(\n                        \"AccessControl: account \",\n                        StringsUpgradeable.toHexString(account),\n                        \" is missing role \",\n                        StringsUpgradeable.toHexString(uint256(role), 32)\n                    )\n                )\n            );\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address account) public virtual override {\n        require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event. Note that unlike {grantRole}, this function doesn't perform any\n     * checks on the calling account.\n     *\n     * May emit a {RoleGranted} event.\n     *\n     * [WARNING]\n     * ====\n     * This function should only be called from the constructor when setting\n     * up the initial roles for the system.\n     *\n     * Using this function in any other way is effectively circumventing the admin\n     * system imposed by {AccessControl}.\n     * ====\n     *\n     * NOTE: This function is deprecated in favor of {_grantRole}.\n     */\n    function _setupRole(bytes32 role, address account) internal virtual {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual {\n        if (!hasRole(role, account)) {\n            _roles[role].members[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual {\n        if (hasRole(role, account)) {\n            _roles[role].members[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControlUpgradeable {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n}\n"},"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMathUpgradeable {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165Upgradeable.sol\";\nimport \"../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\n    function __ERC165_init() internal onlyInitializing {\n    }\n\n    function __ERC165_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165Upgradeable).interfaceId;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165Upgradeable {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20Upgradeable.sol\";\nimport \"../../../security/PausableUpgradeable.sol\";\nimport \"../../../proxy/utils/Initializable.sol\";\n\n/**\n * @dev ERC20 token with pausable token transfers, minting and burning.\n *\n * Useful for scenarios such as preventing trades until the end of an evaluation\n * period, or having an emergency switch for freezing all token transfers in the\n * event of a large bug.\n *\n * IMPORTANT: This contract does not include public pause and unpause functions. In\n * addition to inheriting this contract, you must define both functions, invoking the\n * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate\n * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will\n * make the contract unpausable.\n */\nabstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {\n    function __ERC20Pausable_init() internal onlyInitializing {\n        __Pausable_init_unchained();\n    }\n\n    function __ERC20Pausable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev See {ERC20-_beforeTokenTransfer}.\n     *\n     * Requirements:\n     *\n     * - the contract must not be paused.\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {\n        super._beforeTokenTransfer(from, to, amount);\n\n        require(!paused(), \"ERC20Pausable: token transfer while paused\");\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20Upgradeable.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\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":{"metadata":{"useLiteralContent":true},"optimizer":{"runs":200,"enabled":true}}},"stdJsonOutput":{"sources":{"contracts/interfaces/IDataFeed.sol":{"id":21},"contracts/access/MidasAccessControl.sol":{"id":17},"contracts/abstract/MidasInitializable.sol":{"id":16},"contracts/access/WithMidasAccessControl.sol":{"id":19},"contracts/access/MidasAccessControlRoles.sol":{"id":18},"contracts/libraries/DecimalsCorrectionLibrary.sol":{"id":22},"contracts/feeds/CustomAggregatorV3CompatibleFeed.sol":{"id":20},"contracts/products/mGLO/MGloCustomAggregatorFeed.sol":{"id":23},"contracts/products/mGLO/MGloMidasAccessControlRoles.sol":{"id":24},"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol":{"id":9},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"id":10},"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol":{"id":11},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"id":3},"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol":{"id":0},"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol":{"id":14},"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol":{"id":4},"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol":{"id":5},"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol":{"id":6},"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol":{"id":1},"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol":{"id":2},"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol":{"id":15},"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol":{"id":12},"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol":{"id":13},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol":{"id":7},"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol":{"id":8}},"contracts":{"contracts/products/mGLO/MGloCustomAggregatorFeed.sol":{"MGloCustomAggregatorFeed":{"abi":[{"name":"AnswerUpdated","type":"event","inputs":[{"name":"data","type":"int256","indexed":true,"internalType":"int256"},{"name":"roundId","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"timestamp","type":"uint256","indexed":true,"internalType":"uint256"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint8","indexed":false,"internalType":"uint8"}],"anonymous":false},{"name":"BLACKLISTED_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"BLACKLIST_OPERATOR_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"GREENLISTED_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"GREENLIST_OPERATOR_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLOBAL_GREENLISTED_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"accessControl","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract MidasAccessControl"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"pure"},{"name":"description","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"feedAdminRole","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"pure"},{"name":"getRoundData","type":"function","inputs":[{"name":"_roundId","type":"uint80","internalType":"uint80"}],"outputs":[{"name":"roundId","type":"uint80","internalType":"uint80"},{"name":"answer","type":"int256","internalType":"int256"},{"name":"startedAt","type":"uint256","internalType":"uint256"},{"name":"updatedAt","type":"uint256","internalType":"uint256"},{"name":"answeredInRound","type":"uint80","internalType":"uint80"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"_accessControl","type":"address","internalType":"address"},{"name":"_minAnswer","type":"int192","internalType":"int192"},{"name":"_maxAnswer","type":"int192","internalType":"int192"},{"name":"_maxAnswerDeviation","type":"uint256","internalType":"uint256"},{"name":"_description","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"lastAnswer","type":"function","inputs":[],"outputs":[{"name":"","type":"int256","internalType":"int256"}],"stateMutability":"view"},{"name":"lastTimestamp","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"latestRound","type":"function","inputs":[],"outputs":[{"name":"","type":"uint80","internalType":"uint80"}],"stateMutability":"view"},{"name":"latestRoundData","type":"function","inputs":[],"outputs":[{"name":"roundId","type":"uint80","internalType":"uint80"},{"name":"answer","type":"int256","internalType":"int256"},{"name":"startedAt","type":"uint256","internalType":"uint256"},{"name":"updatedAt","type":"uint256","internalType":"uint256"},{"name":"answeredInRound","type":"uint80","internalType":"uint80"}],"stateMutability":"view"},{"name":"maxAnswer","type":"function","inputs":[],"outputs":[{"name":"","type":"int192","internalType":"int192"}],"stateMutability":"view"},{"name":"maxAnswerDeviation","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"minAnswer","type":"function","inputs":[],"outputs":[{"name":"","type":"int192","internalType":"int192"}],"stateMutability":"view"},{"name":"setRoundData","type":"function","inputs":[{"name":"_data","type":"int256","internalType":"int256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRoundDataSafe","type":"function","inputs":[{"name":"_data","type":"int256","internalType":"int256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"version","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"}],"metadata":"{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"int256\",\"name\":\"data\",\"type\":\"int256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"roundId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"AnswerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BLACKLISTED_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"BLACKLIST_OPERATOR_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GREENLISTED_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GREENLIST_OPERATOR_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"M_GLOBAL_GREENLISTED_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"accessControl\",\"outputs\":[{\"internalType\":\"contract MidasAccessControl\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"description\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feedAdminRole\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint80\",\"name\":\"_roundId\",\"type\":\"uint80\"}],\"name\":\"getRoundData\",\"outputs\":[{\"internalType\":\"uint80\",\"name\":\"roundId\",\"type\":\"uint80\"},{\"internalType\":\"int256\",\"name\":\"answer\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"startedAt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"updatedAt\",\"type\":\"uint256\"},{\"internalType\":\"uint80\",\"name\":\"answeredInRound\",\"type\":\"uint80\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_accessControl\",\"type\":\"address\"},{\"internalType\":\"int192\",\"name\":\"_minAnswer\",\"type\":\"int192\"},{\"internalType\":\"int192\",\"name\":\"_maxAnswer\",\"type\":\"int192\"},{\"internalType\":\"uint256\",\"name\":\"_maxAnswerDeviation\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"_description\",\"type\":\"string\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastAnswer\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestRound\",\"outputs\":[{\"internalType\":\"uint80\",\"name\":\"\",\"type\":\"uint80\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestRoundData\",\"outputs\":[{\"internalType\":\"uint80\",\"name\":\"roundId\",\"type\":\"uint80\"},{\"internalType\":\"int256\",\"name\":\"answer\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"startedAt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"updatedAt\",\"type\":\"uint256\"},{\"internalType\":\"uint80\",\"name\":\"answeredInRound\",\"type\":\"uint80\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxAnswer\",\"outputs\":[{\"internalType\":\"int192\",\"name\":\"\",\"type\":\"int192\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxAnswerDeviation\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minAnswer\",\"outputs\":[{\"internalType\":\"int192\",\"name\":\"\",\"type\":\"int192\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"_data\",\"type\":\"int256\"}],\"name\":\"setRoundData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"_data\",\"type\":\"int256\"}],\"name\":\"setRoundDataSafe\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"RedDuck Software\",\"kind\":\"dev\",\"methods\":{\"feedAdminRole()\":{\"details\":\"describes a role, owner of which can update prices in this feed\",\"returns\":{\"_0\":\"role descriptor\"}},\"initialize(address,int192,int192,uint256,string)\":{\"params\":{\"_accessControl\":\"address of MidasAccessControll contract\",\"_description\":\"init value for `description`\",\"_maxAnswer\":\"init value for `maxAnswer`. Should be > `_minAnswer`\",\"_maxAnswerDeviation\":\"init value for `maxAnswerDeviation`\",\"_minAnswer\":\"init value for `minAnswer`. Should be < `_maxAnswer`\"}},\"lastAnswer()\":{\"returns\":{\"_0\":\"answer of lattest price submission\"}},\"lastTimestamp()\":{\"returns\":{\"_0\":\"timestamp of lattest price submission\"}},\"setRoundData(int256)\":{\"details\":\"`_data` should be >= `minAnswer` and <= `maxAnswer`. Function should be called only from address with `feedAdminRole()`\",\"params\":{\"_data\":\"data value\"}},\"setRoundDataSafe(int256)\":{\"details\":\"deviation with previous data needs to be <= `maxAnswerDeviation`\",\"params\":{\"_data\":\"data value\"}}},\"stateVariables\":{\"__gap\":{\"details\":\"leaving a storage gap for futures updates\"}},\"title\":\"MGloCustomAggregatorFeed\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"BLACKLISTED_ROLE()\":{\"notice\":\"actor that is blacklisted\"},\"BLACKLIST_OPERATOR_ROLE()\":{\"notice\":\"actor that can change black list statuses of addresses\"},\"DEFAULT_ADMIN_ROLE()\":{\"notice\":\"admin role\"},\"GREENLISTED_ROLE()\":{\"notice\":\"actor that is greenlisted\"},\"GREENLIST_OPERATOR_ROLE()\":{\"notice\":\"actor that can change green list statuses of addresses\"},\"M_GLOBAL_GREENLISTED_ROLE()\":{\"notice\":\"greenlist role for mGLO\"},\"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE()\":{\"notice\":\"actor that can manage MGloCustomAggregatorFeed and MGloDataFeed\"},\"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE()\":{\"notice\":\"actor that can manage MGloDepositVault\"},\"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE()\":{\"notice\":\"actor that can manage MGloRedemptionVault\"},\"accessControl()\":{\"notice\":\"MidasAccessControl contract address\"},\"description()\":{\"notice\":\"feed description\"},\"initialize(address,int192,int192,uint256,string)\":{\"notice\":\"upgradeable pattern contract`s initializer\"},\"latestRound()\":{\"notice\":\"last round id\"},\"maxAnswer()\":{\"notice\":\"maximal possible answer that feed can return\"},\"maxAnswerDeviation()\":{\"notice\":\"max deviation from lattest price in %\"},\"minAnswer()\":{\"notice\":\"minimal possible answer that feed can return\"},\"setRoundData(int256)\":{\"notice\":\"sets the data for `latestRound` + 1 round id\"},\"setRoundDataSafe(int256)\":{\"notice\":\"works as `setRoundData()`, but also checks the deviation with the lattest submitted data, and that at least 1 hour passed since the lattest submission\"}},\"notice\":\"AggregatorV3 compatible feed for mGLO, where price is submitted manually by feed admins\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/products/mGLO/MGloCustomAggregatorFeed.sol\":\"MGloCustomAggregatorFeed\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (\\n      uint80 roundId,\\n      int256 answer,\\n      uint256 startedAt,\\n      uint256 updatedAt,\\n      uint80 answeredInRound\\n    );\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (\\n      uint80 roundId,\\n      int256 answer,\\n      uint256 startedAt,\\n      uint256 updatedAt,\\n      uint80 answeredInRound\\n    );\\n}\\n\",\"keccak256\":\"0x6e6e4b0835904509406b070ee173b5bc8f677c19421b76be38aea3b1b3d30846\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IAccessControlUpgradeable.sol\\\";\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../utils/StringsUpgradeable.sol\\\";\\nimport \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```solidity\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```solidity\\n * function foo() public {\\n *     require(hasRole(MY_ROLE, msg.sender));\\n *     ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\\n * to enforce additional security measures for this role.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {\\n    function __AccessControl_init() internal onlyInitializing {\\n    }\\n\\n    function __AccessControl_init_unchained() internal onlyInitializing {\\n    }\\n    struct RoleData {\\n        mapping(address => bool) members;\\n        bytes32 adminRole;\\n    }\\n\\n    mapping(bytes32 => RoleData) private _roles;\\n\\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n    /**\\n     * @dev Modifier that checks that an account has a specific role. Reverts\\n     * with a standardized message including the required role.\\n     *\\n     * The format of the revert reason is given by the following regular expression:\\n     *\\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n     *\\n     * _Available since v4.1._\\n     */\\n    modifier onlyRole(bytes32 role) {\\n        _checkRole(role);\\n        _;\\n    }\\n\\n    /**\\n     * @dev See {IERC165-supportsInterface}.\\n     */\\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n        return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);\\n    }\\n\\n    /**\\n     * @dev Returns `true` if `account` has been granted `role`.\\n     */\\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\\n        return _roles[role].members[account];\\n    }\\n\\n    /**\\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\\n     *\\n     * Format of the revert message is described in {_checkRole}.\\n     *\\n     * _Available since v4.6._\\n     */\\n    function _checkRole(bytes32 role) internal view virtual {\\n        _checkRole(role, _msgSender());\\n    }\\n\\n    /**\\n     * @dev Revert with a standard message if `account` is missing `role`.\\n     *\\n     * The format of the revert reason is given by the following regular expression:\\n     *\\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\\n     */\\n    function _checkRole(bytes32 role, address account) internal view virtual {\\n        if (!hasRole(role, account)) {\\n            revert(\\n                string(\\n                    abi.encodePacked(\\n                        \\\"AccessControl: account \\\",\\n                        StringsUpgradeable.toHexString(account),\\n                        \\\" is missing role \\\",\\n                        StringsUpgradeable.toHexString(uint256(role), 32)\\n                    )\\n                )\\n            );\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\\n     * {revokeRole}.\\n     *\\n     * To change a role's admin, use {_setRoleAdmin}.\\n     */\\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\\n        return _roles[role].adminRole;\\n    }\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     *\\n     * May emit a {RoleGranted} event.\\n     */\\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n        _grantRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Revokes `role` from `account`.\\n     *\\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     *\\n     * May emit a {RoleRevoked} event.\\n     */\\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\\n        _revokeRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Revokes `role` from the calling account.\\n     *\\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n     * purpose is to provide a mechanism for accounts to lose their privileges\\n     * if they are compromised (such as when a trusted device is misplaced).\\n     *\\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `account`.\\n     *\\n     * May emit a {RoleRevoked} event.\\n     */\\n    function renounceRole(bytes32 role, address account) public virtual override {\\n        require(account == _msgSender(), \\\"AccessControl: can only renounce roles for self\\\");\\n\\n        _revokeRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\\n     * event. Note that unlike {grantRole}, this function doesn't perform any\\n     * checks on the calling account.\\n     *\\n     * May emit a {RoleGranted} event.\\n     *\\n     * [WARNING]\\n     * ====\\n     * This function should only be called from the constructor when setting\\n     * up the initial roles for the system.\\n     *\\n     * Using this function in any other way is effectively circumventing the admin\\n     * system imposed by {AccessControl}.\\n     * ====\\n     *\\n     * NOTE: This function is deprecated in favor of {_grantRole}.\\n     */\\n    function _setupRole(bytes32 role, address account) internal virtual {\\n        _grantRole(role, account);\\n    }\\n\\n    /**\\n     * @dev Sets `adminRole` as ``role``'s admin role.\\n     *\\n     * Emits a {RoleAdminChanged} event.\\n     */\\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n        bytes32 previousAdminRole = getRoleAdmin(role);\\n        _roles[role].adminRole = adminRole;\\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\\n    }\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * Internal function without access restriction.\\n     *\\n     * May emit a {RoleGranted} event.\\n     */\\n    function _grantRole(bytes32 role, address account) internal virtual {\\n        if (!hasRole(role, account)) {\\n            _roles[role].members[account] = true;\\n            emit RoleGranted(role, account, _msgSender());\\n        }\\n    }\\n\\n    /**\\n     * @dev Revokes `role` from `account`.\\n     *\\n     * Internal function without access restriction.\\n     *\\n     * May emit a {RoleRevoked} event.\\n     */\\n    function _revokeRole(bytes32 role, address account) internal virtual {\\n        if (hasRole(role, account)) {\\n            _roles[role].members[account] = false;\\n            emit RoleRevoked(role, account, _msgSender());\\n        }\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0xfeefb24d068524440e1ba885efdf105d91f83504af3c2d745ffacc4595396831\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControlUpgradeable {\\n    /**\\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n     *\\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n     * {RoleAdminChanged} not being emitted signaling this.\\n     *\\n     * _Available since v3.1._\\n     */\\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `role`.\\n     *\\n     * `sender` is the account that originated the contract call, an admin role\\n     * bearer except when using {AccessControl-_setupRole}.\\n     */\\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n    /**\\n     * @dev Emitted when `account` is revoked `role`.\\n     *\\n     * `sender` is the account that originated the contract call:\\n     *   - if using `revokeRole`, it is the admin role bearer\\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n     */\\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n    /**\\n     * @dev Returns `true` if `account` has been granted `role`.\\n     */\\n    function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n    /**\\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\\n     * {revokeRole}.\\n     *\\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n     */\\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n    /**\\n     * @dev Grants `role` to `account`.\\n     *\\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     */\\n    function grantRole(bytes32 role, address account) external;\\n\\n    /**\\n     * @dev Revokes `role` from `account`.\\n     *\\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must have ``role``'s admin role.\\n     */\\n    function revokeRole(bytes32 role, address account) external;\\n\\n    /**\\n     * @dev Revokes `role` from the calling account.\\n     *\\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n     * purpose is to provide a mechanism for accounts to lose their privileges\\n     * if they are compromised (such as when a trusted device is misplaced).\\n     *\\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\\n     * event.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `account`.\\n     */\\n    function renounceRole(bytes32 role, address account) external;\\n}\\n\",\"keccak256\":\"0xb8f5302f12138c5561362e88a78d061573e6298b7a1a5afe84a1e2c8d4d5aeaa\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n *     function initialize() initializer public {\\n *         __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n *     }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n *     function initializeV2() reinitializer(2) public {\\n *         __ERC20Permit_init(\\\"MyToken\\\");\\n *     }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n *     _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n    /**\\n     * @dev Indicates that the contract has been initialized.\\n     * @custom:oz-retyped-from bool\\n     */\\n    uint8 private _initialized;\\n\\n    /**\\n     * @dev Indicates that the contract is in the process of being initialized.\\n     */\\n    bool private _initializing;\\n\\n    /**\\n     * @dev Triggered when the contract has been initialized or reinitialized.\\n     */\\n    event Initialized(uint8 version);\\n\\n    /**\\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n     * `onlyInitializing` functions can be used to initialize parent contracts.\\n     *\\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n     * constructor.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier initializer() {\\n        bool isTopLevelCall = !_initializing;\\n        require(\\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n            \\\"Initializable: contract is already initialized\\\"\\n        );\\n        _initialized = 1;\\n        if (isTopLevelCall) {\\n            _initializing = true;\\n        }\\n        _;\\n        if (isTopLevelCall) {\\n            _initializing = false;\\n            emit Initialized(1);\\n        }\\n    }\\n\\n    /**\\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n     * used to initialize parent contracts.\\n     *\\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n     * are added through upgrades and that require initialization.\\n     *\\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\\n     *\\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n     * a contract, executing them in the right order is up to the developer or operator.\\n     *\\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\\n     *\\n     * Emits an {Initialized} event.\\n     */\\n    modifier reinitializer(uint8 version) {\\n        require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n        _initialized = version;\\n        _initializing = true;\\n        _;\\n        _initializing = false;\\n        emit Initialized(version);\\n    }\\n\\n    /**\\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n     */\\n    modifier onlyInitializing() {\\n        require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n        _;\\n    }\\n\\n    /**\\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n     * through proxies.\\n     *\\n     * Emits an {Initialized} event the first time it is successfully executed.\\n     */\\n    function _disableInitializers() internal virtual {\\n        require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n        if (_initialized != type(uint8).max) {\\n            _initialized = type(uint8).max;\\n            emit Initialized(type(uint8).max);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n     */\\n    function _getInitializedVersion() internal view returns (uint8) {\\n        return _initialized;\\n    }\\n\\n    /**\\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n     */\\n    function _isInitializing() internal view returns (bool) {\\n        return _initializing;\\n    }\\n}\\n\",\"keccak256\":\"0x89be10e757d242e9b18d5a32c9fbe2019f6d63052bbe46397a430a1d60d7f794\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n    /**\\n     * @dev Emitted when the pause is triggered by `account`.\\n     */\\n    event Paused(address account);\\n\\n    /**\\n     * @dev Emitted when the pause is lifted by `account`.\\n     */\\n    event Unpaused(address account);\\n\\n    bool private _paused;\\n\\n    /**\\n     * @dev Initializes the contract in unpaused state.\\n     */\\n    function __Pausable_init() internal onlyInitializing {\\n        __Pausable_init_unchained();\\n    }\\n\\n    function __Pausable_init_unchained() internal onlyInitializing {\\n        _paused = false;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is not paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    modifier whenNotPaused() {\\n        _requireNotPaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Modifier to make a function callable only when the contract is paused.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    modifier whenPaused() {\\n        _requirePaused();\\n        _;\\n    }\\n\\n    /**\\n     * @dev Returns true if the contract is paused, and false otherwise.\\n     */\\n    function paused() public view virtual returns (bool) {\\n        return _paused;\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is paused.\\n     */\\n    function _requireNotPaused() internal view virtual {\\n        require(!paused(), \\\"Pausable: paused\\\");\\n    }\\n\\n    /**\\n     * @dev Throws if the contract is not paused.\\n     */\\n    function _requirePaused() internal view virtual {\\n        require(paused(), \\\"Pausable: not paused\\\");\\n    }\\n\\n    /**\\n     * @dev Triggers stopped state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must not be paused.\\n     */\\n    function _pause() internal virtual whenNotPaused {\\n        _paused = true;\\n        emit Paused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev Returns to normal state.\\n     *\\n     * Requirements:\\n     *\\n     * - The contract must be paused.\\n     */\\n    function _unpause() internal virtual whenPaused {\\n        _paused = false;\\n        emit Unpaused(_msgSender());\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC20Upgradeable.sol\\\";\\nimport \\\"./extensions/IERC20MetadataUpgradeable.sol\\\";\\nimport \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.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 * For a generic mechanism see {ERC20PresetMinterPauser}.\\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 ERC20\\n * applications.\\n *\\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\\n * This allows applications to reconstruct the allowance for all accounts just\\n * by listening to said events. Other implementations of the EIP may not emit\\n * these events, as it isn't required by the specification.\\n *\\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\\n * functions have been added to mitigate the well-known issues around setting\\n * allowances. See {IERC20-approve}.\\n */\\ncontract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {\\n    mapping(address => uint256) private _balances;\\n\\n    mapping(address => mapping(address => 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    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\\n        __ERC20_init_unchained(name_, symbol_);\\n    }\\n\\n    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\\n        _name = name_;\\n        _symbol = symbol_;\\n    }\\n\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() public view virtual override 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 override 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 override returns (uint8) {\\n        return 18;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-totalSupply}.\\n     */\\n    function totalSupply() public view virtual override returns (uint256) {\\n        return _totalSupply;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-balanceOf}.\\n     */\\n    function balanceOf(address account) public view virtual override 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 `amount`.\\n     */\\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\\n        address owner = _msgSender();\\n        _transfer(owner, to, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-allowance}.\\n     */\\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\\n        return _allowances[owner][spender];\\n    }\\n\\n    /**\\n     * @dev See {IERC20-approve}.\\n     *\\n     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {\\n        address owner = _msgSender();\\n        _approve(owner, spender, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev See {IERC20-transferFrom}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance. This is not\\n     * required by the EIP. See the note at the beginning of {ERC20}.\\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 `amount`.\\n     * - the caller must have allowance for ``from``'s tokens of at least\\n     * `amount`.\\n     */\\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\\n        address spender = _msgSender();\\n        _spendAllowance(from, spender, amount);\\n        _transfer(from, to, amount);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\\n     *\\n     * This is an alternative to {approve} that can be used as a mitigation for\\n     * problems described in {IERC20-approve}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     */\\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\\n        address owner = _msgSender();\\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\\n     *\\n     * This is an alternative to {approve} that can be used as a mitigation for\\n     * problems described in {IERC20-approve}.\\n     *\\n     * Emits an {Approval} event indicating the updated allowance.\\n     *\\n     * Requirements:\\n     *\\n     * - `spender` cannot be the zero address.\\n     * - `spender` must have allowance for the caller of at least\\n     * `subtractedValue`.\\n     */\\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\\n        address owner = _msgSender();\\n        uint256 currentAllowance = allowance(owner, spender);\\n        require(currentAllowance >= subtractedValue, \\\"ERC20: decreased allowance below zero\\\");\\n        unchecked {\\n            _approve(owner, spender, currentAllowance - subtractedValue);\\n        }\\n\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Moves `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     * Requirements:\\n     *\\n     * - `from` cannot be the zero address.\\n     * - `to` cannot be the zero address.\\n     * - `from` must have a balance of at least `amount`.\\n     */\\n    function _transfer(address from, address to, uint256 amount) internal virtual {\\n        require(from != address(0), \\\"ERC20: transfer from the zero address\\\");\\n        require(to != address(0), \\\"ERC20: transfer to the zero address\\\");\\n\\n        _beforeTokenTransfer(from, to, amount);\\n\\n        uint256 fromBalance = _balances[from];\\n        require(fromBalance >= amount, \\\"ERC20: transfer amount exceeds balance\\\");\\n        unchecked {\\n            _balances[from] = fromBalance - amount;\\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\\n            // decrementing then incrementing.\\n            _balances[to] += amount;\\n        }\\n\\n        emit Transfer(from, to, amount);\\n\\n        _afterTokenTransfer(from, to, amount);\\n    }\\n\\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\\n     * the total supply.\\n     *\\n     * Emits a {Transfer} event with `from` set to the zero address.\\n     *\\n     * Requirements:\\n     *\\n     * - `account` cannot be the zero address.\\n     */\\n    function _mint(address account, uint256 amount) internal virtual {\\n        require(account != address(0), \\\"ERC20: mint to the zero address\\\");\\n\\n        _beforeTokenTransfer(address(0), account, amount);\\n\\n        _totalSupply += amount;\\n        unchecked {\\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\\n            _balances[account] += amount;\\n        }\\n        emit Transfer(address(0), account, amount);\\n\\n        _afterTokenTransfer(address(0), account, amount);\\n    }\\n\\n    /**\\n     * @dev Destroys `amount` tokens from `account`, reducing the\\n     * total supply.\\n     *\\n     * Emits a {Transfer} event with `to` set to the zero address.\\n     *\\n     * Requirements:\\n     *\\n     * - `account` cannot be the zero address.\\n     * - `account` must have at least `amount` tokens.\\n     */\\n    function _burn(address account, uint256 amount) internal virtual {\\n        require(account != address(0), \\\"ERC20: burn from the zero address\\\");\\n\\n        _beforeTokenTransfer(account, address(0), amount);\\n\\n        uint256 accountBalance = _balances[account];\\n        require(accountBalance >= amount, \\\"ERC20: burn amount exceeds balance\\\");\\n        unchecked {\\n            _balances[account] = accountBalance - amount;\\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\\n            _totalSupply -= amount;\\n        }\\n\\n        emit Transfer(account, address(0), amount);\\n\\n        _afterTokenTransfer(account, address(0), amount);\\n    }\\n\\n    /**\\n     * @dev Sets `amount` 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    function _approve(address owner, address spender, uint256 amount) internal virtual {\\n        require(owner != address(0), \\\"ERC20: approve from the zero address\\\");\\n        require(spender != address(0), \\\"ERC20: approve to the zero address\\\");\\n\\n        _allowances[owner][spender] = amount;\\n        emit Approval(owner, spender, amount);\\n    }\\n\\n    /**\\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\\n     *\\n     * Does not update the allowance amount in case of infinite allowance.\\n     * Revert if not enough allowance is available.\\n     *\\n     * Might emit an {Approval} event.\\n     */\\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\\n        uint256 currentAllowance = allowance(owner, spender);\\n        if (currentAllowance != type(uint256).max) {\\n            require(currentAllowance >= amount, \\\"ERC20: insufficient allowance\\\");\\n            unchecked {\\n                _approve(owner, spender, currentAllowance - amount);\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Hook that is called before any transfer of tokens. This includes\\n     * minting and burning.\\n     *\\n     * Calling conditions:\\n     *\\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n     * will be transferred to `to`.\\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\\n     * - `from` and `to` are never both zero.\\n     *\\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n     */\\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\\n\\n    /**\\n     * @dev Hook that is called after any transfer of tokens. This includes\\n     * minting and burning.\\n     *\\n     * Calling conditions:\\n     *\\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\\n     * has been transferred to `to`.\\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\\n     * - `from` and `to` are never both zero.\\n     *\\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\\n     */\\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[45] private __gap;\\n}\\n\",\"keccak256\":\"0xd14a627157b9a411d2410713e5dd3a377e9064bd5c194a90748bbf27ea625784\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\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 amount of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the amount of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves `amount` 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 amount) 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 `amount` as the allowance of `spender` over the 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 amount) external returns (bool);\\n\\n    /**\\n     * @dev Moves `amount` tokens from `from` to `to` using the\\n     * allowance mechanism. `amount` 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 amount) external returns (bool);\\n}\\n\",\"keccak256\":\"0x0e1f0f5f62f67a881cd1a9597acbc0a5e4071f3c2c10449a183b922ae7272e3f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/ERC20Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../ERC20Upgradeable.sol\\\";\\nimport \\\"../../../security/PausableUpgradeable.sol\\\";\\nimport \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev ERC20 token with pausable token transfers, minting and burning.\\n *\\n * Useful for scenarios such as preventing trades until the end of an evaluation\\n * period, or having an emergency switch for freezing all token transfers in the\\n * event of a large bug.\\n *\\n * IMPORTANT: This contract does not include public pause and unpause functions. In\\n * addition to inheriting this contract, you must define both functions, invoking the\\n * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate\\n * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will\\n * make the contract unpausable.\\n */\\nabstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {\\n    function __ERC20Pausable_init() internal onlyInitializing {\\n        __Pausable_init_unchained();\\n    }\\n\\n    function __ERC20Pausable_init_unchained() internal onlyInitializing {\\n    }\\n    /**\\n     * @dev See {ERC20-_beforeTokenTransfer}.\\n     *\\n     * Requirements:\\n     *\\n     * - the contract must not be paused.\\n     */\\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {\\n        super._beforeTokenTransfer(from, to, amount);\\n\\n        require(!paused(), \\\"ERC20Pausable: token transfer while paused\\\");\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0xf0bd7f71ffae5f0addd375e8511fbf2ad8ca0c9b2606c32d92bdda7d76a7a81c\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20Upgradeable.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\n *\\n * _Available since v4.1._\\n */\\ninterface IERC20MetadataUpgradeable is IERC20Upgradeable {\\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\",\"keccak256\":\"0x605434219ebbe4653f703640f06969faa5a1d78f0bfef878e5ddbb1ca369ceeb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n    /**\\n     * @dev Returns true if `account` is a contract.\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * It is unsafe to assume that an address for which this function returns\\n     * false is an externally-owned account (EOA) and not a contract.\\n     *\\n     * Among others, `isContract` will return false for the following\\n     * types of addresses:\\n     *\\n     *  - an externally-owned account\\n     *  - a contract in construction\\n     *  - an address where a contract will be created\\n     *  - an address where a contract lived, but was destroyed\\n     *\\n     * Furthermore, `isContract` will also return true if the target contract within\\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\\n     * which only has an effect at the end of a transaction.\\n     * ====\\n     *\\n     * [IMPORTANT]\\n     * ====\\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n     *\\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n     * constructor.\\n     * ====\\n     */\\n    function isContract(address account) internal view returns (bool) {\\n        // This method relies on extcodesize/address.code.length, which returns 0\\n        // for contracts in construction, since the code is only stored at the end\\n        // of the constructor execution.\\n\\n        return account.code.length > 0;\\n    }\\n\\n    /**\\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n     * `recipient`, forwarding all available gas and reverting on errors.\\n     *\\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n     * imposed by `transfer`, making them unable to receive funds via\\n     * `transfer`. {sendValue} removes this limitation.\\n     *\\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n     *\\n     * IMPORTANT: because control is transferred to `recipient`, care must be\\n     * taken to not create reentrancy vulnerabilities. Consider using\\n     * {ReentrancyGuard} or the\\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n     */\\n    function sendValue(address payable recipient, uint256 amount) internal {\\n        require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n        (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n        require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n    }\\n\\n    /**\\n     * @dev Performs a Solidity function call using a low level `call`. A\\n     * plain `call` is an unsafe replacement for a function call: use this\\n     * function instead.\\n     *\\n     * If `target` reverts with a revert reason, it is bubbled up by this\\n     * function (like regular Solidity function calls).\\n     *\\n     * Returns the raw returned data. To convert to the expected return value,\\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n     *\\n     * Requirements:\\n     *\\n     * - `target` must be a contract.\\n     * - calling `target` with `data` must not revert.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n     * `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, 0, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but also transferring `value` wei to `target`.\\n     *\\n     * Requirements:\\n     *\\n     * - the calling contract must have an ETH balance of at least `value`.\\n     * - the called Solidity function must be `payable`.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n        return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\\n     *\\n     * _Available since v3.1._\\n     */\\n    function functionCallWithValue(\\n        address target,\\n        bytes memory data,\\n        uint256 value,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n        return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a static call.\\n     *\\n     * _Available since v3.3._\\n     */\\n    function functionStaticCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.staticcall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n     * but performing a delegate call.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n        return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n    }\\n\\n    /**\\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n     * but performing a delegate call.\\n     *\\n     * _Available since v3.4._\\n     */\\n    function functionDelegateCall(\\n        address target,\\n        bytes memory data,\\n        string memory errorMessage\\n    ) internal returns (bytes memory) {\\n        (bool success, bytes memory returndata) = target.delegatecall(data);\\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n     *\\n     * _Available since v4.8._\\n     */\\n    function verifyCallResultFromTarget(\\n        address target,\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal view returns (bytes memory) {\\n        if (success) {\\n            if (returndata.length == 0) {\\n                // only check isContract if the call was successful and the return data is empty\\n                // otherwise we already know that it was a contract\\n                require(isContract(target), \\\"Address: call to non-contract\\\");\\n            }\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    /**\\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n     * revert reason or using the provided one.\\n     *\\n     * _Available since v4.3._\\n     */\\n    function verifyCallResult(\\n        bool success,\\n        bytes memory returndata,\\n        string memory errorMessage\\n    ) internal pure returns (bytes memory) {\\n        if (success) {\\n            return returndata;\\n        } else {\\n            _revert(returndata, errorMessage);\\n        }\\n    }\\n\\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n        // Look for revert reason and bubble it up if present\\n        if (returndata.length > 0) {\\n            // The easiest way to bubble the revert reason is using memory via assembly\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                let returndata_size := mload(returndata)\\n                revert(add(32, returndata), returndata_size)\\n            }\\n        } else {\\n            revert(errorMessage);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x9c80f545915582e63fe206c6ce27cbe85a86fc10b9cd2a0e8c9488fb7c2ee422\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n    function __Context_init() internal onlyInitializing {\\n    }\\n\\n    function __Context_init_unchained() internal onlyInitializing {\\n    }\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/MathUpgradeable.sol\\\";\\nimport \\\"./math/SignedMathUpgradeable.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary StringsUpgradeable {\\n    bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n    uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n     */\\n    function toString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            uint256 length = MathUpgradeable.log10(value) + 1;\\n            string memory buffer = new string(length);\\n            uint256 ptr;\\n            /// @solidity memory-safe-assembly\\n            assembly {\\n                ptr := add(buffer, add(32, length))\\n            }\\n            while (true) {\\n                ptr--;\\n                /// @solidity memory-safe-assembly\\n                assembly {\\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n                }\\n                value /= 10;\\n                if (value == 0) break;\\n            }\\n            return buffer;\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\\n     */\\n    function toString(int256 value) internal pure returns (string memory) {\\n        return string(abi.encodePacked(value < 0 ? \\\"-\\\" : \\\"\\\", toString(SignedMathUpgradeable.abs(value))));\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(uint256 value) internal pure returns (string memory) {\\n        unchecked {\\n            return toHexString(value, MathUpgradeable.log256(value) + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n     */\\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n        bytes memory buffer = new bytes(2 * length + 2);\\n        buffer[0] = \\\"0\\\";\\n        buffer[1] = \\\"x\\\";\\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\\n            buffer[i] = _SYMBOLS[value & 0xf];\\n            value >>= 4;\\n        }\\n        require(value == 0, \\\"Strings: hex length insufficient\\\");\\n        return string(buffer);\\n    }\\n\\n    /**\\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n     */\\n    function toHexString(address addr) internal pure returns (string memory) {\\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n    }\\n\\n    /**\\n     * @dev Returns true if the two strings are equal.\\n     */\\n    function equal(string memory a, string memory b) internal pure returns (bool) {\\n        return keccak256(bytes(a)) == keccak256(bytes(b));\\n    }\\n}\\n\",\"keccak256\":\"0xb96dc79b65b7c37937919dcdb356a969ce0aa2e8338322bf4dc027a3c9c9a7eb\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IERC165Upgradeable.sol\\\";\\nimport \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n *\\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {\\n    function __ERC165_init() internal onlyInitializing {\\n    }\\n\\n    function __ERC165_init_unchained() internal onlyInitializing {\\n    }\\n    /**\\n     * @dev See {IERC165-supportsInterface}.\\n     */\\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n        return interfaceId == type(IERC165Upgradeable).interfaceId;\\n    }\\n\\n    /**\\n     * @dev This empty reserved space is put in place to allow future versions to add new\\n     * variables without shifting down storage in the inheritance chain.\\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n     */\\n    uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x9a3b990bd56d139df3e454a9edf1c64668530b5a77fc32eb063bc206f958274a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165Upgradeable {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xc6cef87559d0aeffdf0a99803de655938a7779ec0a3cd5d4383483ad85565a09\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary MathUpgradeable {\\n    enum Rounding {\\n        Down, // Toward negative infinity\\n        Up, // Toward infinity\\n        Zero // Toward zero\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a > b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return a < b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds up instead\\n     * of rounding down.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b - 1) / b can overflow on addition, so we distribute.\\n        return a == 0 ? 0 : (a - 1) / b + 1;\\n    }\\n\\n    /**\\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n     * with further edits by Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2^256 + prod0.\\n            uint256 prod0; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod0 := mul(x, y)\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n            require(denominator > prod1, \\\"Math: mulDiv overflow\\\");\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n            // See https://cs.stackexchange.com/q/138556/92363.\\n\\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\\n            uint256 twos = denominator & (~denominator + 1);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv = 1 mod 2^4.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n            // in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        uint256 result = mulDiv(x, y, denominator);\\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n            result += 1;\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n     *\\n     * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        if (a == 0) {\\n            return 0;\\n        }\\n\\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n        //\\n        // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n        //\\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n        //\\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n        uint256 result = 1 << (log2(a) >> 1);\\n\\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n        // into the expected uint128 result.\\n        unchecked {\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            result = (result + a / result) >> 1;\\n            return min(result, a / result);\\n        }\\n    }\\n\\n    /**\\n     * @notice Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 128;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 64;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 32;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 16;\\n            }\\n            if (value >> 8 > 0) {\\n                value >>= 8;\\n                result += 8;\\n            }\\n            if (value >> 4 > 0) {\\n                value >>= 4;\\n                result += 4;\\n            }\\n            if (value >> 2 > 0) {\\n                value >>= 2;\\n                result += 2;\\n            }\\n            if (value >> 1 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, rounded down, of a positive value.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >> 128 > 0) {\\n                value >>= 128;\\n                result += 16;\\n            }\\n            if (value >> 64 > 0) {\\n                value >>= 64;\\n                result += 8;\\n            }\\n            if (value >> 32 > 0) {\\n                value >>= 32;\\n                result += 4;\\n            }\\n            if (value >> 16 > 0) {\\n                value >>= 16;\\n                result += 2;\\n            }\\n            if (value >> 8 > 0) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2bc0007987c229ae7624eb29be6a9b84f6a6a5872f76248b15208b131ea41c4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/math/SignedMathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard signed math utilities missing in the Solidity language.\\n */\\nlibrary SignedMathUpgradeable {\\n    /**\\n     * @dev Returns the largest of two signed numbers.\\n     */\\n    function max(int256 a, int256 b) internal pure returns (int256) {\\n        return a > b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two signed numbers.\\n     */\\n    function min(int256 a, int256 b) internal pure returns (int256) {\\n        return a < b ? a : b;\\n    }\\n\\n    /**\\n     * @dev Returns the average of two signed numbers without overflow.\\n     * The result is rounded towards zero.\\n     */\\n    function average(int256 a, int256 b) internal pure returns (int256) {\\n        // Formula from the book \\\"Hacker's Delight\\\"\\n        int256 x = (a & b) + ((a ^ b) >> 1);\\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\\n    }\\n\\n    /**\\n     * @dev Returns the absolute unsigned value of a signed value.\\n     */\\n    function abs(int256 n) internal pure returns (uint256) {\\n        unchecked {\\n            // must be unchecked in order to support `n = type(int256).min`\\n            return uint256(n >= 0 ? n : -n);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x88f6b7bba3ee33eeb741f9a0f5bc98b6e6e352d0fe4905377bb328590f84095a\",\"license\":\"MIT\"},\"contracts/abstract/MidasInitializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\n/**\\n * @title MidasInitializable\\n * @author RedDuck Software\\n * @notice Base Initializable contract that implements constructor\\n * that calls _disableInitializers() to prevent\\n * initialization of implementation contract\\n */\\nabstract contract MidasInitializable is Initializable {\\n    /// @custom:oz-upgrades-unsafe-allow constructor\\n    constructor() {\\n        _disableInitializers();\\n    }\\n}\\n\",\"keccak256\":\"0x33ddc23ee381434633c0458d410958d0363248dc0267c5aa6dcd5624a3849831\",\"license\":\"MIT\"},\"contracts/access/MidasAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\\\";\\n\\nimport \\\"./MidasAccessControlRoles.sol\\\";\\nimport \\\"../abstract/MidasInitializable.sol\\\";\\n\\n/**\\n * @title MidasAccessControl\\n * @notice Smart contract that stores all roles for Midas project\\n * @author RedDuck Software\\n */\\ncontract MidasAccessControl is\\n    AccessControlUpgradeable,\\n    MidasInitializable,\\n    MidasAccessControlRoles\\n{\\n    /**\\n     * @notice upgradeable pattern contract`s initializer\\n     */\\n    function initialize() external initializer {\\n        __AccessControl_init();\\n        _setupRoles(msg.sender);\\n    }\\n\\n    /**\\n     * @notice grant multiple roles to multiple users\\n     * in one transaction\\n     * @dev length`s of 2 arays should match\\n     * @param roles array of bytes32 roles\\n     * @param addresses array of user addresses\\n     */\\n    function grantRoleMult(bytes32[] memory roles, address[] memory addresses)\\n        external\\n    {\\n        require(roles.length == addresses.length, \\\"MAC: mismatch arrays\\\");\\n\\n        for (uint256 i = 0; i < roles.length; i++) {\\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\\n            _grantRole(roles[i], addresses[i]);\\n        }\\n    }\\n\\n    /**\\n     * @notice revoke multiple roles from multiple users\\n     * in one transaction\\n     * @dev length`s of 2 arays should match\\n     * @param roles array of bytes32 roles\\n     * @param addresses array of user addresses\\n     */\\n    function revokeRoleMult(bytes32[] memory roles, address[] memory addresses)\\n        external\\n    {\\n        require(roles.length == addresses.length, \\\"MAC: mismatch arrays\\\");\\n        for (uint256 i = 0; i < roles.length; i++) {\\n            _checkRole(getRoleAdmin(roles[i]), msg.sender);\\n            _revokeRole(roles[i], addresses[i]);\\n        }\\n    }\\n\\n    //solhint-disable disable-next-line\\n    function renounceRole(bytes32, address) public pure override {\\n        revert(\\\"MAC: Forbidden\\\");\\n    }\\n\\n    /**\\n     * @dev setup roles during the contracts initialization\\n     */\\n    function _setupRoles(address admin) private {\\n        _grantRole(DEFAULT_ADMIN_ROLE, admin);\\n\\n        _setRoleAdmin(BLACKLISTED_ROLE, BLACKLIST_OPERATOR_ROLE);\\n        _setRoleAdmin(GREENLISTED_ROLE, GREENLIST_OPERATOR_ROLE);\\n    }\\n}\\n\",\"keccak256\":\"0xc5d361b87241702bf495381db842effafd2fe10231ad5ee6d0eac182029622e0\",\"license\":\"MIT\"},\"contracts/access/MidasAccessControlRoles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title MidasAccessControlRoles\\n * @notice Base contract that stores all roles descriptors\\n * @author RedDuck Software\\n */\\nabstract contract MidasAccessControlRoles {\\n    /**\\n     * @notice actor that can change green list statuses of addresses\\n     */\\n    bytes32 public constant GREENLIST_OPERATOR_ROLE =\\n        keccak256(\\\"GREENLIST_OPERATOR_ROLE\\\");\\n\\n    /**\\n     * @notice actor that can change black list statuses of addresses\\n     */\\n    bytes32 public constant BLACKLIST_OPERATOR_ROLE =\\n        keccak256(\\\"BLACKLIST_OPERATOR_ROLE\\\");\\n\\n    /**\\n     * @notice actor that is greenlisted\\n     */\\n    bytes32 public constant GREENLISTED_ROLE = keccak256(\\\"GREENLISTED_ROLE\\\");\\n\\n    /**\\n     * @notice actor that is blacklisted\\n     */\\n    bytes32 public constant BLACKLISTED_ROLE = keccak256(\\\"BLACKLISTED_ROLE\\\");\\n}\\n\",\"keccak256\":\"0x797d1e5236716608a0e2754dcd34099ef8d3bddba8557d2a0414daf47490e126\",\"license\":\"MIT\"},\"contracts/access/WithMidasAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"./MidasAccessControl.sol\\\";\\nimport \\\"../abstract/MidasInitializable.sol\\\";\\n\\n/**\\n * @title WithMidasAccessControl\\n * @notice Base contract that consumes MidasAccessControl\\n * @author RedDuck Software\\n */\\nabstract contract WithMidasAccessControl is\\n    MidasInitializable,\\n    MidasAccessControlRoles\\n{\\n    /**\\n     * @notice admin role\\n     */\\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n    /**\\n     * @notice MidasAccessControl contract address\\n     */\\n    MidasAccessControl public accessControl;\\n\\n    /**\\n     * @dev leaving a storage gap for futures updates\\n     */\\n    uint256[50] private __gap;\\n\\n    /**\\n     * @dev checks that given `address` have `role`\\n     */\\n    modifier onlyRole(bytes32 role, address account) {\\n        _onlyRole(role, account);\\n        _;\\n    }\\n\\n    /**\\n     * @dev checks that given `address` do not have `role`\\n     */\\n    modifier onlyNotRole(bytes32 role, address account) {\\n        _onlyNotRole(role, account);\\n        _;\\n    }\\n\\n    /**\\n     * @dev upgradeable pattern contract`s initializer\\n     */\\n    // solhint-disable func-name-mixedcase\\n    function __WithMidasAccessControl_init(address _accessControl)\\n        internal\\n        onlyInitializing\\n    {\\n        require(_accessControl != address(0), \\\"zero address\\\");\\n        accessControl = MidasAccessControl(_accessControl);\\n    }\\n\\n    /**\\n     * @dev checks that given `address` have `role`\\n     */\\n    function _onlyRole(bytes32 role, address account) internal view {\\n        require(accessControl.hasRole(role, account), \\\"WMAC: hasnt role\\\");\\n    }\\n\\n    /**\\n     * @dev checks that given `address` do not have `role`\\n     */\\n    function _onlyNotRole(bytes32 role, address account) internal view {\\n        require(!accessControl.hasRole(role, account), \\\"WMAC: has role\\\");\\n    }\\n}\\n\",\"keccak256\":\"0xefec8ab41dcc890d353e2e7dedbe034a489f6ea348bda52ca3cb123c813996af\",\"license\":\"MIT\"},\"contracts/feeds/CustomAggregatorV3CompatibleFeed.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\\\";\\nimport \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\\\";\\n\\nimport \\\"../access/WithMidasAccessControl.sol\\\";\\nimport \\\"../libraries/DecimalsCorrectionLibrary.sol\\\";\\nimport \\\"../interfaces/IDataFeed.sol\\\";\\n\\n/**\\n * @title CustomAggregatorV3CompatibleFeed\\n * @notice AggregatorV3 compatible feed, where price is submitted manually by feed admins\\n * @author RedDuck Software\\n */\\ncontract CustomAggregatorV3CompatibleFeed is\\n    WithMidasAccessControl,\\n    AggregatorV3Interface\\n{\\n    struct RoundData {\\n        uint80 roundId;\\n        int256 answer;\\n        uint256 startedAt;\\n        uint256 updatedAt;\\n        uint80 answeredInRound;\\n    }\\n\\n    /**\\n     * @notice feed description\\n     */\\n    string public override description;\\n\\n    /**\\n     * @notice last round id\\n     */\\n    uint80 public latestRound;\\n\\n    /**\\n     * @notice max deviation from lattest price in %\\n     * @dev 10 ** decimals() is a percentage precision\\n     */\\n    uint256 public maxAnswerDeviation;\\n\\n    /**\\n     * @notice minimal possible answer that feed can return\\n     */\\n    int192 public minAnswer;\\n\\n    /**\\n     * @notice maximal possible answer that feed can return\\n     */\\n    int192 public maxAnswer;\\n\\n    /**\\n     * @dev holds round information\\n     */\\n    mapping(uint80 => RoundData) private _roundData;\\n\\n    event AnswerUpdated(\\n        int256 indexed data,\\n        uint256 indexed roundId,\\n        uint256 indexed timestamp\\n    );\\n\\n    /**\\n     * @dev checks that msg.sender do have a feedAdminRole() role\\n     */\\n    modifier onlyAggregatorAdmin() {\\n        _onlyRole(feedAdminRole(), msg.sender);\\n        _;\\n    }\\n\\n    /**\\n     * @notice upgradeable pattern contract`s initializer\\n     * @param _accessControl address of MidasAccessControll contract\\n     * @param _minAnswer init value for `minAnswer`. Should be < `_maxAnswer`\\n     * @param _maxAnswer init value for `maxAnswer`. Should be > `_minAnswer`\\n     * @param _maxAnswerDeviation init value for `maxAnswerDeviation`\\n     * @param _description init value for `description`\\n     */\\n    function initialize(\\n        address _accessControl,\\n        int192 _minAnswer,\\n        int192 _maxAnswer,\\n        uint256 _maxAnswerDeviation,\\n        string calldata _description\\n    ) public virtual initializer {\\n        __WithMidasAccessControl_init(_accessControl);\\n\\n        require(_minAnswer < _maxAnswer, \\\"CA: !min/max\\\");\\n        require(\\n            _maxAnswerDeviation <= 100 * (10**decimals()),\\n            \\\"CA: !max deviation\\\"\\n        );\\n\\n        minAnswer = _minAnswer;\\n        maxAnswer = _maxAnswer;\\n        maxAnswerDeviation = _maxAnswerDeviation;\\n        description = _description;\\n    }\\n\\n    /**\\n     * @notice works as `setRoundData()`, but also checks the\\n     * deviation with the lattest submitted data, and that at least\\n     * 1 hour passed since the lattest submission\\n     * @dev deviation with previous data needs to be <= `maxAnswerDeviation`\\n     * @param _data data value\\n     */\\n    function setRoundDataSafe(int256 _data) external {\\n        uint256 _lastUpdatedAt = lastTimestamp();\\n\\n        if (_lastUpdatedAt != 0) {\\n            uint256 deviation = _getDeviation(lastAnswer(), _data);\\n            require(deviation <= maxAnswerDeviation, \\\"CA: !deviation\\\");\\n        }\\n\\n        require(\\n            block.timestamp - _lastUpdatedAt > 1 hours,\\n            \\\"CA: not enough time passed\\\"\\n        );\\n\\n        return setRoundData(_data);\\n    }\\n\\n    /**\\n     * @notice sets the data for `latestRound` + 1 round id\\n     * @dev `_data` should be >= `minAnswer` and <= `maxAnswer`.\\n     * Function should be called only from address with `feedAdminRole()`\\n     * @param _data data value\\n     */\\n    function setRoundData(int256 _data) public onlyAggregatorAdmin {\\n        require(\\n            _data >= minAnswer && _data <= maxAnswer,\\n            \\\"CA: out of [min;max]\\\"\\n        );\\n\\n        uint80 roundId = latestRound + 1;\\n\\n        _roundData[roundId] = RoundData({\\n            roundId: roundId,\\n            answer: _data,\\n            startedAt: block.timestamp,\\n            updatedAt: block.timestamp,\\n            answeredInRound: roundId\\n        });\\n\\n        latestRound = roundId;\\n\\n        emit AnswerUpdated(_data, roundId, block.timestamp);\\n    }\\n\\n    /**\\n     * @inheritdoc AggregatorV3Interface\\n     */\\n    function latestRoundData()\\n        external\\n        view\\n        returns (\\n            uint80 roundId,\\n            int256 answer,\\n            uint256 startedAt,\\n            uint256 updatedAt,\\n            uint80 answeredInRound\\n        )\\n    {\\n        return getRoundData(latestRound);\\n    }\\n\\n    /**\\n     * @inheritdoc AggregatorV3Interface\\n     */\\n    function version() external pure returns (uint256) {\\n        return 1;\\n    }\\n\\n    /**\\n     * @return answer of lattest price submission\\n     */\\n    function lastAnswer() public view returns (int256) {\\n        return _roundData[latestRound].answer;\\n    }\\n\\n    /**\\n     * @return timestamp of lattest price submission\\n     */\\n    function lastTimestamp() public view returns (uint256) {\\n        return _roundData[latestRound].updatedAt;\\n    }\\n\\n    /**\\n     * @inheritdoc AggregatorV3Interface\\n     */\\n    function getRoundData(uint80 _roundId)\\n        public\\n        view\\n        returns (\\n            uint80 roundId,\\n            int256 answer,\\n            uint256 startedAt,\\n            uint256 updatedAt,\\n            uint80 answeredInRound\\n        )\\n    {\\n        RoundData memory roundData = _roundData[_roundId];\\n        return (\\n            roundData.roundId,\\n            roundData.answer,\\n            roundData.startedAt,\\n            roundData.updatedAt,\\n            roundData.answeredInRound\\n        );\\n    }\\n\\n    /**\\n     * @dev describes a role, owner of which can update prices in this feed\\n     * @return role descriptor\\n     */\\n    function feedAdminRole() public view virtual returns (bytes32) {\\n        return DEFAULT_ADMIN_ROLE;\\n    }\\n\\n    /**\\n     * @inheritdoc AggregatorV3Interface\\n     */\\n    function decimals() public pure returns (uint8) {\\n        return 8;\\n    }\\n\\n    /**\\n     * @dev calculates a deviation in % between `_lastPrice` and `_newPrice`\\n     * @return deviation in `10 ** decimals()` precision\\n     */\\n    function _getDeviation(int256 _lastPrice, int256 _newPrice)\\n        internal\\n        pure\\n        returns (uint256)\\n    {\\n        if (_newPrice == 0) return 100 * 10**decimals();\\n        int256 one = int256(10**decimals());\\n        int256 priceDif = _newPrice - _lastPrice;\\n        int256 deviation = (priceDif * one * 100) / _lastPrice;\\n        deviation = deviation < 0 ? deviation * -1 : deviation;\\n        return uint256(deviation);\\n    }\\n}\\n\",\"keccak256\":\"0x7af534ae031ea188b70bc28acab2d900468ee70ccaacdf8541a4c58c5f775024\",\"license\":\"MIT\"},\"contracts/interfaces/IDataFeed.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol\\\";\\nimport \\\"@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol\\\";\\n\\nimport \\\"../access/WithMidasAccessControl.sol\\\";\\nimport \\\"../libraries/DecimalsCorrectionLibrary.sol\\\";\\n\\n/**\\n * @title IDataFeed\\n * @author RedDuck Software\\n */\\ninterface IDataFeed {\\n    /**\\n     * @notice fetches answer from aggregator\\n     * and converts it to the base18 precision\\n     * @return answer fetched aggregator answer\\n     */\\n    function getDataInBase18() external view returns (uint256 answer);\\n\\n    /**\\n     * @dev describes a role, owner of which can manage this feed\\n     * @return role descriptor\\n     */\\n    function feedAdminRole() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x9fa7605e7391d8fd6f377f45fd33f58eec1cfc97749aec33780c597ec095c706\",\"license\":\"MIT\"},\"contracts/libraries/DecimalsCorrectionLibrary.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title DecimalsCorrectionLibrary\\n * @author RedDuck Software\\n */\\nlibrary DecimalsCorrectionLibrary {\\n    /**\\n     * @dev converts `originalAmount` with `originalDecimals` into\\n     * amount with `decidedDecimals`\\n     * @param originalAmount amount to convert\\n     * @param originalDecimals decimals of the original amount\\n     * @param decidedDecimals decimals for the output amount\\n     * @return amount converted amount with `decidedDecimals`\\n     */\\n    function convert(\\n        uint256 originalAmount,\\n        uint256 originalDecimals,\\n        uint256 decidedDecimals\\n    ) internal pure returns (uint256) {\\n        if (originalAmount == 0) return 0;\\n        if (originalDecimals == decidedDecimals) return originalAmount;\\n\\n        uint256 adjustedAmount;\\n\\n        if (originalDecimals > decidedDecimals) {\\n            adjustedAmount =\\n                originalAmount /\\n                (10**(originalDecimals - decidedDecimals));\\n        } else {\\n            adjustedAmount =\\n                originalAmount *\\n                (10**(decidedDecimals - originalDecimals));\\n        }\\n\\n        return adjustedAmount;\\n    }\\n\\n    /**\\n     * @dev converts `originalAmount` with decimals 18 into\\n     * amount with `decidedDecimals`\\n     * @param originalAmount amount to convert\\n     * @param decidedDecimals decimals for the output amount\\n     * @return amount converted amount with `decidedDecimals`\\n     */\\n    function convertFromBase18(uint256 originalAmount, uint256 decidedDecimals)\\n        internal\\n        pure\\n        returns (uint256)\\n    {\\n        return convert(originalAmount, 18, decidedDecimals);\\n    }\\n\\n    /**\\n     * @dev converts `originalAmount` with `originalDecimals` into\\n     * amount with decimals 18\\n     * @param originalAmount amount to convert\\n     * @param originalDecimals decimals of the original amount\\n     * @return amount converted amount with 18 decimals\\n     */\\n    function convertToBase18(uint256 originalAmount, uint256 originalDecimals)\\n        internal\\n        pure\\n        returns (uint256)\\n    {\\n        return convert(originalAmount, originalDecimals, 18);\\n    }\\n}\\n\",\"keccak256\":\"0x5d1b64b11adda6ea2ab56bb662706a46f76d8225c8db3c429f03a30f5e77a7aa\",\"license\":\"MIT\"},\"contracts/products/mGLO/MGloCustomAggregatorFeed.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.9;\\n\\nimport \\\"../../feeds/CustomAggregatorV3CompatibleFeed.sol\\\";\\nimport \\\"./MGloMidasAccessControlRoles.sol\\\";\\n\\n/**\\n * @title MGloCustomAggregatorFeed\\n * @notice AggregatorV3 compatible feed for mGLO,\\n * where price is submitted manually by feed admins\\n * @author RedDuck Software\\n */\\ncontract MGloCustomAggregatorFeed is\\n    CustomAggregatorV3CompatibleFeed,\\n    MGloMidasAccessControlRoles\\n{\\n    /**\\n     * @dev leaving a storage gap for futures updates\\n     */\\n    uint256[50] private __gap;\\n\\n    /**\\n     * @inheritdoc CustomAggregatorV3CompatibleFeed\\n     */\\n    function feedAdminRole() public pure override returns (bytes32) {\\n        return M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE;\\n    }\\n}\\n\",\"keccak256\":\"0x5ce4bda1de25e2d01808996d67f297a9ac7fab7aff0fbcafb2cef9bb2abfc7e2\",\"license\":\"MIT\"},\"contracts/products/mGLO/MGloMidasAccessControlRoles.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.9;\\n\\n/**\\n * @title MGloMidasAccessControlRoles\\n * @notice Base contract that stores all roles descriptors for mGLO contracts\\n * @author RedDuck Software\\n */\\nabstract contract MGloMidasAccessControlRoles {\\n    /**\\n     * @notice actor that can manage MGloDepositVault\\n     */\\n    bytes32 public constant M_GLO_DEPOSIT_VAULT_ADMIN_ROLE =\\n        keccak256(\\\"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE\\\");\\n\\n    /**\\n     * @notice actor that can manage MGloRedemptionVault\\n     */\\n    bytes32 public constant M_GLO_REDEMPTION_VAULT_ADMIN_ROLE =\\n        keccak256(\\\"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE\\\");\\n\\n    /**\\n     * @notice actor that can manage MGloCustomAggregatorFeed and MGloDataFeed\\n     */\\n    bytes32 public constant M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE =\\n        keccak256(\\\"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE\\\");\\n\\n    /**\\n     * @notice greenlist role for mGLO\\n     */\\n    bytes32 public constant M_GLOBAL_GREENLISTED_ROLE =\\n        keccak256(\\\"M_GLOBAL_GREENLISTED_ROLE\\\");\\n}\\n\",\"keccak256\":\"0x15b0faa8feb2a18a31b4503d72622b194117da0098535adb1bebda876a80f995\",\"license\":\"MIT\"}},\"version\":1}","userdoc":{"kind":"user","notice":"AggregatorV3 compatible feed for mGLO, where price is submitted manually by feed admins","methods":{"maxAnswer()":{"notice":"maximal possible answer that feed can return"},"minAnswer()":{"notice":"minimal possible answer that feed can return"},"description()":{"notice":"feed description"},"latestRound()":{"notice":"last round id"},"accessControl()":{"notice":"MidasAccessControl contract address"},"BLACKLISTED_ROLE()":{"notice":"actor that is blacklisted"},"GREENLISTED_ROLE()":{"notice":"actor that is greenlisted"},"DEFAULT_ADMIN_ROLE()":{"notice":"admin role"},"maxAnswerDeviation()":{"notice":"max deviation from lattest price in %"},"setRoundData(int256)":{"notice":"sets the data for `latestRound` + 1 round id"},"setRoundDataSafe(int256)":{"notice":"works as `setRoundData()`, but also checks the deviation with the lattest submitted data, and that at least 1 hour passed since the lattest submission"},"BLACKLIST_OPERATOR_ROLE()":{"notice":"actor that can change black list statuses of addresses"},"GREENLIST_OPERATOR_ROLE()":{"notice":"actor that can change green list statuses of addresses"},"M_GLOBAL_GREENLISTED_ROLE()":{"notice":"greenlist role for mGLO"},"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE()":{"notice":"actor that can manage MGloDepositVault"},"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE()":{"notice":"actor that can manage MGloRedemptionVault"},"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE()":{"notice":"actor that can manage MGloCustomAggregatorFeed and MGloDataFeed"},"initialize(address,int192,int192,uint256,string)":{"notice":"upgradeable pattern contract`s initializer"}},"version":1},"devdoc":{"kind":"dev","title":"MGloCustomAggregatorFeed","author":"RedDuck Software","methods":{"lastAnswer()":{"returns":{"_0":"answer of lattest price submission"}},"feedAdminRole()":{"details":"describes a role, owner of which can update prices in this feed","returns":{"_0":"role descriptor"}},"lastTimestamp()":{"returns":{"_0":"timestamp of lattest price submission"}},"setRoundData(int256)":{"params":{"_data":"data value"},"details":"`_data` should be >= `minAnswer` and <= `maxAnswer`. Function should be called only from address with `feedAdminRole()`"},"setRoundDataSafe(int256)":{"params":{"_data":"data value"},"details":"deviation with previous data needs to be <= `maxAnswerDeviation`"},"initialize(address,int192,int192,uint256,string)":{"params":{"_maxAnswer":"init value for `maxAnswer`. Should be > `_minAnswer`","_minAnswer":"init value for `minAnswer`. Should be < `_maxAnswer`","_description":"init value for `description`","_accessControl":"address of MidasAccessControll contract","_maxAnswerDeviation":"init value for `maxAnswerDeviation`"}}},"version":1,"stateVariables":{"__gap":{"details":"leaving a storage gap for futures updates"}}},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint8":{"label":"uint8","encoding":"inplace","numberOfBytes":"1"},"t_int192":{"label":"int192","encoding":"inplace","numberOfBytes":"24"},"t_int256":{"label":"int256","encoding":"inplace","numberOfBytes":"32"},"t_uint80":{"label":"uint80","encoding":"inplace","numberOfBytes":"10"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_array(t_uint256)50_storage":{"base":"t_uint256","label":"uint256[50]","encoding":"inplace","numberOfBytes":"1600"},"t_struct(RoundData)3499_storage":{"label":"struct CustomAggregatorV3CompatibleFeed.RoundData","members":[{"slot":"0","type":"t_uint80","astId":3490,"label":"roundId","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"1","type":"t_int256","astId":3492,"label":"answer","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"2","type":"t_uint256","astId":3494,"label":"startedAt","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"3","type":"t_uint256","astId":3496,"label":"updatedAt","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"4","type":"t_uint80","astId":3498,"label":"answeredInRound","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"}],"encoding":"inplace","numberOfBytes":"160"},"t_contract(MidasAccessControl)3335":{"label":"contract MidasAccessControl","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_uint80,t_struct(RoundData)3499_storage)":{"key":"t_uint80","label":"mapping(uint80 => struct CustomAggregatorV3CompatibleFeed.RoundData)","value":"t_struct(RoundData)3499_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint8","astId":461,"label":"_initialized","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"0","type":"t_bool","astId":464,"label":"_initializing","offset":1,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"0","type":"t_contract(MidasAccessControl)3335","astId":3380,"label":"accessControl","offset":2,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"1","type":"t_array(t_uint256)50_storage","astId":3385,"label":"__gap","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"51","type":"t_string_storage","astId":3503,"label":"description","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"52","type":"t_uint80","astId":3506,"label":"latestRound","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"53","type":"t_uint256","astId":3509,"label":"maxAnswerDeviation","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"54","type":"t_int192","astId":3512,"label":"minAnswer","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"55","type":"t_int192","astId":3515,"label":"maxAnswer","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"56","type":"t_mapping(t_uint80,t_struct(RoundData)3499_storage)","astId":3521,"label":"_roundData","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"},{"slot":"57","type":"t_array(t_uint256)50_storage","astId":4000,"label":"__gap","offset":0,"contract":"contracts/products/mGLO/MGloCustomAggregatorFeed.sol:MGloCustomAggregatorFeed"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"333:412:23:-:0;;;;;;;;;;;;-1:-1:-1;502:22:16;:20;:22::i;:::-;333:412:23;;5939:280:3;6007:13;;;;;;;6006:14;5998:66;;;;-1:-1:-1;;;5998:66:3;;216:2:25;5998:66:3;;;198:21:25;255:2;235:18;;;228:30;294:34;274:18;;;267:62;-1:-1:-1;;;345:18:25;;;338:37;392:19;;5998:66:3;;;;;;;;6078:12;;6094:15;6078:12;;;:31;6074:139;;6125:12;:30;;-1:-1:-1;;6125:30:3;6140:15;6125:30;;;;;;6174:28;;564:36:25;;;6174:28:3;;552:2:25;537:18;6174:28:3;;;;;;;6074:139;5939:280::o;422:184:25:-;333:412:23;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"333:412:23:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;616:127;808:52:24;616:127:23;;;160:25:25;;;148:2;133:18;616:127:23;;;;;;;;532:39:19;;;;;;;;-1:-1:-1;;;;;532:39:19;;;;;;-1:-1:-1;;;;;387:32:25;;;369:51;;357:2;342:18;532:39:19;196:230:25;320:94:18;;378:36;320:94;;5115:112:20;5198:11;;-1:-1:-1;;;;;5198:11:20;5161:7;5187:23;;;:10;:23;;;;;:33;;;5115:112;;665:72:18;;708:29;665:72;;1214:23:20;;;;;;;;;;;;786:2:25;775:22;;;;757:41;;745:2;730:18;1214:23:20;613:191:25;6097:73:20;;;6162:1;951:36:25;;939:2;924:18;6097:73:20;809:184:25;330:108:24;;395:43;330:108;;507:94:18;;565:36;507:94;;4787:76:20;4855:1;4787:76;;518:114:24;;586:46;518:114;;801:72:18;;844:29;801:72;;942:25:20;;;;;-1:-1:-1;;;;;942:25:20;;;;;;-1:-1:-1;;;;;1160:35:25;;;1142:54;;1130:2;1115:18;942:25:20;998:204:25;1320:23:20;;;;;;;;;856:34;;;:::i;:::-;;;;;;;:::i;1098:33::-;;;;;;3111:455;;;;;;:::i;:::-;;:::i;:::-;;2195:606;;;;;;:::i;:::-;;:::i;5290:510::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3750:15:25;;;3732:34;;3797:2;3782:18;;3775:34;;;;3825:18;;3818:34;;;;3883:2;3868:18;;3861:34;3932:15;;;3926:3;3911:19;;3904:44;3678:3;3663:19;5290:510:20;3438:516:25;734:126:24;;808:52;734:126;;409:49:19;;454:4;409:49;;3818:553:20;;;;;;:::i;:::-;;:::i;4935:105::-;5014:11;;-1:-1:-1;;;;;5014:11:20;4978:6;5003:23;;;:10;:23;;;;;5014:11;5003:30;;4935:105;;922:98:24;;982:38;922:98;;4434:290:20;;;:::i;856:34::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3111:455::-;5198:11;;-1:-1:-1;;;;;5198:11:20;3170:22;5187:23;;;:10;:23;;;;;:33;;;3225:19;;3221:176;;5014:11;;-1:-1:-1;;;;;5014:11:20;3260:17;5003:23;;;:10;:23;;;;;5014:11;5003:30;;3280:34;;3308:5;3280:13;:34::i;:::-;3260:54;;3349:18;;3336:9;:31;;3328:58;;;;-1:-1:-1;;;3328:58:20;;4726:2:25;3328:58:20;;;4708:21:25;4765:2;4745:18;;;4738:30;-1:-1:-1;;;4784:18:25;;;4777:44;4838:18;;3328:58:20;;;;;;;;;3246:151;3221:176;3463:7;3428:32;3446:14;3428:15;:32;:::i;:::-;:42;3407:115;;;;-1:-1:-1;;;3407:115:20;;5331:2:25;3407:115:20;;;5313:21:25;5370:2;5350:18;;;5343:30;5409:28;5389:18;;;5382:56;5455:18;;3407:115:20;5129:350:25;3407:115:20;3540:19;3553:5;3540:12;:19::i;:::-;3533:26;3111:455;:::o;2195:606::-;3279:19:3;3302:13;;;;;;3301:14;;3347:34;;;;-1:-1:-1;3365:12:3;;3380:1;3365:12;;;;:16;3347:34;3346:108;;;-1:-1:-1;3426:4:3;1713:19:9;:23;;;3387:66:3;;-1:-1:-1;3436:12:3;;;;;:17;3387:66;3325:201;;;;-1:-1:-1;;;3325:201:3;;5686:2:25;3325:201:3;;;5668:21:25;5725:2;5705:18;;;5698:30;5764:34;5744:18;;;5737:62;-1:-1:-1;;;5815:18:25;;;5808:44;5869:19;;3325:201:3;5484:410:25;3325:201:3;3536:12;:16;;-1:-1:-1;;3536:16:3;3551:1;3536:16;;;3562:65;;;;3596:13;:20;;-1:-1:-1;;3596:20:3;;;;;3562:65;2419:45:20::1;2449:14;2419:29;:45::i;:::-;2496:10;2483:23;;:10;:23;;;2475:48;;;::::0;-1:-1:-1;;;2475:48:20;;6101:2:25;2475:48:20::1;::::0;::::1;6083:21:25::0;6140:2;6120:18;;;6113:30;-1:-1:-1;;;6159:18:25;;;6152:42;6211:18;;2475:48:20::1;5899:336:25::0;2475:48:20::1;2584:14;6162:1:::0;2584:2:::1;:14;:::i;:::-;2577:22;::::0;:3:::1;:22;:::i;:::-;2554:19;:45;;2533:110;;;::::0;-1:-1:-1;;;2533:110:20;;7998:2:25;2533:110:20::1;::::0;::::1;7980:21:25::0;8037:2;8017:18;;;8010:30;-1:-1:-1;;;8056:18:25;;;8049:48;8114:18;;2533:110:20::1;7796:342:25::0;2533:110:20::1;2654:9;:22:::0;;-1:-1:-1;;;;;2654:22:20;;;-1:-1:-1;;;;;;2654:22:20;;::::1;;::::0;;;2686:9:::1;:22:::0;;;;;;;;::::1;::::0;;;::::1;::::0;;2718:18:::1;:40:::0;;;2768:26:::1;:11;2782:12:::0;;2768:26:::1;:::i;:::-;;3651:14:3::0;3647:99;;;3697:5;3681:21;;-1:-1:-1;;3681:21:3;;;3721:14;;-1:-1:-1;951:36:25;;3721:14:3;;939:2:25;924:18;3721:14:3;;;;;;;3647:99;3269:483;2195:606:20;;;;;;:::o;5290:510::-;-1:-1:-1;;;;;5580:20:20;;;5387:14;5580:20;;;:10;:20;;;;;;;;;5551:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5290:510::o;3818:553::-;1708:38;808:52:24;1735:10:20;1708:9;:38::i;:::-;3921:9:::1;::::0;::::1;;3912:18:::0;::::1;::::0;::::1;::::0;:40:::1;;-1:-1:-1::0;3943:9:20::1;::::0;::::1;;3934:18:::0;::::1;;3912:40;3891:107;;;::::0;-1:-1:-1;;;3891:107:20;;8544:2:25;3891:107:20::1;::::0;::::1;8526:21:25::0;8583:2;8563:18;;;8556:30;-1:-1:-1;;;8602:18:25;;;8595:50;8662:18;;3891:107:20::1;8342:344:25::0;3891:107:20::1;4026:11;::::0;4009:14:::1;::::0;4026:15:::1;::::0;-1:-1:-1;;;;;4026:11:20::1;::::0;:15:::1;:::i;:::-;4074:196;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;4074:196:20;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;4166:15:::1;4074:196:::0;;;;;;;;;;;;;;;;;;-1:-1:-1;4052:19:20;;;:10:::1;:19:::0;;;;;;:218;;;;;;::::1;-1:-1:-1::0;;4052:218:20;;::::1;;::::0;;;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;4281:11:::1;:21:::0;;;;::::1;::::0;::::1;::::0;;;4318:46;;4009:32;;-1:-1:-1;4166:15:20;;4136:5;;4318:46:::1;::::0;::::1;3881:490;3818:553:::0;:::o;4434:290::-;4705:11;;4521:14;;;;;;;;;;4692:25;;-1:-1:-1;;;;;4705:11:20;4692:12;:25::i;:::-;4685:32;;;;;;;;;;4434:290;;;;;:::o;6326:442::-;6433:7;6460:14;6456:47;;6489:14;6162:1;6489:2;:14;:::i;:::-;6483:20;;:3;:20;:::i;:::-;6476:27;;;;6456:47;6513:10;6533:14;6162:1;6533:2;:14;:::i;:::-;6513:35;-1:-1:-1;6558:15:20;6576:22;6588:10;6576:9;:22;:::i;:::-;6558:40;-1:-1:-1;6608:16:20;6652:10;6628:14;6639:3;6558:40;6628:14;:::i;:::-;:20;;6645:3;6628:20;:::i;:::-;6627:35;;;;:::i;:::-;6608:54;;6696:1;6684:9;:13;:42;;6717:9;6684:42;;;6700:14;:9;-1:-1:-1;;6700:14:20;:::i;:::-;6672:54;-1:-1:-1;;;;6326:442:20;;;;;:::o;1157:239:19:-;5374:13:3;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:3;;10263:2:25;5366:69:3;;;10245:21:25;10302:2;10282:18;;;10275:30;10341:34;10321:18;;;10314:62;-1:-1:-1;;;10392:18:25;;;10385:41;10443:19;;5366:69:3;10061:407:25;5366:69:3;-1:-1:-1;;;;;1284:28:19;::::1;1276:53;;;::::0;-1:-1:-1;;;1276:53:19;;10675:2:25;1276:53:19::1;::::0;::::1;10657:21:25::0;10714:2;10694:18;;;10687:30;-1:-1:-1;;;10733:18:25;;;10726:42;10785:18;;1276:53:19::1;10473:336:25::0;1276:53:19::1;1339:13;:50:::0;;-1:-1:-1;;;;;1339:50:19;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;1339:50:19;;::::1;::::0;;;::::1;::::0;;1157:239::o;1470:146::-;1552:13;;:36;;-1:-1:-1;;;1552:36:19;;;;;10988:25:25;;;-1:-1:-1;;;;;11049:32:25;;;11029:18;;;11022:60;1552:13:19;;;;;;;;:21;;10961:18:25;;1552:36:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1544:65;;;;-1:-1:-1;;;1544:65:19;;11577:2:25;1544:65:19;;;11559:21:25;11616:2;11596:18;;;11589:30;-1:-1:-1;;;11635:18:25;;;11628:46;11691:18;;1544:65:19;11375:340:25;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;1207:597:25;1319:4;1348:2;1377;1366:9;1359:21;1409:6;1403:13;1452:6;1447:2;1436:9;1432:18;1425:34;1477:1;1487:140;1501:6;1498:1;1495:13;1487:140;;;1596:14;;;1592:23;;1586:30;1562:17;;;1581:2;1558:26;1551:66;1516:10;;1487:140;;;1645:6;1642:1;1639:13;1636:91;;;1715:1;1710:2;1701:6;1690:9;1686:22;1682:31;1675:42;1636:91;-1:-1:-1;1788:2:25;1767:15;-1:-1:-1;;1763:29:25;1748:45;;;;1795:2;1744:54;;1207:597;-1:-1:-1;;;1207:597:25:o;1809:179::-;1867:6;1920:2;1908:9;1899:7;1895:23;1891:32;1888:52;;;1936:1;1933;1926:12;1888:52;-1:-1:-1;1959:23:25;;1809:179;-1:-1:-1;1809:179:25:o;1993:162::-;2060:20;;2120:2;2109:21;;;2099:32;;2089:60;;2145:1;2142;2135:12;2089:60;1993:162;;;:::o;2160:980::-;2265:6;2273;2281;2289;2297;2305;2358:3;2346:9;2337:7;2333:23;2329:33;2326:53;;;2375:1;2372;2365:12;2326:53;2401:23;;-1:-1:-1;;;;;2453:31:25;;2443:42;;2433:70;;2499:1;2496;2489:12;2433:70;2522:5;-1:-1:-1;2546:37:25;2579:2;2564:18;;2546:37;:::i;:::-;2536:47;;2602:37;2635:2;2624:9;2620:18;2602:37;:::i;:::-;2592:47;;2686:2;2675:9;2671:18;2658:32;2648:42;;2741:3;2730:9;2726:19;2713:33;2765:18;2806:2;2798:6;2795:14;2792:34;;;2822:1;2819;2812:12;2792:34;2860:6;2849:9;2845:22;2835:32;;2905:7;2898:4;2894:2;2890:13;2886:27;2876:55;;2927:1;2924;2917:12;2876:55;2967:2;2954:16;2993:2;2985:6;2982:14;2979:34;;;3009:1;3006;2999:12;2979:34;3054:7;3049:2;3040:6;3036:2;3032:15;3028:24;3025:37;3022:57;;;3075:1;3072;3065:12;3022:57;3106:2;3102;3098:11;3088:21;;3128:6;3118:16;;;;;2160:980;;;;;;;;:::o;3145:288::-;3203:6;3256:2;3244:9;3235:7;3231:23;3227:32;3224:52;;;3272:1;3269;3262:12;3224:52;3311:9;3298:23;-1:-1:-1;;;;;3354:5:25;3350:34;3343:5;3340:45;3330:73;;3399:1;3396;3389:12;3330:73;3422:5;3145:288;-1:-1:-1;;;3145:288:25:o;4139:380::-;4218:1;4214:12;;;;4261;;;4282:61;;4336:4;4328:6;4324:17;4314:27;;4282:61;4389:2;4381:6;4378:14;4358:18;4355:38;4352:161;;;4435:10;4430:3;4426:20;4423:1;4416:31;4470:4;4467:1;4460:15;4498:4;4495:1;4488:15;4352:161;;4139:380;;;:::o;4867:127::-;4928:10;4923:3;4919:20;4916:1;4909:31;4959:4;4956:1;4949:15;4983:4;4980:1;4973:15;4999:125;5039:4;5067:1;5064;5061:8;5058:34;;;5072:18;;:::i;:::-;-1:-1:-1;5109:9:25;;4999:125::o;6240:422::-;6329:1;6372:5;6329:1;6386:270;6407:7;6397:8;6394:21;6386:270;;;6466:4;6462:1;6458:6;6454:17;6448:4;6445:27;6442:53;;;6475:18;;:::i;:::-;6525:7;6515:8;6511:22;6508:55;;;6545:16;;;;6508:55;6624:22;;;;6584:15;;;;6386:270;;;6390:3;6240:422;;;;;:::o;6667:806::-;6716:5;6746:8;6736:80;;-1:-1:-1;6787:1:25;6801:5;;6736:80;6835:4;6825:76;;-1:-1:-1;6872:1:25;6886:5;;6825:76;6917:4;6935:1;6930:59;;;;7003:1;6998:130;;;;6910:218;;6930:59;6960:1;6951:10;;6974:5;;;6998:130;7035:3;7025:8;7022:17;7019:43;;;7042:18;;:::i;:::-;-1:-1:-1;;7098:1:25;7084:16;;7113:5;;6910:218;;7212:2;7202:8;7199:16;7193:3;7187:4;7184:13;7180:36;7174:2;7164:8;7161:16;7156:2;7150:4;7147:12;7143:35;7140:77;7137:159;;;-1:-1:-1;7249:19:25;;;7281:5;;7137:159;7328:34;7353:8;7347:4;7328:34;:::i;:::-;7398:6;7394:1;7390:6;7386:19;7377:7;7374:32;7371:58;;;7409:18;;:::i;:::-;7447:20;;6667:806;-1:-1:-1;;;6667:806:25:o;7478:140::-;7536:5;7565:47;7606:4;7596:8;7592:19;7586:4;7565:47;:::i;7623:168::-;7663:7;7729:1;7725;7721:6;7717:14;7714:1;7711:21;7706:1;7699:9;7692:17;7688:45;7685:71;;;7736:18;;:::i;:::-;-1:-1:-1;7776:9:25;;7623:168::o;8691:240::-;8730:3;-1:-1:-1;;;;;8807:2:25;8804:1;8800:10;8837:2;8834:1;8830:10;8868:3;8864:2;8860:12;8855:3;8852:21;8849:47;;;8876:18;;:::i;:::-;8912:13;;8691:240;-1:-1:-1;;;;8691:240:25:o;8936:267::-;8975:4;9004:9;;;9029:10;;-1:-1:-1;;;9048:19:25;;9041:27;;9025:44;9022:70;;;9072:18;;:::i;:::-;-1:-1:-1;;;;;9119:27:25;;9112:35;;9104:44;;9101:70;;;9151:18;;:::i;:::-;-1:-1:-1;;9188:9:25;;8936:267::o;9208:553::-;9247:7;-1:-1:-1;;;;;9317:9:25;;;9345;;;9370:11;;;9389:10;;;9383:17;;9366:35;9363:61;;;9404:18;;:::i;:::-;-1:-1:-1;;;9480:1:25;9473:9;;9498:11;;;9518;;;9511:19;;9494:37;9491:63;;;9534:18;;:::i;:::-;9580:1;9577;9573:9;9563:19;;9627:1;9623:2;9618:11;9615:1;9611:19;9606:2;9602;9598:11;9594:37;9591:63;;;9634:18;;:::i;:::-;9699:1;9695:2;9690:11;9687:1;9683:19;9678:2;9674;9670:11;9666:37;9663:63;;;9706:18;;:::i;:::-;-1:-1:-1;;;9746:9:25;;;;;9208:553;-1:-1:-1;;;9208:553:25:o;9766:290::-;9805:1;9831;9821:132;;9875:10;9870:3;9866:20;9863:1;9856:31;9910:4;9907:1;9900:15;9938:4;9935:1;9928:15;9821:132;-1:-1:-1;;;9969:18:25;;-1:-1:-1;;9989:13:25;;9965:38;9962:64;;;10006:18;;:::i;:::-;-1:-1:-1;10040:10:25;;9766:290::o;11093:277::-;11160:6;11213:2;11201:9;11192:7;11188:23;11184:32;11181:52;;;11229:1;11226;11219:12;11181:52;11261:9;11255:16;11314:5;11307:13;11300:21;11293:5;11290:32;11280:60;;11336:1;11333;11326:12","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"accessControl()","signatureHash4":"0x13007d55","signatureHash32":"0x13007d55f557a45612c4afdb48dab1774f1e9a1a60e53c68ae604e2cf641ec3b"},{"signature":"BLACKLISTED_ROLE()","signatureHash4":"0x62b199c5","signatureHash32":"0x62b199c53f0339ed24e4f3a93c367bfacef7126960c007a8e8e3ca24843fb976"},{"signature":"BLACKLIST_OPERATOR_ROLE()","signatureHash4":"0x5300b4ba","signatureHash32":"0x5300b4babd0e2c758fbf67fa5344eb7ccd02f26282abcfd122cf15cc0e0bf6e9"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"DEFAULT_ADMIN_ROLE()","signatureHash4":"0xa217fddf","signatureHash32":"0xa217fddfde7807bb766525e432eeeecaaf4de889a05e8df9fb827257fb978cf4"},{"signature":"description()","signatureHash4":"0x7284e416","signatureHash32":"0x7284e416b404dc25ce1d7ccfcfdd0c385b0e836e94b9e6364e5c3cc120e5a43c"},{"signature":"feedAdminRole()","signatureHash4":"0x0ccb6a8e","signatureHash32":"0x0ccb6a8e8ec96de47f60b770f4ed7f7387f7254f844c7cc7d8c9ea601276a7d2"},{"signature":"getRoundData(uint80)","signatureHash4":"0x9a6fc8f5","signatureHash32":"0x9a6fc8f5bd1d333aff9fc77c09f6631020497d65346af0bdf49de784b6868a8d"},{"signature":"GREENLISTED_ROLE()","signatureHash4":"0x1ed41163","signatureHash32":"0x1ed41163106681dd8e6e4676317136188cac9908f363f7587447b02c89fb3982"},{"signature":"GREENLIST_OPERATOR_ROLE()","signatureHash4":"0x15b9598a","signatureHash32":"0x15b9598ae4469d9a33f8ca020f379f613b69c2062883e974d70e171b560d480e"},{"signature":"initialize(address,int192,int192,uint256,string)","signatureHash4":"0x8ffabcdb","signatureHash32":"0x8ffabcdb049a2f0270edc2cfcf725af2c6fe1c1793c165e612282fd88bfed6db"},{"signature":"lastAnswer()","signatureHash4":"0xbb23ae25","signatureHash32":"0xbb23ae257dcfa92342d78c0a5715079a175219921d14199fd0ff950d8ed7c52b"},{"signature":"lastTimestamp()","signatureHash4":"0x19d8ac61","signatureHash32":"0x19d8ac61717496e3e6fc2884b766fdce06db87c3be335b1266e8b7d31a1ccd01"},{"signature":"latestRound()","signatureHash4":"0x668a0f02","signatureHash32":"0x668a0f0276948a71d2eeb20f9a8cdb93ad42215df8774e2bee2df85a54e38165"},{"signature":"latestRoundData()","signatureHash4":"0xfeaf968c","signatureHash32":"0xfeaf968c92170f878bbe01f267c8c6f5faf34a9192f39d9bd2b066b6cbfd3a06"},{"signature":"maxAnswer()","signatureHash4":"0x70da2f67","signatureHash32":"0x70da2f672045711cd7869d9b9f0be88f77f6a6d6592ba51e61dd178129166899"},{"signature":"maxAnswerDeviation()","signatureHash4":"0x78d3f14e","signatureHash32":"0x78d3f14ecfe74ab807b9362d4eb6ce87d0da8c947e19a06fe64d0fe94883230d"},{"signature":"M_GLOBAL_GREENLISTED_ROLE()","signatureHash4":"0xd74bc41d","signatureHash32":"0xd74bc41d4279aae901b95fe0483406332bc6abb52d918cf730ec1a4aa3919661"},{"signature":"M_GLO_CUSTOM_AGGREGATOR_FEED_ADMIN_ROLE()","signatureHash4":"0x9d6bb3e8","signatureHash32":"0x9d6bb3e81bd6fb734d681553462c240073f6d8815b8eb8c1b7a2044b96b0d527"},{"signature":"M_GLO_DEPOSIT_VAULT_ADMIN_ROLE()","signatureHash4":"0x5245b919","signatureHash32":"0x5245b919e1ec52307b5f97a7e9f12389ada91b14530920ae12488d792366c95f"},{"signature":"M_GLO_REDEMPTION_VAULT_ADMIN_ROLE()","signatureHash4":"0x5fdafbc1","signatureHash32":"0x5fdafbc1aa8590c63b250dacf8f15ee711d2528221573732851d183e5d0dba4e"},{"signature":"minAnswer()","signatureHash4":"0x22adbc78","signatureHash32":"0x22adbc7820a295373010a666e189155fbda68595e031522b43bf4b1e75a9e13e"},{"signature":"setRoundData(int256)","signatureHash4":"0xa4381d1f","signatureHash32":"0xa4381d1f2276f3ceb76427945f5660479661094fb11cc954ec4bebd7c534ecc7"},{"signature":"setRoundDataSafe(int256)","signatureHash4":"0x89d6e95f","signatureHash32":"0x89d6e95fa6aca3e51d6bf52d352f7cb9846978f949894b1436ce0988cbe4200d"},{"signature":"version()","signatureHash4":"0x54fd4d50","signatureHash32":"0x54fd4d50fce680dbc2593d9e893064bfa880e5642d0036394e1a1849f7fc0749"}],"event":[{"signature":"AnswerUpdated(int256,uint256,uint256)","signatureHash4":"0x0559884f","signatureHash32":"0x0559884fd3a460db3073b7fc896cc77986f16e378210ded43186175bf646fc5f"},{"signature":"Initialized(uint8)","signatureHash4":"0x7f26b83f","signatureHash32":"0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"8453","address":"0x4A0a3eAb5c75173C760B5a50a8570e5D20D9cC94"}