{"matchId":"27472578","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-04-01T13:56:24Z","creationBytecode":{"onchainBytecode":"0x6080604052348015600e575f5ffd5b50610af48061001c5f395ff3fe60806040526004361061013d575f3560e01c8063a5eb43ef116100bb578063dacb541911610071578063e8025d7711610057578063e8025d77146102ab578063ec0484011461028a578063f4bfa000146102c5575f5ffd5b8063dacb54191461026f578063dd4cbf6b1461028a575f5ffd5b8063ad967e15116100a1578063ad967e1514610239578063c2da75f01461017a578063c609684a146101cc575f5ffd5b8063a5eb43ef1461017a578063ac862bfa146101cc575f5ffd5b806354bb0c1d116101105780637f7b6002116100f65780637f7b6002146101e65780638f0c2916146102005780639dde59771461021f575f5ffd5b806354bb0c1d146101b25780637a4df6eb146101cc575f5ffd5b806301b88f861461014157806302c6bb6a146101605780633f66feff1461017a5780633fad77fc14610198575b5f5ffd5b34801561014c575f5ffd5b5061015e61015b366004610419565b50565b005b34801561016b575f5ffd5b5061015e61015b36600461051b565b348015610185575f5ffd5b5061015e61019436600461064c565b5050565b3480156101a3575f5ffd5b5061015e61019436600461068b565b3480156101bd575f5ffd5b5061015e61015b3660046106fc565b3480156101d7575f5ffd5b5061015e61019436600461075d565b3480156101f1575f5ffd5b5061015e610194366004610790565b34801561020b575f5ffd5b5061015e61021a3660046107f1565b505050565b34801561022a575f5ffd5b5061015e61019436600461082b565b6102556102473660046108ca565b5f5f97509795505050505050565b604080519283526020830191909152015b60405180910390f35b61025561027d36600461094d565b5f5f965096945050505050565b348015610295575f5ffd5b5061015e6102a43660046109c0565b5050505050565b3480156102b6575f5ffd5b5061015e61015b366004610a40565b3480156102d0575f5ffd5b506102e86102df36600461075d565b50606091829150565b604051610266929190610a91565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b60405160e0810167ffffffffffffffff81118282101715610346576103466102f6565b60405290565b60405160c0810167ffffffffffffffff81118282101715610346576103466102f6565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff811182821017156103b6576103b66102f6565b604052919050565b5f67ffffffffffffffff8211156103d7576103d76102f6565b5060051b60200190565b803573ffffffffffffffffffffffffffffffffffffffff81168114610404575f5ffd5b919050565b803560ff81168114610404575f5ffd5b5f60208284031215610429575f5ffd5b813567ffffffffffffffff81111561043f575f5ffd5b8201601f8101841361044f575f5ffd5b803561046261045d826103be565b61036f565b80828252602082019150602060e08402850101925086831115610483575f5ffd5b6020840193505b828410156105115760e084880312156104a1575f5ffd5b6104a9610323565b6104b2856103e1565b81526104c0602086016103e1565b60208201526104d160408601610409565b6040820152606085810135908201526080808601359082015260a0808601359082015260c08086013590820152825260e09093019260209091019061048a565b9695505050505050565b5f6020828403121561052b575f5ffd5b813567ffffffffffffffff811115610541575f5ffd5b8201601f81018413610551575f5ffd5b803561055f61045d826103be565b80828252602082019150602060c08402850101925086831115610580575f5ffd5b6020840193505b828410156105115760c0848803121561059e575f5ffd5b6105a661034c565b6105af856103e1565b81526105bd602086016103e1565b60208201526105ce60408601610409565b6040820152606085810135908201526080808601359082015260a08086013590820152825260c090930192602090910190610587565b5f5f83601f840112610614575f5ffd5b50813567ffffffffffffffff81111561062b575f5ffd5b6020830191508360208260061b8501011115610645575f5ffd5b9250929050565b5f5f6020838503121561065d575f5ffd5b823567ffffffffffffffff811115610673575f5ffd5b61067f85828601610604565b90969095509350505050565b5f5f6020838503121561069c575f5ffd5b823567ffffffffffffffff8111156106b2575f5ffd5b8301601f810185136106c2575f5ffd5b803567ffffffffffffffff8111156106d8575f5ffd5b85602060a0830284010111156106ec575f5ffd5b6020919091019590945092505050565b5f6020828403121561070c575f5ffd5b610715826103e1565b9392505050565b5f5f83601f84011261072c575f5ffd5b50813567ffffffffffffffff811115610743575f5ffd5b6020830191508360208260051b8501011115610645575f5ffd5b5f5f6020838503121561076e575f5ffd5b823567ffffffffffffffff811115610784575f5ffd5b61067f8582860161071c565b5f5f602083850312156107a1575f5ffd5b823567ffffffffffffffff8111156107b7575f5ffd5b8301601f810185136107c7575f5ffd5b803567ffffffffffffffff8111156107dd575f5ffd5b8560208260071b84010111156106ec575f5ffd5b5f5f5f60608486031215610803575f5ffd5b61080c846103e1565b925061081a602085016103e1565b929592945050506040919091013590565b5f5f6020838503121561083c575f5ffd5b823567ffffffffffffffff811115610852575f5ffd5b8301601f81018513610862575f5ffd5b803567ffffffffffffffff811115610878575f5ffd5b85602060e0830284010111156106ec575f5ffd5b5f5f83601f84011261089c575f5ffd5b50813567ffffffffffffffff8111156108b3575f5ffd5b602083019150836020828501011115610645575f5ffd5b5f5f5f5f5f5f5f60c0888a0312156108e0575f5ffd5b6108e9886103e1565b96506020880135955060408801359450610905606089016103e1565b9350610913608089016103e1565b925060a088013567ffffffffffffffff81111561092e575f5ffd5b61093a8a828b0161088c565b989b979a50959850939692959293505050565b5f5f5f5f5f5f60a08789031215610962575f5ffd5b61096b876103e1565b9550610979602088016103e1565b94506040870135935060608701359250608087013567ffffffffffffffff8111156109a2575f5ffd5b6109ae89828a0161088c565b979a9699509497509295939492505050565b5f5f5f5f5f606086880312156109d4575f5ffd5b6109dd866103e1565b9450602086013567ffffffffffffffff8111156109f8575f5ffd5b610a048882890161071c565b909550935050604086013567ffffffffffffffff811115610a23575f5ffd5b610a2f8882890161071c565b969995985093965092949392505050565b5f60208284031215610a50575f5ffd5b5035919050565b5f8151808452602084019350602083015f5b82811015610a87578151865260209586019590910190600101610a69565b5093949350505050565b604081525f610aa36040830185610a57565b8281036020840152610ab58185610a57565b9594505050505056fea264697066735822122084ad68f5bca444fed215be9338cbb66890517388c6b0f2fe5a242279fb33d84e64736f6c634300081d0033","recompiledBytecode":"0x6080604052348015600e575f5ffd5b50610af48061001c5f395ff3fe60806040526004361061013d575f3560e01c8063a5eb43ef116100bb578063dacb541911610071578063e8025d7711610057578063e8025d77146102ab578063ec0484011461028a578063f4bfa000146102c5575f5ffd5b8063dacb54191461026f578063dd4cbf6b1461028a575f5ffd5b8063ad967e15116100a1578063ad967e1514610239578063c2da75f01461017a578063c609684a146101cc575f5ffd5b8063a5eb43ef1461017a578063ac862bfa146101cc575f5ffd5b806354bb0c1d116101105780637f7b6002116100f65780637f7b6002146101e65780638f0c2916146102005780639dde59771461021f575f5ffd5b806354bb0c1d146101b25780637a4df6eb146101cc575f5ffd5b806301b88f861461014157806302c6bb6a146101605780633f66feff1461017a5780633fad77fc14610198575b5f5ffd5b34801561014c575f5ffd5b5061015e61015b366004610419565b50565b005b34801561016b575f5ffd5b5061015e61015b36600461051b565b348015610185575f5ffd5b5061015e61019436600461064c565b5050565b3480156101a3575f5ffd5b5061015e61019436600461068b565b3480156101bd575f5ffd5b5061015e61015b3660046106fc565b3480156101d7575f5ffd5b5061015e61019436600461075d565b3480156101f1575f5ffd5b5061015e610194366004610790565b34801561020b575f5ffd5b5061015e61021a3660046107f1565b505050565b34801561022a575f5ffd5b5061015e61019436600461082b565b6102556102473660046108ca565b5f5f97509795505050505050565b604080519283526020830191909152015b60405180910390f35b61025561027d36600461094d565b5f5f965096945050505050565b348015610295575f5ffd5b5061015e6102a43660046109c0565b5050505050565b3480156102b6575f5ffd5b5061015e61015b366004610a40565b3480156102d0575f5ffd5b506102e86102df36600461075d565b50606091829150565b604051610266929190610a91565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b60405160e0810167ffffffffffffffff81118282101715610346576103466102f6565b60405290565b60405160c0810167ffffffffffffffff81118282101715610346576103466102f6565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff811182821017156103b6576103b66102f6565b604052919050565b5f67ffffffffffffffff8211156103d7576103d76102f6565b5060051b60200190565b803573ffffffffffffffffffffffffffffffffffffffff81168114610404575f5ffd5b919050565b803560ff81168114610404575f5ffd5b5f60208284031215610429575f5ffd5b813567ffffffffffffffff81111561043f575f5ffd5b8201601f8101841361044f575f5ffd5b803561046261045d826103be565b61036f565b80828252602082019150602060e08402850101925086831115610483575f5ffd5b6020840193505b828410156105115760e084880312156104a1575f5ffd5b6104a9610323565b6104b2856103e1565b81526104c0602086016103e1565b60208201526104d160408601610409565b6040820152606085810135908201526080808601359082015260a0808601359082015260c08086013590820152825260e09093019260209091019061048a565b9695505050505050565b5f6020828403121561052b575f5ffd5b813567ffffffffffffffff811115610541575f5ffd5b8201601f81018413610551575f5ffd5b803561055f61045d826103be565b80828252602082019150602060c08402850101925086831115610580575f5ffd5b6020840193505b828410156105115760c0848803121561059e575f5ffd5b6105a661034c565b6105af856103e1565b81526105bd602086016103e1565b60208201526105ce60408601610409565b6040820152606085810135908201526080808601359082015260a08086013590820152825260c090930192602090910190610587565b5f5f83601f840112610614575f5ffd5b50813567ffffffffffffffff81111561062b575f5ffd5b6020830191508360208260061b8501011115610645575f5ffd5b9250929050565b5f5f6020838503121561065d575f5ffd5b823567ffffffffffffffff811115610673575f5ffd5b61067f85828601610604565b90969095509350505050565b5f5f6020838503121561069c575f5ffd5b823567ffffffffffffffff8111156106b2575f5ffd5b8301601f810185136106c2575f5ffd5b803567ffffffffffffffff8111156106d8575f5ffd5b85602060a0830284010111156106ec575f5ffd5b6020919091019590945092505050565b5f6020828403121561070c575f5ffd5b610715826103e1565b9392505050565b5f5f83601f84011261072c575f5ffd5b50813567ffffffffffffffff811115610743575f5ffd5b6020830191508360208260051b8501011115610645575f5ffd5b5f5f6020838503121561076e575f5ffd5b823567ffffffffffffffff811115610784575f5ffd5b61067f8582860161071c565b5f5f602083850312156107a1575f5ffd5b823567ffffffffffffffff8111156107b7575f5ffd5b8301601f810185136107c7575f5ffd5b803567ffffffffffffffff8111156107dd575f5ffd5b8560208260071b84010111156106ec575f5ffd5b5f5f5f60608486031215610803575f5ffd5b61080c846103e1565b925061081a602085016103e1565b929592945050506040919091013590565b5f5f6020838503121561083c575f5ffd5b823567ffffffffffffffff811115610852575f5ffd5b8301601f81018513610862575f5ffd5b803567ffffffffffffffff811115610878575f5ffd5b85602060e0830284010111156106ec575f5ffd5b5f5f83601f84011261089c575f5ffd5b50813567ffffffffffffffff8111156108b3575f5ffd5b602083019150836020828501011115610645575f5ffd5b5f5f5f5f5f5f5f60c0888a0312156108e0575f5ffd5b6108e9886103e1565b96506020880135955060408801359450610905606089016103e1565b9350610913608089016103e1565b925060a088013567ffffffffffffffff81111561092e575f5ffd5b61093a8a828b0161088c565b989b979a50959850939692959293505050565b5f5f5f5f5f5f60a08789031215610962575f5ffd5b61096b876103e1565b9550610979602088016103e1565b94506040870135935060608701359250608087013567ffffffffffffffff8111156109a2575f5ffd5b6109ae89828a0161088c565b979a9699509497509295939492505050565b5f5f5f5f5f606086880312156109d4575f5ffd5b6109dd866103e1565b9450602086013567ffffffffffffffff8111156109f8575f5ffd5b610a048882890161071c565b909550935050604086013567ffffffffffffffff811115610a23575f5ffd5b610a2f8882890161071c565b969995985093965092949392505050565b5f60208284031215610a50575f5ffd5b5035919050565b5f8151808452602084019350602083015f5b82811015610a87578151865260209586019590910190600101610a69565b5093949350505050565b604081525f610aa36040830185610a57565b8281036020840152610ab58185610a57565b9594505050505056fea264697066735822122084ad68f5bca444fed215be9338cbb66890517388c6b0f2fe5a242279fb33d84e64736f6c634300081d0033","sourceMap":"420:3066:2:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122084ad68f5bca444fed215be9338cbb66890517388c6b0f2fe5a242279fb33d84e64736f6c634300081d0033","offset":2779}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"420:3066:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1903:109;;;;;;;;;;-1:-1:-1;1903:109:2;;;;;:::i;:::-;;;;;1604;;;;;;;;;;-1:-1:-1;1604:109:2;;;;;:::i;524:88::-;;;;;;;;;;-1:-1:-1;524:88:2;;;;;:::i;:::-;;;;1019:102;;;;;;;;;;-1:-1:-1;1019:102:2;;;;;:::i;802:70::-;;;;;;;;;;-1:-1:-1;802:70:2;;;;;:::i;2488:62::-;;;;;;;;;;-1:-1:-1;2488:62:2;;;;;:::i;1317:96::-;;;;;;;;;;-1:-1:-1;1317:96:2;;;;;:::i;1760:::-;;;;;;;;;;-1:-1:-1;1760:96:2;;;;;:::i;:::-;;;;;1168:102;;;;;;;;;;-1:-1:-1;1168:102:2;;;;;:::i;2926:265::-;;;;;;:::i;:::-;3153:16;3171;2926:265;;;;;;;;;;;;;;;10567:25:4;;;10623:2;10608:18;;10601:34;;;;10540:18;2926:265:2;;;;;;;;3238:246;;;;;;:::i;:::-;3446:16;3464;3238:246;;;;;;;;;;2059:113;;;;;;;;;;-1:-1:-1;2059:113:2;;;;;:::i;:::-;;;;;;;919:53;;;;;;;;;;-1:-1:-1;919:53:2;;;;;:::i;2707:172::-;;;;;;;;;;-1:-1:-1;2707:172:2;;;;;:::i;:::-;-1:-1:-1;2797:38:2;;;;-1:-1:-1;2707:172:2;;;;;;;;;:::i;14:184:4:-;66:77;63:1;56:88;163:4;160:1;153:15;187:4;184:1;177:15;203:253;275:2;269:9;317:4;305:17;;352:18;337:34;;373:22;;;334:62;331:88;;;399:18;;:::i;:::-;435:2;428:22;203:253;:::o;461:::-;533:2;527:9;575:4;563:17;;610:18;595:34;;631:22;;;592:62;589:88;;;657:18;;:::i;719:334::-;790:2;784:9;846:2;836:13;;851:66;832:86;820:99;;949:18;934:34;;970:22;;;931:62;928:88;;;996:18;;:::i;:::-;1032:2;1025:22;719:334;;-1:-1:-1;719:334:4:o;1058:199::-;1134:4;1167:18;1159:6;1156:30;1153:56;;;1189:18;;:::i;:::-;-1:-1:-1;1234:1:4;1230:14;1246:4;1226:25;;1058:199::o;1262:196::-;1330:20;;1390:42;1379:54;;1369:65;;1359:93;;1448:1;1445;1438:12;1359:93;1262:196;;;:::o;1463:156::-;1529:20;;1589:4;1578:16;;1568:27;;1558:55;;1609:1;1606;1599:12;1624:1722;1741:6;1794:2;1782:9;1773:7;1769:23;1765:32;1762:52;;;1810:1;1807;1800:12;1762:52;1850:9;1837:23;1883:18;1875:6;1872:30;1869:50;;;1915:1;1912;1905:12;1869:50;1938:22;;1991:4;1983:13;;1979:27;-1:-1:-1;1969:55:4;;2020:1;2017;2010:12;1969:55;2060:2;2047:16;2083:80;2099:63;2155:6;2099:63;:::i;:::-;2083:80;:::i;:::-;2185:3;2209:6;2204:3;2197:19;2241:2;2236:3;2232:12;2225:19;;2299:2;2291:4;2283:6;2279:17;2275:2;2271:26;2267:35;2253:49;;2325:7;2317:6;2314:19;2311:39;;;2346:1;2343;2336:12;2311:39;2378:2;2374;2370:11;2359:22;;2390:926;2406:6;2401:3;2398:15;2390:926;;;2488:4;2482:3;2473:7;2469:17;2465:28;2462:48;;;2506:1;2503;2496:12;2462:48;2536:22;;:::i;:::-;2585:23;2604:3;2585:23;:::i;:::-;2578:5;2571:38;2645:32;2673:2;2668:3;2664:12;2645:32;:::i;:::-;2640:2;2633:5;2629:14;2622:56;2714:30;2740:2;2735:3;2731:12;2714:30;:::i;:::-;2709:2;2698:14;;2691:54;2820:2;2811:12;;;2798:26;2844:14;;;2837:31;2943:3;2934:13;;;2921:27;2968:15;;;2961:32;3068:3;3059:13;;;3046:27;3093:15;;;3086:32;3193:3;3184:13;;;3171:27;3218:15;;;3211:32;3256:18;;2432:4;2423:14;;;;3303:2;3294:12;;;;2390:926;;;3335:5;1624:1722;-1:-1:-1;;;;;;1624:1722:4:o;3351:1597::-;3468:6;3521:2;3509:9;3500:7;3496:23;3492:32;3489:52;;;3537:1;3534;3527:12;3489:52;3577:9;3564:23;3610:18;3602:6;3599:30;3596:50;;;3642:1;3639;3632:12;3596:50;3665:22;;3718:4;3710:13;;3706:27;-1:-1:-1;3696:55:4;;3747:1;3744;3737:12;3696:55;3787:2;3774:16;3810:80;3826:63;3882:6;3826:63;:::i;3810:80::-;3912:3;3936:6;3931:3;3924:19;3968:2;3963:3;3959:12;3952:19;;4026:2;4018:4;4010:6;4006:17;4002:2;3998:26;3994:35;3980:49;;4052:7;4044:6;4041:19;4038:39;;;4073:1;4070;4063:12;4038:39;4105:2;4101;4097:11;4086:22;;4117:801;4133:6;4128:3;4125:15;4117:801;;;4215:4;4209:3;4200:7;4196:17;4192:28;4189:48;;;4233:1;4230;4223:12;4189:48;4263:22;;:::i;:::-;4312:23;4331:3;4312:23;:::i;:::-;4305:5;4298:38;4372:32;4400:2;4395:3;4391:12;4372:32;:::i;:::-;4367:2;4360:5;4356:14;4349:56;4441:30;4467:2;4462:3;4458:12;4441:30;:::i;:::-;4436:2;4425:14;;4418:54;4547:2;4538:12;;;4525:26;4571:14;;;4564:31;4670:3;4661:13;;;4648:27;4695:15;;;4688:32;4795:3;4786:13;;;4773:27;4820:15;;;4813:32;4858:18;;4159:4;4150:14;;;;4905:2;4896:12;;;;4117:801;;4953:387;5036:8;5046:6;5100:3;5093:4;5085:6;5081:17;5077:27;5067:55;;5118:1;5115;5108:12;5067:55;-1:-1:-1;5141:20:4;;5184:18;5173:30;;5170:50;;;5216:1;5213;5206:12;5170:50;5253:4;5245:6;5241:17;5229:29;;5313:3;5306:4;5296:6;5293:1;5289:14;5281:6;5277:27;5273:38;5270:47;5267:67;;;5330:1;5327;5320:12;5267:67;4953:387;;;;;:::o;5345:486::-;5460:6;5468;5521:2;5509:9;5500:7;5496:23;5492:32;5489:52;;;5537:1;5534;5527:12;5489:52;5577:9;5564:23;5610:18;5602:6;5599:30;5596:50;;;5642:1;5639;5632:12;5596:50;5681:90;5763:7;5754:6;5743:9;5739:22;5681:90;:::i;:::-;5790:8;;5655:116;;-1:-1:-1;5345:486:4;-1:-1:-1;;;;5345:486:4:o;5836:647::-;5956:6;5964;6017:2;6005:9;5996:7;5992:23;5988:32;5985:52;;;6033:1;6030;6023:12;5985:52;6073:9;6060:23;6106:18;6098:6;6095:30;6092:50;;;6138:1;6135;6128:12;6092:50;6161:22;;6214:4;6206:13;;6202:27;-1:-1:-1;6192:55:4;;6243:1;6240;6233:12;6192:55;6283:2;6270:16;6309:18;6301:6;6298:30;6295:50;;;6341:1;6338;6331:12;6295:50;6397:7;6392:2;6384:4;6376:6;6372:17;6368:2;6364:26;6360:35;6357:48;6354:68;;;6418:1;6415;6408:12;6354:68;6449:2;6441:11;;;;;6471:6;;-1:-1:-1;5836:647:4;-1:-1:-1;;;5836:647:4:o;6488:186::-;6547:6;6600:2;6588:9;6579:7;6575:23;6571:32;6568:52;;;6616:1;6613;6606:12;6568:52;6639:29;6658:9;6639:29;:::i;:::-;6629:39;6488:186;-1:-1:-1;;;6488:186:4:o;6679:367::-;6742:8;6752:6;6806:3;6799:4;6791:6;6787:17;6783:27;6773:55;;6824:1;6821;6814:12;6773:55;-1:-1:-1;6847:20:4;;6890:18;6879:30;;6876:50;;;6922:1;6919;6912:12;6876:50;6959:4;6951:6;6947:17;6935:29;;7019:3;7012:4;7002:6;6999:1;6995:14;6987:6;6983:27;6979:38;6976:47;6973:67;;;7036:1;7033;7026:12;7051:437;7137:6;7145;7198:2;7186:9;7177:7;7173:23;7169:32;7166:52;;;7214:1;7211;7204:12;7166:52;7254:9;7241:23;7287:18;7279:6;7276:30;7273:50;;;7319:1;7316;7309:12;7273:50;7358:70;7420:7;7411:6;7400:9;7396:22;7358:70;:::i;7493:640::-;7609:6;7617;7670:2;7658:9;7649:7;7645:23;7641:32;7638:52;;;7686:1;7683;7676:12;7638:52;7726:9;7713:23;7759:18;7751:6;7748:30;7745:50;;;7791:1;7788;7781:12;7745:50;7814:22;;7867:4;7859:13;;7855:27;-1:-1:-1;7845:55:4;;7896:1;7893;7886:12;7845:55;7936:2;7923:16;7962:18;7954:6;7951:30;7948:50;;;7994:1;7991;7984:12;7948:50;8047:7;8042:2;8032:6;8029:1;8025:14;8021:2;8017:23;8013:32;8010:45;8007:65;;;8068:1;8065;8058:12;8138:374;8215:6;8223;8231;8284:2;8272:9;8263:7;8259:23;8255:32;8252:52;;;8300:1;8297;8290:12;8252:52;8323:29;8342:9;8323:29;:::i;:::-;8313:39;;8371:38;8405:2;8394:9;8390:18;8371:38;:::i;:::-;8138:374;;8361:48;;-1:-1:-1;;;8478:2:4;8463:18;;;;8450:32;;8138:374::o;8517:648::-;8638:6;8646;8699:2;8687:9;8678:7;8674:23;8670:32;8667:52;;;8715:1;8712;8705:12;8667:52;8755:9;8742:23;8788:18;8780:6;8777:30;8774:50;;;8820:1;8817;8810:12;8774:50;8843:22;;8896:4;8888:13;;8884:27;-1:-1:-1;8874:55:4;;8925:1;8922;8915:12;8874:55;8965:2;8952:16;8991:18;8983:6;8980:30;8977:50;;;9023:1;9020;9013:12;8977:50;9079:7;9074:2;9066:4;9058:6;9054:17;9050:2;9046:26;9042:35;9039:48;9036:68;;;9100:1;9097;9090:12;9170:347;9221:8;9231:6;9285:3;9278:4;9270:6;9266:17;9262:27;9252:55;;9303:1;9300;9293:12;9252:55;-1:-1:-1;9326:20:4;;9369:18;9358:30;;9355:50;;;9401:1;9398;9391:12;9355:50;9438:4;9430:6;9426:17;9414:29;;9490:3;9483:4;9474:6;9466;9462:19;9458:30;9455:39;9452:59;;;9507:1;9504;9497:12;9522:866;9635:6;9643;9651;9659;9667;9675;9683;9736:3;9724:9;9715:7;9711:23;9707:33;9704:53;;;9753:1;9750;9743:12;9704:53;9776:29;9795:9;9776:29;:::i;:::-;9766:39;-1:-1:-1;9874:2:4;9859:18;;9846:32;;-1:-1:-1;9975:2:4;9960:18;;9947:32;;-1:-1:-1;10024:38:4;10058:2;10043:18;;10024:38;:::i;:::-;10014:48;;10081:39;10115:3;10104:9;10100:19;10081:39;:::i;:::-;10071:49;;10171:3;10160:9;10156:19;10143:33;10199:18;10191:6;10188:30;10185:50;;;10231:1;10228;10221:12;10185:50;10270:58;10320:7;10311:6;10300:9;10296:22;10270:58;:::i;:::-;9522:866;;;;-1:-1:-1;9522:866:4;;-1:-1:-1;9522:866:4;;;;10244:84;;-1:-1:-1;;;9522:866:4:o;11140:791::-;11244:6;11252;11260;11268;11276;11284;11337:3;11325:9;11316:7;11312:23;11308:33;11305:53;;;11354:1;11351;11344:12;11305:53;11377:29;11396:9;11377:29;:::i;:::-;11367:39;;11425:38;11459:2;11448:9;11444:18;11425:38;:::i;:::-;11415:48;-1:-1:-1;11532:2:4;11517:18;;11504:32;;-1:-1:-1;11633:2:4;11618:18;;11605:32;;-1:-1:-1;11714:3:4;11699:19;;11686:33;11742:18;11731:30;;11728:50;;;11774:1;11771;11764:12;11728:50;11813:58;11863:7;11854:6;11843:9;11839:22;11813:58;:::i;:::-;11140:791;;;;-1:-1:-1;11140:791:4;;-1:-1:-1;11140:791:4;;11890:8;;11140:791;-1:-1:-1;;;11140:791:4:o;11936:842::-;12067:6;12075;12083;12091;12099;12152:2;12140:9;12131:7;12127:23;12123:32;12120:52;;;12168:1;12165;12158:12;12120:52;12191:29;12210:9;12191:29;:::i;:::-;12181:39;;12271:2;12260:9;12256:18;12243:32;12298:18;12290:6;12287:30;12284:50;;;12330:1;12327;12320:12;12284:50;12369:70;12431:7;12422:6;12411:9;12407:22;12369:70;:::i;:::-;12458:8;;-1:-1:-1;12343:96:4;-1:-1:-1;;12546:2:4;12531:18;;12518:32;12575:18;12562:32;;12559:52;;;12607:1;12604;12597:12;12559:52;12646:72;12710:7;12699:8;12688:9;12684:24;12646:72;:::i;:::-;11936:842;;;;-1:-1:-1;11936:842:4;;-1:-1:-1;12737:8:4;;12620:98;11936:842;-1:-1:-1;;;11936:842:4:o;12783:226::-;12842:6;12895:2;12883:9;12874:7;12870:23;12866:32;12863:52;;;12911:1;12908;12901:12;12863:52;-1:-1:-1;12956:23:4;;12783:226;-1:-1:-1;12783:226:4:o;13014:420::-;13067:3;13105:5;13099:12;13132:6;13127:3;13120:19;13164:4;13159:3;13155:14;13148:21;;13203:4;13196:5;13192:16;13226:1;13236:173;13250:6;13247:1;13244:13;13236:173;;;13311:13;;13299:26;;13354:4;13345:14;;;;13382:17;;;;13272:1;13265:9;13236:173;;;-1:-1:-1;13425:3:4;;13014:420;-1:-1:-1;;;;13014:420:4:o;13439:465::-;13696:2;13685:9;13678:21;13659:4;13722:56;13774:2;13763:9;13759:18;13751:6;13722:56;:::i;:::-;13826:9;13818:6;13814:22;13809:2;13798:9;13794:18;13787:50;13854:44;13891:6;13883;13854:44;:::i;:::-;13846:52;13439:465;-1:-1:-1;;;;;13439:465:4:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122084ad68f5bca444fed215be9338cbb66890517388c6b0f2fe5a242279fb33d84e64736f6c634300081d0033","offset":2751}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xc871829a6c2521e21010ab0f19fea75b3a0e2a78df64f71ea6d037010b3082cd","blockNumber":"24765012","transactionIndex":"42","deployer":"0x0Ed35B1609Ec45c7079E80d11149a52717e4859A"},"sources":{"contracts/infiniteProxy/interfaces/iProxy.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.21 <=0.8.29;\n\ninterface IProxy {\n    function setAdmin(address newAdmin_) external;\n\n    function setDummyImplementation(address newDummyImplementation_) external;\n\n    function addImplementation(address implementation_, bytes4[] calldata sigs_) external;\n\n    function removeImplementation(address implementation_) external;\n\n    function getAdmin() external view returns (address);\n\n    function getDummyImplementation() external view returns (address);\n\n    function getImplementationSigs(address impl_) external view returns (bytes4[] memory);\n\n    function getSigsImplementation(bytes4 sig_) external view returns (address);\n\n    function readFromStorage(bytes32 slot_) external view returns (uint256 result_);\n}\n"},"contracts/liquidity/adminModule/structs.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity >=0.8.21 <=0.8.29;\n\nabstract contract Structs {\n    struct AddressBool {\n        address addr;\n        bool value;\n    }\n\n    struct AddressUint256 {\n        address addr;\n        uint256 value;\n    }\n\n    /// @notice struct to set borrow rate data for version 1\n    struct RateDataV1Params {\n        ///\n        /// @param token for rate data\n        address token;\n        ///\n        /// @param kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink usually means slow increase in rate, once utilization is above kink borrow rate increases fast\n        uint256 kink;\n        ///\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\n        /// i.e. constant minimum borrow rate\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\n        uint256 rateAtUtilizationZero;\n        ///\n        /// @param rateAtUtilizationKink borrow rate when utilization is at kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at kink then rateAtUtilizationKink would be 700\n        uint256 rateAtUtilizationKink;\n        ///\n        /// @param rateAtUtilizationMax borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\n        uint256 rateAtUtilizationMax;\n    }\n\n    /// @notice struct to set borrow rate data for version 2\n    struct RateDataV2Params {\n        ///\n        /// @param token for rate data\n        address token;\n        ///\n        /// @param kink1 first kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink 1 usually means slow increase in rate, once utilization is above kink 1 borrow rate increases faster\n        uint256 kink1;\n        ///\n        /// @param kink2 second kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink 2 usually means slow / medium increase in rate, once utilization is above kink 2 borrow rate increases fast\n        uint256 kink2;\n        ///\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\n        /// i.e. constant minimum borrow rate\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\n        uint256 rateAtUtilizationZero;\n        ///\n        /// @param rateAtUtilizationKink1 desired borrow rate when utilization is at first kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at first kink then rateAtUtilizationKink would be 700\n        uint256 rateAtUtilizationKink1;\n        ///\n        /// @param rateAtUtilizationKink2 desired borrow rate when utilization is at second kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at second kink then rateAtUtilizationKink would be 1_200\n        uint256 rateAtUtilizationKink2;\n        ///\n        /// @param rateAtUtilizationMax desired borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\n        uint256 rateAtUtilizationMax;\n    }\n\n    /// @notice struct to set token config\n    struct TokenConfig {\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param fee charges on borrower's interest. in 1e2: 100% = 10_000; 1% = 100\n        uint256 fee;\n        ///\n        /// @param threshold on when to update the storage slot. in 1e2: 100% = 10_000; 1% = 100\n        uint256 threshold;\n        ///\n        /// @param maxUtilization maximum allowed utilization. in 1e2: 100% = 10_000; 1% = 100\n        ///                       set to 100% to disable and have default limit of 100% (avoiding SLOAD).\n        uint256 maxUtilization;\n    }\n\n    /// @notice struct to set user supply & withdrawal config\n    struct UserSupplyConfig {\n        ///\n        /// @param user address\n        address user;\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param mode: 0 = without interest. 1 = with interest\n        uint8 mode;\n        ///\n        /// @param expandPercent withdrawal limit expand percent. in 1e2: 100% = 10_000; 1% = 100\n        /// Also used to calculate rate at which withdrawal limit should decrease (instant).\n        uint256 expandPercent;\n        ///\n        /// @param expandDuration withdrawal limit expand duration in seconds.\n        /// used to calculate rate together with expandPercent\n        uint256 expandDuration;\n        ///\n        /// @param baseWithdrawalLimit base limit, below this, user can withdraw the entire amount.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 baseWithdrawalLimit;\n    }\n\n    /// @notice struct to set user borrow & payback config\n    struct UserBorrowConfig {\n        ///\n        /// @param user address\n        address user;\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param mode: 0 = without interest. 1 = with interest\n        uint8 mode;\n        ///\n        /// @param expandPercent debt limit expand percent. in 1e2: 100% = 10_000; 1% = 100\n        /// Also used to calculate rate at which debt limit should decrease (instant).\n        uint256 expandPercent;\n        ///\n        /// @param expandDuration debt limit expand duration in seconds.\n        /// used to calculate rate together with expandPercent\n        uint256 expandDuration;\n        ///\n        /// @param baseDebtCeiling base borrow limit. until here, borrow limit remains as baseDebtCeiling\n        /// (user can borrow until this point at once without stepped expansion). Above this, automated limit comes in place.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 baseDebtCeiling;\n        ///\n        /// @param maxDebtCeiling max borrow ceiling, maximum amount the user can borrow.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 maxDebtCeiling;\n    }\n}\n"},"contracts/liquidity/dummyImpl.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity >=0.8.21 <=0.8.29;\n\nimport { IFluidLiquidityLogic, IFluidLiquidityAdmin } from \"./interfaces/iLiquidity.sol\";\nimport { Structs as AdminModuleStructs } from \"./adminModule/structs.sol\";\n\n/// @notice Liquidity dummy implementation used for Fluid Liquidity infinite proxy.\n/// @dev see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation\ncontract FluidLiquidityDummyImpl is IFluidLiquidityLogic {\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRevenueCollector(address revenueCollector_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function changeStatus(uint256 newStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function pauseTokens(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function unpauseTokens(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function collectRevenue(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateExchangePrices(\n        address[] calldata tokens_\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_) {}\n\n    /// @inheritdoc IFluidLiquidityLogic\n    function operate(\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        address withdrawTo_,\n        address borrowTo_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\n\n    /// @inheritdoc IFluidLiquidityLogic\n    function operateOnBehalfOf(\n        address onBehalf_,\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\n}\n"},"contracts/liquidity/interfaces/iLiquidity.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity >=0.8.21 <=0.8.29;\n\nimport { IProxy } from \"../../infiniteProxy/interfaces/iProxy.sol\";\nimport { Structs as AdminModuleStructs } from \"../adminModule/structs.sol\";\n\ninterface IFluidLiquidityAdmin {\n    /// @notice adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.\n    ///         auths can be helpful in reducing governance overhead where it's not needed.\n    /// @param authsStatus_ array of structs setting allowed status for an address.\n    ///                     status true => add auth, false => remove auth\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external;\n\n    /// @notice adds/removes guardians. Only callable by Governance.\n    /// @param guardiansStatus_ array of structs setting allowed status for an address.\n    ///                         status true => add guardian, false => remove guardian\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external;\n\n    /// @notice changes the revenue collector address (contract that is sent revenue). Only callable by Governance.\n    /// @param revenueCollector_  new revenue collector address\n    function updateRevenueCollector(address revenueCollector_) external;\n\n    /// @notice changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths.\n    /// @param newStatus_ new status\n    ///        status = 2 -> pause, status = 1 -> resume.\n    function changeStatus(uint256 newStatus_) external;\n\n    /// @notice                  update tokens rate data version 1. Only callable by Auths.\n    /// @param tokensRateData_   array of RateDataV1Params with rate data to set for each token\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external;\n\n    /// @notice                  update tokens rate data version 2. Only callable by Auths.\n    /// @param tokensRateData_   array of RateDataV2Params with rate data to set for each token\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external;\n\n    /// @notice updates token configs: fee charge on borrowers interest & storage update utilization threshold.\n    ///         Only callable by Auths.\n    /// @param tokenConfigs_ contains token address, fee & utilization threshold\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external;\n\n    /// @notice updates user classes: 0 is for new protocols, 1 is for established protocols.\n    ///         Only callable by Auths.\n    /// @param userClasses_ struct array of uint256 value to assign for each user address\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external;\n\n    /// @notice sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.\n    ///         Only callable by Auths.\n    ///         Resets decay limit to 0.\n    /// @param userSupplyConfigs_ struct array containing user supply config, see `UserSupplyConfig` struct for more info\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external;\n\n    /// @notice sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0\n    /// @param user_ user address for which to update the withdrawal limit\n    /// @param token_ token address for which to update the withdrawal limit\n    /// @param newLimit_ new limit until which user supply can decrease to.\n    ///                  Important: input in raw. Must account for exchange price in input param calculation.\n    ///                  Note any limit that is < max expansion or > current user supply will set max expansion limit or\n    ///                  current user supply as limit respectively.\n    ///                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes\n    ///                  below base limit then fully down to 0.\n    ///                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit).\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external;\n\n    /// @notice setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.\n    ///         Only callable by Auths.\n    /// @param userBorrowConfigs_ struct array containing user borrow config, see `UserBorrowConfig` struct for more info\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external;\n\n    /// @notice pause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\n    /// Only callable by Guardians.\n    /// @param user_          address of user to pause operations for\n    /// @param supplyTokens_  token addresses to pause withdrawals for\n    /// @param borrowTokens_  token addresses to pause borrowings for\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\n\n    /// @notice unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\n    /// Only callable by Guardians.\n    /// @param user_          address of user to unpause operations for\n    /// @param supplyTokens_  token addresses to unpause withdrawals for\n    /// @param borrowTokens_  token addresses to unpause borrowings for\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\n\n    /// @notice pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig.\n    /// Only callable by Guardians.\n    /// @param tokens_ token addresses to pause\n    function pauseTokens(address[] calldata tokens_) external;\n\n    /// @notice unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig.\n    /// Only callable by Guardians.\n    /// @param tokens_ token addresses to unpause\n    function unpauseTokens(address[] calldata tokens_) external;\n\n    /// @notice         collects revenue for tokens to configured revenueCollector address.\n    /// @param tokens_  array of tokens to collect revenue for\n    /// @dev            Note that this can revert if token balance is < revenueAmount (utilization > 100%)\n    function collectRevenue(address[] calldata tokens_) external;\n\n    /// @notice gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage.\n    /// @param tokens_ tokens to update exchange prices for\n    /// @return supplyExchangePrices_ new supply rates of overall system for each token\n    /// @return borrowExchangePrices_ new borrow rates of overall system for each token\n    function updateExchangePrices(\n        address[] calldata tokens_\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_);\n}\n\ninterface IFluidLiquidityLogic is IFluidLiquidityAdmin {\n    /// @notice Single function which handles supply, withdraw, borrow & payback\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\n    /// @param supplyAmount_ if +ve then supply, if -ve then withdraw, if 0 then nothing\n    /// @param borrowAmount_ if +ve then borrow, if -ve then payback, if 0 then nothing\n    /// @param withdrawTo_ if withdrawal then to which address\n    /// @param borrowTo_ if borrow then to which address\n    /// @param callbackData_ callback data passed to `liquidityCallback` method of protocol\n    /// @return memVar3_ updated supplyExchangePrice\n    /// @return memVar4_ updated borrowExchangePrice\n    /// @dev to trigger skipping in / out transfers (gas optimization):\n    /// -  ` callbackData_` MUST be encoded so that \"from\" address is the last 20 bytes in the last 32 bytes slot,\n    ///     also for native token operations where liquidityCallback is not triggered!\n    ///     from address must come at last position if there is more data. I.e. encode like:\n    ///     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end\n    ///     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end.\n    /// -   this \"from\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender`\n    /// -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS\n    ///     in the slot before (bytes 32 to 63)\n    /// -   `msg.value` must be 0.\n    /// -   Amounts must be either:\n    ///     -  supply(+) == borrow(+), withdraw(-) == payback(-).\n    ///     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).\n    function operate(\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        address withdrawTo_,\n        address borrowTo_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\n\n    /// @notice Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.\n    ///         Only callable by auths or governance. Token transfers still come from msg.sender:\n    ///         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().\n    ///         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.\n    ///         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused.\n    /// @param onBehalf_ the address (protocol) whose position to operate on. Must be != address(0)\n    ///                   and must have a configured position (via admin) for the given token.\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\n    /// @param supplyAmount_ if +ve then supply, if 0 then nothing. Must be >= 0.\n    /// @param borrowAmount_ if -ve then payback, if 0 then nothing. Must be <= 0.\n    ///                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.\n    /// @param callbackData_ must be empty (length 0). Custom callbackData-powered transfer shortcuts like\n    ///                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.\n    /// @return memVar3_ updated supplyExchangePrice\n    /// @return memVar4_ updated borrowExchangePrice\n    function operateOnBehalfOf(\n        address onBehalf_,\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\n}\n\ninterface IFluidLiquidity is IProxy, IFluidLiquidityLogic {}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.29+commit.ab55807c","compilerSettings":{"metadata":{"useLiteralContent":true},"optimizer":{"runs":10000000,"enabled":true},"evmVersion":"cancun"},"name":"FluidLiquidityDummyImpl","fullyQualifiedName":"contracts/liquidity/dummyImpl.sol:FluidLiquidityDummyImpl"},"abi":[{"name":"changeStatus","type":"function","inputs":[{"name":"newStatus_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"collectRevenue","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"operate","type":"function","inputs":[{"name":"token_","type":"address","internalType":"address"},{"name":"supplyAmount_","type":"int256","internalType":"int256"},{"name":"borrowAmount_","type":"int256","internalType":"int256"},{"name":"withdrawTo_","type":"address","internalType":"address"},{"name":"borrowTo_","type":"address","internalType":"address"},{"name":"callbackData_","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"memVar3_","type":"uint256","internalType":"uint256"},{"name":"memVar4_","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"operateOnBehalfOf","type":"function","inputs":[{"name":"onBehalf_","type":"address","internalType":"address"},{"name":"token_","type":"address","internalType":"address"},{"name":"supplyAmount_","type":"int256","internalType":"int256"},{"name":"borrowAmount_","type":"int256","internalType":"int256"},{"name":"callbackData_","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"memVar3_","type":"uint256","internalType":"uint256"},{"name":"memVar4_","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"pauseTokens","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pauseUser","type":"function","inputs":[{"name":"user_","type":"address","internalType":"address"},{"name":"supplyTokens_","type":"address[]","internalType":"address[]"},{"name":"borrowTokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpauseTokens","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpauseUser","type":"function","inputs":[{"name":"user_","type":"address","internalType":"address"},{"name":"supplyTokens_","type":"address[]","internalType":"address[]"},{"name":"borrowTokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateAuths","type":"function","inputs":[{"name":"authsStatus_","type":"tuple[]","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"internalType":"struct Structs.AddressBool[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateExchangePrices","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[{"name":"supplyExchangePrices_","type":"uint256[]","internalType":"uint256[]"},{"name":"borrowExchangePrices_","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"nonpayable"},{"name":"updateGuardians","type":"function","inputs":[{"name":"guardiansStatus_","type":"tuple[]","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"internalType":"struct Structs.AddressBool[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateRateDataV1s","type":"function","inputs":[{"name":"tokensRateData_","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"kink","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationZero","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationKink","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationMax","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.RateDataV1Params[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateRateDataV2s","type":"function","inputs":[{"name":"tokensRateData_","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"kink1","type":"uint256","internalType":"uint256"},{"name":"kink2","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationZero","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationKink1","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationKink2","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationMax","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.RateDataV2Params[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateRevenueCollector","type":"function","inputs":[{"name":"revenueCollector_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateTokenConfigs","type":"function","inputs":[{"name":"tokenConfigs_","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"fee","type":"uint256","internalType":"uint256"},{"name":"threshold","type":"uint256","internalType":"uint256"},{"name":"maxUtilization","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.TokenConfig[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserBorrowConfigs","type":"function","inputs":[{"name":"userBorrowConfigs_","type":"tuple[]","components":[{"name":"user","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"mode","type":"uint8","internalType":"uint8"},{"name":"expandPercent","type":"uint256","internalType":"uint256"},{"name":"expandDuration","type":"uint256","internalType":"uint256"},{"name":"baseDebtCeiling","type":"uint256","internalType":"uint256"},{"name":"maxDebtCeiling","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.UserBorrowConfig[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserClasses","type":"function","inputs":[{"name":"userClasses_","type":"tuple[]","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.AddressUint256[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserSupplyConfigs","type":"function","inputs":[{"name":"userSupplyConfigs_","type":"tuple[]","components":[{"name":"user","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"mode","type":"uint8","internalType":"uint8"},{"name":"expandPercent","type":"uint256","internalType":"uint256"},{"name":"expandDuration","type":"uint256","internalType":"uint256"},{"name":"baseWithdrawalLimit","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.UserSupplyConfig[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserWithdrawalLimit","type":"function","inputs":[{"name":"user_","type":"address","internalType":"address"},{"name":"token_","type":"address","internalType":"address"},{"name":"newLimit_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.29+commit.ab55807c"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"newStatus_","type":"uint256"}],"name":"changeStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens_","type":"address[]"}],"name":"collectRevenue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"int256","name":"supplyAmount_","type":"int256"},{"internalType":"int256","name":"borrowAmount_","type":"int256"},{"internalType":"address","name":"withdrawTo_","type":"address"},{"internalType":"address","name":"borrowTo_","type":"address"},{"internalType":"bytes","name":"callbackData_","type":"bytes"}],"name":"operate","outputs":[{"internalType":"uint256","name":"memVar3_","type":"uint256"},{"internalType":"uint256","name":"memVar4_","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"onBehalf_","type":"address"},{"internalType":"address","name":"token_","type":"address"},{"internalType":"int256","name":"supplyAmount_","type":"int256"},{"internalType":"int256","name":"borrowAmount_","type":"int256"},{"internalType":"bytes","name":"callbackData_","type":"bytes"}],"name":"operateOnBehalfOf","outputs":[{"internalType":"uint256","name":"memVar3_","type":"uint256"},{"internalType":"uint256","name":"memVar4_","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens_","type":"address[]"}],"name":"pauseTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user_","type":"address"},{"internalType":"address[]","name":"supplyTokens_","type":"address[]"},{"internalType":"address[]","name":"borrowTokens_","type":"address[]"}],"name":"pauseUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens_","type":"address[]"}],"name":"unpauseTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user_","type":"address"},{"internalType":"address[]","name":"supplyTokens_","type":"address[]"},{"internalType":"address[]","name":"borrowTokens_","type":"address[]"}],"name":"unpauseUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"internalType":"struct Structs.AddressBool[]","name":"authsStatus_","type":"tuple[]"}],"name":"updateAuths","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens_","type":"address[]"}],"name":"updateExchangePrices","outputs":[{"internalType":"uint256[]","name":"supplyExchangePrices_","type":"uint256[]"},{"internalType":"uint256[]","name":"borrowExchangePrices_","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"internalType":"struct Structs.AddressBool[]","name":"guardiansStatus_","type":"tuple[]"}],"name":"updateGuardians","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"kink","type":"uint256"},{"internalType":"uint256","name":"rateAtUtilizationZero","type":"uint256"},{"internalType":"uint256","name":"rateAtUtilizationKink","type":"uint256"},{"internalType":"uint256","name":"rateAtUtilizationMax","type":"uint256"}],"internalType":"struct Structs.RateDataV1Params[]","name":"tokensRateData_","type":"tuple[]"}],"name":"updateRateDataV1s","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"kink1","type":"uint256"},{"internalType":"uint256","name":"kink2","type":"uint256"},{"internalType":"uint256","name":"rateAtUtilizationZero","type":"uint256"},{"internalType":"uint256","name":"rateAtUtilizationKink1","type":"uint256"},{"internalType":"uint256","name":"rateAtUtilizationKink2","type":"uint256"},{"internalType":"uint256","name":"rateAtUtilizationMax","type":"uint256"}],"internalType":"struct Structs.RateDataV2Params[]","name":"tokensRateData_","type":"tuple[]"}],"name":"updateRateDataV2s","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"revenueCollector_","type":"address"}],"name":"updateRevenueCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"fee","type":"uint256"},{"internalType":"uint256","name":"threshold","type":"uint256"},{"internalType":"uint256","name":"maxUtilization","type":"uint256"}],"internalType":"struct Structs.TokenConfig[]","name":"tokenConfigs_","type":"tuple[]"}],"name":"updateTokenConfigs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"mode","type":"uint8"},{"internalType":"uint256","name":"expandPercent","type":"uint256"},{"internalType":"uint256","name":"expandDuration","type":"uint256"},{"internalType":"uint256","name":"baseDebtCeiling","type":"uint256"},{"internalType":"uint256","name":"maxDebtCeiling","type":"uint256"}],"internalType":"struct Structs.UserBorrowConfig[]","name":"userBorrowConfigs_","type":"tuple[]"}],"name":"updateUserBorrowConfigs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct Structs.AddressUint256[]","name":"userClasses_","type":"tuple[]"}],"name":"updateUserClasses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"mode","type":"uint8"},{"internalType":"uint256","name":"expandPercent","type":"uint256"},{"internalType":"uint256","name":"expandDuration","type":"uint256"},{"internalType":"uint256","name":"baseWithdrawalLimit","type":"uint256"}],"internalType":"struct Structs.UserSupplyConfig[]","name":"userSupplyConfigs_","type":"tuple[]"}],"name":"updateUserSupplyConfigs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user_","type":"address"},{"internalType":"address","name":"token_","type":"address"},{"internalType":"uint256","name":"newLimit_","type":"uint256"}],"name":"updateUserWithdrawalLimit","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"details":"see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation","kind":"dev","methods":{"changeStatus(uint256)":{"params":{"newStatus_":"new status        status = 2 -> pause, status = 1 -> resume."}},"collectRevenue(address[])":{"details":"Note that this can revert if token balance is < revenueAmount (utilization > 100%)","params":{"tokens_":"array of tokens to collect revenue for"}},"operate(address,int256,int256,address,address,bytes)":{"details":"to trigger skipping in / out transfers (gas optimization): -  ` callbackData_` MUST be encoded so that \"from\" address is the last 20 bytes in the last 32 bytes slot,     also for native token operations where liquidityCallback is not triggered!     from address must come at last position if there is more data. I.e. encode like:     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end. -   this \"from\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender` -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS     in the slot before (bytes 32 to 63) -   `msg.value` must be 0. -   Amounts must be either:     -  supply(+) == borrow(+), withdraw(-) == payback(-).     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).","params":{"borrowAmount_":"if +ve then borrow, if -ve then payback, if 0 then nothing","borrowTo_":"if borrow then to which address","callbackData_":"callback data passed to `liquidityCallback` method of protocol","supplyAmount_":"if +ve then supply, if -ve then withdraw, if 0 then nothing","token_":"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)","withdrawTo_":"if withdrawal then to which address"},"returns":{"memVar3_":"updated supplyExchangePrice","memVar4_":"updated borrowExchangePrice"}},"operateOnBehalfOf(address,address,int256,int256,bytes)":{"params":{"borrowAmount_":"if -ve then payback, if 0 then nothing. Must be <= 0.                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.","callbackData_":"must be empty (length 0). Custom callbackData-powered transfer shortcuts like                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.","onBehalf_":"the address (protocol) whose position to operate on. Must be != address(0)                   and must have a configured position (via admin) for the given token.","supplyAmount_":"if +ve then supply, if 0 then nothing. Must be >= 0.","token_":"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)"},"returns":{"memVar3_":"updated supplyExchangePrice","memVar4_":"updated borrowExchangePrice"}},"pauseTokens(address[])":{"params":{"tokens_":"token addresses to pause"}},"pauseUser(address,address[],address[])":{"params":{"borrowTokens_":"token addresses to pause borrowings for","supplyTokens_":"token addresses to pause withdrawals for","user_":"address of user to pause operations for"}},"unpauseTokens(address[])":{"params":{"tokens_":"token addresses to unpause"}},"unpauseUser(address,address[],address[])":{"params":{"borrowTokens_":"token addresses to unpause borrowings for","supplyTokens_":"token addresses to unpause withdrawals for","user_":"address of user to unpause operations for"}},"updateAuths((address,bool)[])":{"params":{"authsStatus_":"array of structs setting allowed status for an address.                     status true => add auth, false => remove auth"}},"updateExchangePrices(address[])":{"params":{"tokens_":"tokens to update exchange prices for"},"returns":{"borrowExchangePrices_":"new borrow rates of overall system for each token","supplyExchangePrices_":"new supply rates of overall system for each token"}},"updateGuardians((address,bool)[])":{"params":{"guardiansStatus_":"array of structs setting allowed status for an address.                         status true => add guardian, false => remove guardian"}},"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])":{"params":{"tokensRateData_":"array of RateDataV1Params with rate data to set for each token"}},"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])":{"params":{"tokensRateData_":"array of RateDataV2Params with rate data to set for each token"}},"updateRevenueCollector(address)":{"params":{"revenueCollector_":"new revenue collector address"}},"updateTokenConfigs((address,uint256,uint256,uint256)[])":{"params":{"tokenConfigs_":"contains token address, fee & utilization threshold"}},"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])":{"params":{"userBorrowConfigs_":"struct array containing user borrow config, see `UserBorrowConfig` struct for more info"}},"updateUserClasses((address,uint256)[])":{"params":{"userClasses_":"struct array of uint256 value to assign for each user address"}},"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])":{"params":{"userSupplyConfigs_":"struct array containing user supply config, see `UserSupplyConfig` struct for more info"}},"updateUserWithdrawalLimit(address,address,uint256)":{"params":{"newLimit_":"new limit until which user supply can decrease to.                  Important: input in raw. Must account for exchange price in input param calculation.                  Note any limit that is < max expansion or > current user supply will set max expansion limit or                  current user supply as limit respectively.                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes                  below base limit then fully down to 0.                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit).","token_":"token address for which to update the withdrawal limit","user_":"user address for which to update the withdrawal limit"}}},"version":1},"userdoc":{"kind":"user","methods":{"changeStatus(uint256)":{"notice":"changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths."},"collectRevenue(address[])":{"notice":"collects revenue for tokens to configured revenueCollector address."},"operate(address,int256,int256,address,address,bytes)":{"notice":"Single function which handles supply, withdraw, borrow & payback"},"operateOnBehalfOf(address,address,int256,int256,bytes)":{"notice":"Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.         Only callable by auths or governance. Token transfers still come from msg.sender:         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused."},"pauseTokens(address[])":{"notice":"pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig. Only callable by Guardians."},"pauseUser(address,address[],address[])":{"notice":"pause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians."},"unpauseTokens(address[])":{"notice":"unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig. Only callable by Guardians."},"unpauseUser(address,address[],address[])":{"notice":"unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians."},"updateAuths((address,bool)[])":{"notice":"adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.         auths can be helpful in reducing governance overhead where it's not needed."},"updateExchangePrices(address[])":{"notice":"gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage."},"updateGuardians((address,bool)[])":{"notice":"adds/removes guardians. Only callable by Governance."},"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])":{"notice":"update tokens rate data version 1. Only callable by Auths."},"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])":{"notice":"update tokens rate data version 2. Only callable by Auths."},"updateRevenueCollector(address)":{"notice":"changes the revenue collector address (contract that is sent revenue). Only callable by Governance."},"updateTokenConfigs((address,uint256,uint256,uint256)[])":{"notice":"updates token configs: fee charge on borrowers interest & storage update utilization threshold.         Only callable by Auths."},"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])":{"notice":"setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths."},"updateUserClasses((address,uint256)[])":{"notice":"updates user classes: 0 is for new protocols, 1 is for established protocols.         Only callable by Auths."},"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])":{"notice":"sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths.         Resets decay limit to 0."},"updateUserWithdrawalLimit(address,address,uint256)":{"notice":"sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0"}},"notice":"Liquidity dummy implementation used for Fluid Liquidity infinite proxy.","version":1}},"settings":{"compilationTarget":{"contracts/liquidity/dummyImpl.sol":"FluidLiquidityDummyImpl"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":true,"runs":10000000},"remappings":[]},"sources":{"contracts/infiniteProxy/interfaces/iProxy.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.21 <=0.8.29;\n\ninterface IProxy {\n    function setAdmin(address newAdmin_) external;\n\n    function setDummyImplementation(address newDummyImplementation_) external;\n\n    function addImplementation(address implementation_, bytes4[] calldata sigs_) external;\n\n    function removeImplementation(address implementation_) external;\n\n    function getAdmin() external view returns (address);\n\n    function getDummyImplementation() external view returns (address);\n\n    function getImplementationSigs(address impl_) external view returns (bytes4[] memory);\n\n    function getSigsImplementation(bytes4 sig_) external view returns (address);\n\n    function readFromStorage(bytes32 slot_) external view returns (uint256 result_);\n}\n","keccak256":"0x30d8b90d077a4ab2b116788f4b47ec7009dc49e11ef76f1d7bf07bd0cc65b406","license":"MIT"},"contracts/liquidity/adminModule/structs.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity >=0.8.21 <=0.8.29;\n\nabstract contract Structs {\n    struct AddressBool {\n        address addr;\n        bool value;\n    }\n\n    struct AddressUint256 {\n        address addr;\n        uint256 value;\n    }\n\n    /// @notice struct to set borrow rate data for version 1\n    struct RateDataV1Params {\n        ///\n        /// @param token for rate data\n        address token;\n        ///\n        /// @param kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink usually means slow increase in rate, once utilization is above kink borrow rate increases fast\n        uint256 kink;\n        ///\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\n        /// i.e. constant minimum borrow rate\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\n        uint256 rateAtUtilizationZero;\n        ///\n        /// @param rateAtUtilizationKink borrow rate when utilization is at kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at kink then rateAtUtilizationKink would be 700\n        uint256 rateAtUtilizationKink;\n        ///\n        /// @param rateAtUtilizationMax borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\n        uint256 rateAtUtilizationMax;\n    }\n\n    /// @notice struct to set borrow rate data for version 2\n    struct RateDataV2Params {\n        ///\n        /// @param token for rate data\n        address token;\n        ///\n        /// @param kink1 first kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink 1 usually means slow increase in rate, once utilization is above kink 1 borrow rate increases faster\n        uint256 kink1;\n        ///\n        /// @param kink2 second kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink 2 usually means slow / medium increase in rate, once utilization is above kink 2 borrow rate increases fast\n        uint256 kink2;\n        ///\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\n        /// i.e. constant minimum borrow rate\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\n        uint256 rateAtUtilizationZero;\n        ///\n        /// @param rateAtUtilizationKink1 desired borrow rate when utilization is at first kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at first kink then rateAtUtilizationKink would be 700\n        uint256 rateAtUtilizationKink1;\n        ///\n        /// @param rateAtUtilizationKink2 desired borrow rate when utilization is at second kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at second kink then rateAtUtilizationKink would be 1_200\n        uint256 rateAtUtilizationKink2;\n        ///\n        /// @param rateAtUtilizationMax desired borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\n        uint256 rateAtUtilizationMax;\n    }\n\n    /// @notice struct to set token config\n    struct TokenConfig {\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param fee charges on borrower's interest. in 1e2: 100% = 10_000; 1% = 100\n        uint256 fee;\n        ///\n        /// @param threshold on when to update the storage slot. in 1e2: 100% = 10_000; 1% = 100\n        uint256 threshold;\n        ///\n        /// @param maxUtilization maximum allowed utilization. in 1e2: 100% = 10_000; 1% = 100\n        ///                       set to 100% to disable and have default limit of 100% (avoiding SLOAD).\n        uint256 maxUtilization;\n    }\n\n    /// @notice struct to set user supply & withdrawal config\n    struct UserSupplyConfig {\n        ///\n        /// @param user address\n        address user;\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param mode: 0 = without interest. 1 = with interest\n        uint8 mode;\n        ///\n        /// @param expandPercent withdrawal limit expand percent. in 1e2: 100% = 10_000; 1% = 100\n        /// Also used to calculate rate at which withdrawal limit should decrease (instant).\n        uint256 expandPercent;\n        ///\n        /// @param expandDuration withdrawal limit expand duration in seconds.\n        /// used to calculate rate together with expandPercent\n        uint256 expandDuration;\n        ///\n        /// @param baseWithdrawalLimit base limit, below this, user can withdraw the entire amount.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 baseWithdrawalLimit;\n    }\n\n    /// @notice struct to set user borrow & payback config\n    struct UserBorrowConfig {\n        ///\n        /// @param user address\n        address user;\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param mode: 0 = without interest. 1 = with interest\n        uint8 mode;\n        ///\n        /// @param expandPercent debt limit expand percent. in 1e2: 100% = 10_000; 1% = 100\n        /// Also used to calculate rate at which debt limit should decrease (instant).\n        uint256 expandPercent;\n        ///\n        /// @param expandDuration debt limit expand duration in seconds.\n        /// used to calculate rate together with expandPercent\n        uint256 expandDuration;\n        ///\n        /// @param baseDebtCeiling base borrow limit. until here, borrow limit remains as baseDebtCeiling\n        /// (user can borrow until this point at once without stepped expansion). Above this, automated limit comes in place.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 baseDebtCeiling;\n        ///\n        /// @param maxDebtCeiling max borrow ceiling, maximum amount the user can borrow.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 maxDebtCeiling;\n    }\n}\n","keccak256":"0xfa7cbe07b97f45acd0460deaff1ef54de9473164249e5527ee4da6efb6bf7e65","license":"BUSL-1.1"},"contracts/liquidity/dummyImpl.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity >=0.8.21 <=0.8.29;\n\nimport { IFluidLiquidityLogic, IFluidLiquidityAdmin } from \"./interfaces/iLiquidity.sol\";\nimport { Structs as AdminModuleStructs } from \"./adminModule/structs.sol\";\n\n/// @notice Liquidity dummy implementation used for Fluid Liquidity infinite proxy.\n/// @dev see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation\ncontract FluidLiquidityDummyImpl is IFluidLiquidityLogic {\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRevenueCollector(address revenueCollector_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function changeStatus(uint256 newStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function pauseTokens(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function unpauseTokens(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function collectRevenue(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateExchangePrices(\n        address[] calldata tokens_\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_) {}\n\n    /// @inheritdoc IFluidLiquidityLogic\n    function operate(\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        address withdrawTo_,\n        address borrowTo_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\n\n    /// @inheritdoc IFluidLiquidityLogic\n    function operateOnBehalfOf(\n        address onBehalf_,\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\n}\n","keccak256":"0xb49dc40f3c12b32cd1eb93b9eb8ac711c106e33cd85ccf4250a4e7c0d7adc576","license":"BUSL-1.1"},"contracts/liquidity/interfaces/iLiquidity.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity >=0.8.21 <=0.8.29;\n\nimport { IProxy } from \"../../infiniteProxy/interfaces/iProxy.sol\";\nimport { Structs as AdminModuleStructs } from \"../adminModule/structs.sol\";\n\ninterface IFluidLiquidityAdmin {\n    /// @notice adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.\n    ///         auths can be helpful in reducing governance overhead where it's not needed.\n    /// @param authsStatus_ array of structs setting allowed status for an address.\n    ///                     status true => add auth, false => remove auth\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external;\n\n    /// @notice adds/removes guardians. Only callable by Governance.\n    /// @param guardiansStatus_ array of structs setting allowed status for an address.\n    ///                         status true => add guardian, false => remove guardian\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external;\n\n    /// @notice changes the revenue collector address (contract that is sent revenue). Only callable by Governance.\n    /// @param revenueCollector_  new revenue collector address\n    function updateRevenueCollector(address revenueCollector_) external;\n\n    /// @notice changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths.\n    /// @param newStatus_ new status\n    ///        status = 2 -> pause, status = 1 -> resume.\n    function changeStatus(uint256 newStatus_) external;\n\n    /// @notice                  update tokens rate data version 1. Only callable by Auths.\n    /// @param tokensRateData_   array of RateDataV1Params with rate data to set for each token\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external;\n\n    /// @notice                  update tokens rate data version 2. Only callable by Auths.\n    /// @param tokensRateData_   array of RateDataV2Params with rate data to set for each token\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external;\n\n    /// @notice updates token configs: fee charge on borrowers interest & storage update utilization threshold.\n    ///         Only callable by Auths.\n    /// @param tokenConfigs_ contains token address, fee & utilization threshold\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external;\n\n    /// @notice updates user classes: 0 is for new protocols, 1 is for established protocols.\n    ///         Only callable by Auths.\n    /// @param userClasses_ struct array of uint256 value to assign for each user address\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external;\n\n    /// @notice sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.\n    ///         Only callable by Auths.\n    ///         Resets decay limit to 0.\n    /// @param userSupplyConfigs_ struct array containing user supply config, see `UserSupplyConfig` struct for more info\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external;\n\n    /// @notice sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0\n    /// @param user_ user address for which to update the withdrawal limit\n    /// @param token_ token address for which to update the withdrawal limit\n    /// @param newLimit_ new limit until which user supply can decrease to.\n    ///                  Important: input in raw. Must account for exchange price in input param calculation.\n    ///                  Note any limit that is < max expansion or > current user supply will set max expansion limit or\n    ///                  current user supply as limit respectively.\n    ///                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes\n    ///                  below base limit then fully down to 0.\n    ///                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit).\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external;\n\n    /// @notice setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.\n    ///         Only callable by Auths.\n    /// @param userBorrowConfigs_ struct array containing user borrow config, see `UserBorrowConfig` struct for more info\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external;\n\n    /// @notice pause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\n    /// Only callable by Guardians.\n    /// @param user_          address of user to pause operations for\n    /// @param supplyTokens_  token addresses to pause withdrawals for\n    /// @param borrowTokens_  token addresses to pause borrowings for\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\n\n    /// @notice unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\n    /// Only callable by Guardians.\n    /// @param user_          address of user to unpause operations for\n    /// @param supplyTokens_  token addresses to unpause withdrawals for\n    /// @param borrowTokens_  token addresses to unpause borrowings for\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\n\n    /// @notice pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig.\n    /// Only callable by Guardians.\n    /// @param tokens_ token addresses to pause\n    function pauseTokens(address[] calldata tokens_) external;\n\n    /// @notice unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig.\n    /// Only callable by Guardians.\n    /// @param tokens_ token addresses to unpause\n    function unpauseTokens(address[] calldata tokens_) external;\n\n    /// @notice         collects revenue for tokens to configured revenueCollector address.\n    /// @param tokens_  array of tokens to collect revenue for\n    /// @dev            Note that this can revert if token balance is < revenueAmount (utilization > 100%)\n    function collectRevenue(address[] calldata tokens_) external;\n\n    /// @notice gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage.\n    /// @param tokens_ tokens to update exchange prices for\n    /// @return supplyExchangePrices_ new supply rates of overall system for each token\n    /// @return borrowExchangePrices_ new borrow rates of overall system for each token\n    function updateExchangePrices(\n        address[] calldata tokens_\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_);\n}\n\ninterface IFluidLiquidityLogic is IFluidLiquidityAdmin {\n    /// @notice Single function which handles supply, withdraw, borrow & payback\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\n    /// @param supplyAmount_ if +ve then supply, if -ve then withdraw, if 0 then nothing\n    /// @param borrowAmount_ if +ve then borrow, if -ve then payback, if 0 then nothing\n    /// @param withdrawTo_ if withdrawal then to which address\n    /// @param borrowTo_ if borrow then to which address\n    /// @param callbackData_ callback data passed to `liquidityCallback` method of protocol\n    /// @return memVar3_ updated supplyExchangePrice\n    /// @return memVar4_ updated borrowExchangePrice\n    /// @dev to trigger skipping in / out transfers (gas optimization):\n    /// -  ` callbackData_` MUST be encoded so that \"from\" address is the last 20 bytes in the last 32 bytes slot,\n    ///     also for native token operations where liquidityCallback is not triggered!\n    ///     from address must come at last position if there is more data. I.e. encode like:\n    ///     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end\n    ///     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end.\n    /// -   this \"from\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender`\n    /// -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS\n    ///     in the slot before (bytes 32 to 63)\n    /// -   `msg.value` must be 0.\n    /// -   Amounts must be either:\n    ///     -  supply(+) == borrow(+), withdraw(-) == payback(-).\n    ///     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).\n    function operate(\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        address withdrawTo_,\n        address borrowTo_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\n\n    /// @notice Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.\n    ///         Only callable by auths or governance. Token transfers still come from msg.sender:\n    ///         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().\n    ///         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.\n    ///         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused.\n    /// @param onBehalf_ the address (protocol) whose position to operate on. Must be != address(0)\n    ///                   and must have a configured position (via admin) for the given token.\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\n    /// @param supplyAmount_ if +ve then supply, if 0 then nothing. Must be >= 0.\n    /// @param borrowAmount_ if -ve then payback, if 0 then nothing. Must be <= 0.\n    ///                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.\n    /// @param callbackData_ must be empty (length 0). Custom callbackData-powered transfer shortcuts like\n    ///                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.\n    /// @return memVar3_ updated supplyExchangePrice\n    /// @return memVar4_ updated borrowExchangePrice\n    function operateOnBehalfOf(\n        address onBehalf_,\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\n}\n\ninterface IFluidLiquidity is IProxy, IFluidLiquidityLogic {}\n","keccak256":"0x3e020c10d52a450c12b70a496d05d00bcd849b4646cae1757595d1d3be76ff14","license":"MIT"}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Liquidity dummy implementation used for Fluid Liquidity infinite proxy.","methods":{"changeStatus(uint256)":{"notice":"changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths."},"pauseTokens(address[])":{"notice":"pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig. Only callable by Guardians."},"unpauseTokens(address[])":{"notice":"unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig. Only callable by Guardians."},"collectRevenue(address[])":{"notice":"collects revenue for tokens to configured revenueCollector address."},"updateAuths((address,bool)[])":{"notice":"adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.         auths can be helpful in reducing governance overhead where it's not needed."},"updateExchangePrices(address[])":{"notice":"gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage."},"updateRevenueCollector(address)":{"notice":"changes the revenue collector address (contract that is sent revenue). Only callable by Governance."},"updateGuardians((address,bool)[])":{"notice":"adds/removes guardians. Only callable by Governance."},"pauseUser(address,address[],address[])":{"notice":"pause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians."},"updateUserClasses((address,uint256)[])":{"notice":"updates user classes: 0 is for new protocols, 1 is for established protocols.         Only callable by Auths."},"unpauseUser(address,address[],address[])":{"notice":"unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians."},"updateUserWithdrawalLimit(address,address,uint256)":{"notice":"sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0"},"operate(address,int256,int256,address,address,bytes)":{"notice":"Single function which handles supply, withdraw, borrow & payback"},"operateOnBehalfOf(address,address,int256,int256,bytes)":{"notice":"Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.         Only callable by auths or governance. Token transfers still come from msg.sender:         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused."},"updateTokenConfigs((address,uint256,uint256,uint256)[])":{"notice":"updates token configs: fee charge on borrowers interest & storage update utilization threshold.         Only callable by Auths."},"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])":{"notice":"update tokens rate data version 1. Only callable by Auths."},"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])":{"notice":"sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths.         Resets decay limit to 0."},"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])":{"notice":"update tokens rate data version 2. Only callable by Auths."},"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])":{"notice":"setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths."}},"version":1},"devdoc":{"kind":"dev","details":"see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation","methods":{"changeStatus(uint256)":{"params":{"newStatus_":"new status        status = 2 -> pause, status = 1 -> resume."}},"pauseTokens(address[])":{"params":{"tokens_":"token addresses to pause"}},"unpauseTokens(address[])":{"params":{"tokens_":"token addresses to unpause"}},"collectRevenue(address[])":{"params":{"tokens_":"array of tokens to collect revenue for"},"details":"Note that this can revert if token balance is < revenueAmount (utilization > 100%)"},"updateAuths((address,bool)[])":{"params":{"authsStatus_":"array of structs setting allowed status for an address.                     status true => add auth, false => remove auth"}},"updateExchangePrices(address[])":{"params":{"tokens_":"tokens to update exchange prices for"},"returns":{"borrowExchangePrices_":"new borrow rates of overall system for each token","supplyExchangePrices_":"new supply rates of overall system for each token"}},"updateRevenueCollector(address)":{"params":{"revenueCollector_":"new revenue collector address"}},"updateGuardians((address,bool)[])":{"params":{"guardiansStatus_":"array of structs setting allowed status for an address.                         status true => add guardian, false => remove guardian"}},"pauseUser(address,address[],address[])":{"params":{"user_":"address of user to pause operations for","borrowTokens_":"token addresses to pause borrowings for","supplyTokens_":"token addresses to pause withdrawals for"}},"updateUserClasses((address,uint256)[])":{"params":{"userClasses_":"struct array of uint256 value to assign for each user address"}},"unpauseUser(address,address[],address[])":{"params":{"user_":"address of user to unpause operations for","borrowTokens_":"token addresses to unpause borrowings for","supplyTokens_":"token addresses to unpause withdrawals for"}},"updateUserWithdrawalLimit(address,address,uint256)":{"params":{"user_":"user address for which to update the withdrawal limit","token_":"token address for which to update the withdrawal limit","newLimit_":"new limit until which user supply can decrease to.                  Important: input in raw. Must account for exchange price in input param calculation.                  Note any limit that is < max expansion or > current user supply will set max expansion limit or                  current user supply as limit respectively.                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes                  below base limit then fully down to 0.                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit)."}},"operate(address,int256,int256,address,address,bytes)":{"params":{"token_":"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)","borrowTo_":"if borrow then to which address","withdrawTo_":"if withdrawal then to which address","borrowAmount_":"if +ve then borrow, if -ve then payback, if 0 then nothing","callbackData_":"callback data passed to `liquidityCallback` method of protocol","supplyAmount_":"if +ve then supply, if -ve then withdraw, if 0 then nothing"},"details":"to trigger skipping in / out transfers (gas optimization): -  ` callbackData_` MUST be encoded so that \"from\" address is the last 20 bytes in the last 32 bytes slot,     also for native token operations where liquidityCallback is not triggered!     from address must come at last position if there is more data. I.e. encode like:     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end. -   this \"from\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender` -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS     in the slot before (bytes 32 to 63) -   `msg.value` must be 0. -   Amounts must be either:     -  supply(+) == borrow(+), withdraw(-) == payback(-).     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).","returns":{"memVar3_":"updated supplyExchangePrice","memVar4_":"updated borrowExchangePrice"}},"operateOnBehalfOf(address,address,int256,int256,bytes)":{"params":{"token_":"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)","onBehalf_":"the address (protocol) whose position to operate on. Must be != address(0)                   and must have a configured position (via admin) for the given token.","borrowAmount_":"if -ve then payback, if 0 then nothing. Must be <= 0.                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.","callbackData_":"must be empty (length 0). Custom callbackData-powered transfer shortcuts like                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.","supplyAmount_":"if +ve then supply, if 0 then nothing. Must be >= 0."},"returns":{"memVar3_":"updated supplyExchangePrice","memVar4_":"updated borrowExchangePrice"}},"updateTokenConfigs((address,uint256,uint256,uint256)[])":{"params":{"tokenConfigs_":"contains token address, fee & utilization threshold"}},"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])":{"params":{"tokensRateData_":"array of RateDataV1Params with rate data to set for each token"}},"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])":{"params":{"userSupplyConfigs_":"struct array containing user supply config, see `UserSupplyConfig` struct for more info"}},"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])":{"params":{"tokensRateData_":"array of RateDataV2Params with rate data to set for each token"}},"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])":{"params":{"userBorrowConfigs_":"struct array containing user borrow config, see `UserBorrowConfig` struct for more info"}}},"version":1},"sourceIds":{"contracts/liquidity/dummyImpl.sol":{"id":2},"contracts/liquidity/adminModule/structs.sol":{"id":1},"contracts/infiniteProxy/interfaces/iProxy.sol":{"id":0},"contracts/liquidity/interfaces/iLiquidity.sol":{"id":3}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/liquidity/dummyImpl.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity >=0.8.21 <=0.8.29;\n\nimport { IFluidLiquidityLogic, IFluidLiquidityAdmin } from \"./interfaces/iLiquidity.sol\";\nimport { Structs as AdminModuleStructs } from \"./adminModule/structs.sol\";\n\n/// @notice Liquidity dummy implementation used for Fluid Liquidity infinite proxy.\n/// @dev see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation\ncontract FluidLiquidityDummyImpl is IFluidLiquidityLogic {\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRevenueCollector(address revenueCollector_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function changeStatus(uint256 newStatus_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function pauseTokens(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function unpauseTokens(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function collectRevenue(address[] calldata tokens_) external {}\n\n    /// @inheritdoc IFluidLiquidityAdmin\n    function updateExchangePrices(\n        address[] calldata tokens_\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_) {}\n\n    /// @inheritdoc IFluidLiquidityLogic\n    function operate(\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        address withdrawTo_,\n        address borrowTo_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\n\n    /// @inheritdoc IFluidLiquidityLogic\n    function operateOnBehalfOf(\n        address onBehalf_,\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\n}\n"},"contracts/liquidity/adminModule/structs.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity >=0.8.21 <=0.8.29;\n\nabstract contract Structs {\n    struct AddressBool {\n        address addr;\n        bool value;\n    }\n\n    struct AddressUint256 {\n        address addr;\n        uint256 value;\n    }\n\n    /// @notice struct to set borrow rate data for version 1\n    struct RateDataV1Params {\n        ///\n        /// @param token for rate data\n        address token;\n        ///\n        /// @param kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink usually means slow increase in rate, once utilization is above kink borrow rate increases fast\n        uint256 kink;\n        ///\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\n        /// i.e. constant minimum borrow rate\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\n        uint256 rateAtUtilizationZero;\n        ///\n        /// @param rateAtUtilizationKink borrow rate when utilization is at kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at kink then rateAtUtilizationKink would be 700\n        uint256 rateAtUtilizationKink;\n        ///\n        /// @param rateAtUtilizationMax borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\n        uint256 rateAtUtilizationMax;\n    }\n\n    /// @notice struct to set borrow rate data for version 2\n    struct RateDataV2Params {\n        ///\n        /// @param token for rate data\n        address token;\n        ///\n        /// @param kink1 first kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink 1 usually means slow increase in rate, once utilization is above kink 1 borrow rate increases faster\n        uint256 kink1;\n        ///\n        /// @param kink2 second kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\n        /// utilization below kink 2 usually means slow / medium increase in rate, once utilization is above kink 2 borrow rate increases fast\n        uint256 kink2;\n        ///\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\n        /// i.e. constant minimum borrow rate\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\n        uint256 rateAtUtilizationZero;\n        ///\n        /// @param rateAtUtilizationKink1 desired borrow rate when utilization is at first kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at first kink then rateAtUtilizationKink would be 700\n        uint256 rateAtUtilizationKink1;\n        ///\n        /// @param rateAtUtilizationKink2 desired borrow rate when utilization is at second kink. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 7% at second kink then rateAtUtilizationKink would be 1_200\n        uint256 rateAtUtilizationKink2;\n        ///\n        /// @param rateAtUtilizationMax desired borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\n        uint256 rateAtUtilizationMax;\n    }\n\n    /// @notice struct to set token config\n    struct TokenConfig {\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param fee charges on borrower's interest. in 1e2: 100% = 10_000; 1% = 100\n        uint256 fee;\n        ///\n        /// @param threshold on when to update the storage slot. in 1e2: 100% = 10_000; 1% = 100\n        uint256 threshold;\n        ///\n        /// @param maxUtilization maximum allowed utilization. in 1e2: 100% = 10_000; 1% = 100\n        ///                       set to 100% to disable and have default limit of 100% (avoiding SLOAD).\n        uint256 maxUtilization;\n    }\n\n    /// @notice struct to set user supply & withdrawal config\n    struct UserSupplyConfig {\n        ///\n        /// @param user address\n        address user;\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param mode: 0 = without interest. 1 = with interest\n        uint8 mode;\n        ///\n        /// @param expandPercent withdrawal limit expand percent. in 1e2: 100% = 10_000; 1% = 100\n        /// Also used to calculate rate at which withdrawal limit should decrease (instant).\n        uint256 expandPercent;\n        ///\n        /// @param expandDuration withdrawal limit expand duration in seconds.\n        /// used to calculate rate together with expandPercent\n        uint256 expandDuration;\n        ///\n        /// @param baseWithdrawalLimit base limit, below this, user can withdraw the entire amount.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 baseWithdrawalLimit;\n    }\n\n    /// @notice struct to set user borrow & payback config\n    struct UserBorrowConfig {\n        ///\n        /// @param user address\n        address user;\n        ///\n        /// @param token address\n        address token;\n        ///\n        /// @param mode: 0 = without interest. 1 = with interest\n        uint8 mode;\n        ///\n        /// @param expandPercent debt limit expand percent. in 1e2: 100% = 10_000; 1% = 100\n        /// Also used to calculate rate at which debt limit should decrease (instant).\n        uint256 expandPercent;\n        ///\n        /// @param expandDuration debt limit expand duration in seconds.\n        /// used to calculate rate together with expandPercent\n        uint256 expandDuration;\n        ///\n        /// @param baseDebtCeiling base borrow limit. until here, borrow limit remains as baseDebtCeiling\n        /// (user can borrow until this point at once without stepped expansion). Above this, automated limit comes in place.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 baseDebtCeiling;\n        ///\n        /// @param maxDebtCeiling max borrow ceiling, maximum amount the user can borrow.\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\n        /// with interest -> raw, without interest -> normal\n        uint256 maxDebtCeiling;\n    }\n}\n"},"contracts/infiniteProxy/interfaces/iProxy.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.21 <=0.8.29;\n\ninterface IProxy {\n    function setAdmin(address newAdmin_) external;\n\n    function setDummyImplementation(address newDummyImplementation_) external;\n\n    function addImplementation(address implementation_, bytes4[] calldata sigs_) external;\n\n    function removeImplementation(address implementation_) external;\n\n    function getAdmin() external view returns (address);\n\n    function getDummyImplementation() external view returns (address);\n\n    function getImplementationSigs(address impl_) external view returns (bytes4[] memory);\n\n    function getSigsImplementation(bytes4 sig_) external view returns (address);\n\n    function readFromStorage(bytes32 slot_) external view returns (uint256 result_);\n}\n"},"contracts/liquidity/interfaces/iLiquidity.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity >=0.8.21 <=0.8.29;\n\nimport { IProxy } from \"../../infiniteProxy/interfaces/iProxy.sol\";\nimport { Structs as AdminModuleStructs } from \"../adminModule/structs.sol\";\n\ninterface IFluidLiquidityAdmin {\n    /// @notice adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.\n    ///         auths can be helpful in reducing governance overhead where it's not needed.\n    /// @param authsStatus_ array of structs setting allowed status for an address.\n    ///                     status true => add auth, false => remove auth\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external;\n\n    /// @notice adds/removes guardians. Only callable by Governance.\n    /// @param guardiansStatus_ array of structs setting allowed status for an address.\n    ///                         status true => add guardian, false => remove guardian\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external;\n\n    /// @notice changes the revenue collector address (contract that is sent revenue). Only callable by Governance.\n    /// @param revenueCollector_  new revenue collector address\n    function updateRevenueCollector(address revenueCollector_) external;\n\n    /// @notice changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths.\n    /// @param newStatus_ new status\n    ///        status = 2 -> pause, status = 1 -> resume.\n    function changeStatus(uint256 newStatus_) external;\n\n    /// @notice                  update tokens rate data version 1. Only callable by Auths.\n    /// @param tokensRateData_   array of RateDataV1Params with rate data to set for each token\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external;\n\n    /// @notice                  update tokens rate data version 2. Only callable by Auths.\n    /// @param tokensRateData_   array of RateDataV2Params with rate data to set for each token\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external;\n\n    /// @notice updates token configs: fee charge on borrowers interest & storage update utilization threshold.\n    ///         Only callable by Auths.\n    /// @param tokenConfigs_ contains token address, fee & utilization threshold\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external;\n\n    /// @notice updates user classes: 0 is for new protocols, 1 is for established protocols.\n    ///         Only callable by Auths.\n    /// @param userClasses_ struct array of uint256 value to assign for each user address\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external;\n\n    /// @notice sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.\n    ///         Only callable by Auths.\n    ///         Resets decay limit to 0.\n    /// @param userSupplyConfigs_ struct array containing user supply config, see `UserSupplyConfig` struct for more info\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external;\n\n    /// @notice sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0\n    /// @param user_ user address for which to update the withdrawal limit\n    /// @param token_ token address for which to update the withdrawal limit\n    /// @param newLimit_ new limit until which user supply can decrease to.\n    ///                  Important: input in raw. Must account for exchange price in input param calculation.\n    ///                  Note any limit that is < max expansion or > current user supply will set max expansion limit or\n    ///                  current user supply as limit respectively.\n    ///                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes\n    ///                  below base limit then fully down to 0.\n    ///                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit).\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external;\n\n    /// @notice setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.\n    ///         Only callable by Auths.\n    /// @param userBorrowConfigs_ struct array containing user borrow config, see `UserBorrowConfig` struct for more info\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external;\n\n    /// @notice pause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\n    /// Only callable by Guardians.\n    /// @param user_          address of user to pause operations for\n    /// @param supplyTokens_  token addresses to pause withdrawals for\n    /// @param borrowTokens_  token addresses to pause borrowings for\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\n\n    /// @notice unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\n    /// Only callable by Guardians.\n    /// @param user_          address of user to unpause operations for\n    /// @param supplyTokens_  token addresses to unpause withdrawals for\n    /// @param borrowTokens_  token addresses to unpause borrowings for\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\n\n    /// @notice pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig.\n    /// Only callable by Guardians.\n    /// @param tokens_ token addresses to pause\n    function pauseTokens(address[] calldata tokens_) external;\n\n    /// @notice unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig.\n    /// Only callable by Guardians.\n    /// @param tokens_ token addresses to unpause\n    function unpauseTokens(address[] calldata tokens_) external;\n\n    /// @notice         collects revenue for tokens to configured revenueCollector address.\n    /// @param tokens_  array of tokens to collect revenue for\n    /// @dev            Note that this can revert if token balance is < revenueAmount (utilization > 100%)\n    function collectRevenue(address[] calldata tokens_) external;\n\n    /// @notice gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage.\n    /// @param tokens_ tokens to update exchange prices for\n    /// @return supplyExchangePrices_ new supply rates of overall system for each token\n    /// @return borrowExchangePrices_ new borrow rates of overall system for each token\n    function updateExchangePrices(\n        address[] calldata tokens_\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_);\n}\n\ninterface IFluidLiquidityLogic is IFluidLiquidityAdmin {\n    /// @notice Single function which handles supply, withdraw, borrow & payback\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\n    /// @param supplyAmount_ if +ve then supply, if -ve then withdraw, if 0 then nothing\n    /// @param borrowAmount_ if +ve then borrow, if -ve then payback, if 0 then nothing\n    /// @param withdrawTo_ if withdrawal then to which address\n    /// @param borrowTo_ if borrow then to which address\n    /// @param callbackData_ callback data passed to `liquidityCallback` method of protocol\n    /// @return memVar3_ updated supplyExchangePrice\n    /// @return memVar4_ updated borrowExchangePrice\n    /// @dev to trigger skipping in / out transfers (gas optimization):\n    /// -  ` callbackData_` MUST be encoded so that \"from\" address is the last 20 bytes in the last 32 bytes slot,\n    ///     also for native token operations where liquidityCallback is not triggered!\n    ///     from address must come at last position if there is more data. I.e. encode like:\n    ///     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end\n    ///     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end.\n    /// -   this \"from\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender`\n    /// -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS\n    ///     in the slot before (bytes 32 to 63)\n    /// -   `msg.value` must be 0.\n    /// -   Amounts must be either:\n    ///     -  supply(+) == borrow(+), withdraw(-) == payback(-).\n    ///     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).\n    function operate(\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        address withdrawTo_,\n        address borrowTo_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\n\n    /// @notice Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.\n    ///         Only callable by auths or governance. Token transfers still come from msg.sender:\n    ///         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().\n    ///         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.\n    ///         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused.\n    /// @param onBehalf_ the address (protocol) whose position to operate on. Must be != address(0)\n    ///                   and must have a configured position (via admin) for the given token.\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\n    /// @param supplyAmount_ if +ve then supply, if 0 then nothing. Must be >= 0.\n    /// @param borrowAmount_ if -ve then payback, if 0 then nothing. Must be <= 0.\n    ///                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.\n    /// @param callbackData_ must be empty (length 0). Custom callbackData-powered transfer shortcuts like\n    ///                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.\n    /// @return memVar3_ updated supplyExchangePrice\n    /// @return memVar4_ updated borrowExchangePrice\n    function operateOnBehalfOf(\n        address onBehalf_,\n        address token_,\n        int256 supplyAmount_,\n        int256 borrowAmount_,\n        bytes calldata callbackData_\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\n}\n\ninterface IFluidLiquidity is IProxy, IFluidLiquidityLogic {}\n"}},"language":"Solidity","settings":{"metadata":{"useLiteralContent":true},"optimizer":{"runs":10000000,"enabled":true},"evmVersion":"cancun"}},"stdJsonOutput":{"sources":{"contracts/liquidity/dummyImpl.sol":{"id":2},"contracts/liquidity/adminModule/structs.sol":{"id":1},"contracts/infiniteProxy/interfaces/iProxy.sol":{"id":0},"contracts/liquidity/interfaces/iLiquidity.sol":{"id":3}},"contracts":{"contracts/liquidity/dummyImpl.sol":{"FluidLiquidityDummyImpl":{"abi":[{"name":"changeStatus","type":"function","inputs":[{"name":"newStatus_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"collectRevenue","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"operate","type":"function","inputs":[{"name":"token_","type":"address","internalType":"address"},{"name":"supplyAmount_","type":"int256","internalType":"int256"},{"name":"borrowAmount_","type":"int256","internalType":"int256"},{"name":"withdrawTo_","type":"address","internalType":"address"},{"name":"borrowTo_","type":"address","internalType":"address"},{"name":"callbackData_","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"memVar3_","type":"uint256","internalType":"uint256"},{"name":"memVar4_","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"operateOnBehalfOf","type":"function","inputs":[{"name":"onBehalf_","type":"address","internalType":"address"},{"name":"token_","type":"address","internalType":"address"},{"name":"supplyAmount_","type":"int256","internalType":"int256"},{"name":"borrowAmount_","type":"int256","internalType":"int256"},{"name":"callbackData_","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"memVar3_","type":"uint256","internalType":"uint256"},{"name":"memVar4_","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"pauseTokens","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pauseUser","type":"function","inputs":[{"name":"user_","type":"address","internalType":"address"},{"name":"supplyTokens_","type":"address[]","internalType":"address[]"},{"name":"borrowTokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpauseTokens","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpauseUser","type":"function","inputs":[{"name":"user_","type":"address","internalType":"address"},{"name":"supplyTokens_","type":"address[]","internalType":"address[]"},{"name":"borrowTokens_","type":"address[]","internalType":"address[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateAuths","type":"function","inputs":[{"name":"authsStatus_","type":"tuple[]","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"internalType":"struct Structs.AddressBool[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateExchangePrices","type":"function","inputs":[{"name":"tokens_","type":"address[]","internalType":"address[]"}],"outputs":[{"name":"supplyExchangePrices_","type":"uint256[]","internalType":"uint256[]"},{"name":"borrowExchangePrices_","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"nonpayable"},{"name":"updateGuardians","type":"function","inputs":[{"name":"guardiansStatus_","type":"tuple[]","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"internalType":"struct Structs.AddressBool[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateRateDataV1s","type":"function","inputs":[{"name":"tokensRateData_","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"kink","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationZero","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationKink","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationMax","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.RateDataV1Params[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateRateDataV2s","type":"function","inputs":[{"name":"tokensRateData_","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"kink1","type":"uint256","internalType":"uint256"},{"name":"kink2","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationZero","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationKink1","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationKink2","type":"uint256","internalType":"uint256"},{"name":"rateAtUtilizationMax","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.RateDataV2Params[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateRevenueCollector","type":"function","inputs":[{"name":"revenueCollector_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateTokenConfigs","type":"function","inputs":[{"name":"tokenConfigs_","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"fee","type":"uint256","internalType":"uint256"},{"name":"threshold","type":"uint256","internalType":"uint256"},{"name":"maxUtilization","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.TokenConfig[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserBorrowConfigs","type":"function","inputs":[{"name":"userBorrowConfigs_","type":"tuple[]","components":[{"name":"user","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"mode","type":"uint8","internalType":"uint8"},{"name":"expandPercent","type":"uint256","internalType":"uint256"},{"name":"expandDuration","type":"uint256","internalType":"uint256"},{"name":"baseDebtCeiling","type":"uint256","internalType":"uint256"},{"name":"maxDebtCeiling","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.UserBorrowConfig[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserClasses","type":"function","inputs":[{"name":"userClasses_","type":"tuple[]","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.AddressUint256[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserSupplyConfigs","type":"function","inputs":[{"name":"userSupplyConfigs_","type":"tuple[]","components":[{"name":"user","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"mode","type":"uint8","internalType":"uint8"},{"name":"expandPercent","type":"uint256","internalType":"uint256"},{"name":"expandDuration","type":"uint256","internalType":"uint256"},{"name":"baseWithdrawalLimit","type":"uint256","internalType":"uint256"}],"internalType":"struct Structs.UserSupplyConfig[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateUserWithdrawalLimit","type":"function","inputs":[{"name":"user_","type":"address","internalType":"address"},{"name":"token_","type":"address","internalType":"address"},{"name":"newLimit_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.29+commit.ab55807c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newStatus_\",\"type\":\"uint256\"}],\"name\":\"changeStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens_\",\"type\":\"address[]\"}],\"name\":\"collectRevenue\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token_\",\"type\":\"address\"},{\"internalType\":\"int256\",\"name\":\"supplyAmount_\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"borrowAmount_\",\"type\":\"int256\"},{\"internalType\":\"address\",\"name\":\"withdrawTo_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"borrowTo_\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callbackData_\",\"type\":\"bytes\"}],\"name\":\"operate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"memVar3_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"memVar4_\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"onBehalf_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token_\",\"type\":\"address\"},{\"internalType\":\"int256\",\"name\":\"supplyAmount_\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"borrowAmount_\",\"type\":\"int256\"},{\"internalType\":\"bytes\",\"name\":\"callbackData_\",\"type\":\"bytes\"}],\"name\":\"operateOnBehalfOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"memVar3_\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"memVar4_\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens_\",\"type\":\"address[]\"}],\"name\":\"pauseTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user_\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"supplyTokens_\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"borrowTokens_\",\"type\":\"address[]\"}],\"name\":\"pauseUser\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens_\",\"type\":\"address[]\"}],\"name\":\"unpauseTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user_\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"supplyTokens_\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"borrowTokens_\",\"type\":\"address[]\"}],\"name\":\"unpauseUser\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"internalType\":\"struct Structs.AddressBool[]\",\"name\":\"authsStatus_\",\"type\":\"tuple[]\"}],\"name\":\"updateAuths\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens_\",\"type\":\"address[]\"}],\"name\":\"updateExchangePrices\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"supplyExchangePrices_\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"borrowExchangePrices_\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"internalType\":\"struct Structs.AddressBool[]\",\"name\":\"guardiansStatus_\",\"type\":\"tuple[]\"}],\"name\":\"updateGuardians\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"kink\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateAtUtilizationZero\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateAtUtilizationKink\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateAtUtilizationMax\",\"type\":\"uint256\"}],\"internalType\":\"struct Structs.RateDataV1Params[]\",\"name\":\"tokensRateData_\",\"type\":\"tuple[]\"}],\"name\":\"updateRateDataV1s\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"kink1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"kink2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateAtUtilizationZero\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateAtUtilizationKink1\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateAtUtilizationKink2\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateAtUtilizationMax\",\"type\":\"uint256\"}],\"internalType\":\"struct Structs.RateDataV2Params[]\",\"name\":\"tokensRateData_\",\"type\":\"tuple[]\"}],\"name\":\"updateRateDataV2s\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"revenueCollector_\",\"type\":\"address\"}],\"name\":\"updateRevenueCollector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"threshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxUtilization\",\"type\":\"uint256\"}],\"internalType\":\"struct Structs.TokenConfig[]\",\"name\":\"tokenConfigs_\",\"type\":\"tuple[]\"}],\"name\":\"updateTokenConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"mode\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"expandPercent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expandDuration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"baseDebtCeiling\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDebtCeiling\",\"type\":\"uint256\"}],\"internalType\":\"struct Structs.UserBorrowConfig[]\",\"name\":\"userBorrowConfigs_\",\"type\":\"tuple[]\"}],\"name\":\"updateUserBorrowConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct Structs.AddressUint256[]\",\"name\":\"userClasses_\",\"type\":\"tuple[]\"}],\"name\":\"updateUserClasses\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"mode\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"expandPercent\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expandDuration\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"baseWithdrawalLimit\",\"type\":\"uint256\"}],\"internalType\":\"struct Structs.UserSupplyConfig[]\",\"name\":\"userSupplyConfigs_\",\"type\":\"tuple[]\"}],\"name\":\"updateUserSupplyConfigs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"newLimit_\",\"type\":\"uint256\"}],\"name\":\"updateUserWithdrawalLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation\",\"kind\":\"dev\",\"methods\":{\"changeStatus(uint256)\":{\"params\":{\"newStatus_\":\"new status        status = 2 -> pause, status = 1 -> resume.\"}},\"collectRevenue(address[])\":{\"details\":\"Note that this can revert if token balance is < revenueAmount (utilization > 100%)\",\"params\":{\"tokens_\":\"array of tokens to collect revenue for\"}},\"operate(address,int256,int256,address,address,bytes)\":{\"details\":\"to trigger skipping in / out transfers (gas optimization): -  ` callbackData_` MUST be encoded so that \\\"from\\\" address is the last 20 bytes in the last 32 bytes slot,     also for native token operations where liquidityCallback is not triggered!     from address must come at last position if there is more data. I.e. encode like:     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end. -   this \\\"from\\\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender` -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS     in the slot before (bytes 32 to 63) -   `msg.value` must be 0. -   Amounts must be either:     -  supply(+) == borrow(+), withdraw(-) == payback(-).     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).\",\"params\":{\"borrowAmount_\":\"if +ve then borrow, if -ve then payback, if 0 then nothing\",\"borrowTo_\":\"if borrow then to which address\",\"callbackData_\":\"callback data passed to `liquidityCallback` method of protocol\",\"supplyAmount_\":\"if +ve then supply, if -ve then withdraw, if 0 then nothing\",\"token_\":\"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\",\"withdrawTo_\":\"if withdrawal then to which address\"},\"returns\":{\"memVar3_\":\"updated supplyExchangePrice\",\"memVar4_\":\"updated borrowExchangePrice\"}},\"operateOnBehalfOf(address,address,int256,int256,bytes)\":{\"params\":{\"borrowAmount_\":\"if -ve then payback, if 0 then nothing. Must be <= 0.                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.\",\"callbackData_\":\"must be empty (length 0). Custom callbackData-powered transfer shortcuts like                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.\",\"onBehalf_\":\"the address (protocol) whose position to operate on. Must be != address(0)                   and must have a configured position (via admin) for the given token.\",\"supplyAmount_\":\"if +ve then supply, if 0 then nothing. Must be >= 0.\",\"token_\":\"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\"},\"returns\":{\"memVar3_\":\"updated supplyExchangePrice\",\"memVar4_\":\"updated borrowExchangePrice\"}},\"pauseTokens(address[])\":{\"params\":{\"tokens_\":\"token addresses to pause\"}},\"pauseUser(address,address[],address[])\":{\"params\":{\"borrowTokens_\":\"token addresses to pause borrowings for\",\"supplyTokens_\":\"token addresses to pause withdrawals for\",\"user_\":\"address of user to pause operations for\"}},\"unpauseTokens(address[])\":{\"params\":{\"tokens_\":\"token addresses to unpause\"}},\"unpauseUser(address,address[],address[])\":{\"params\":{\"borrowTokens_\":\"token addresses to unpause borrowings for\",\"supplyTokens_\":\"token addresses to unpause withdrawals for\",\"user_\":\"address of user to unpause operations for\"}},\"updateAuths((address,bool)[])\":{\"params\":{\"authsStatus_\":\"array of structs setting allowed status for an address.                     status true => add auth, false => remove auth\"}},\"updateExchangePrices(address[])\":{\"params\":{\"tokens_\":\"tokens to update exchange prices for\"},\"returns\":{\"borrowExchangePrices_\":\"new borrow rates of overall system for each token\",\"supplyExchangePrices_\":\"new supply rates of overall system for each token\"}},\"updateGuardians((address,bool)[])\":{\"params\":{\"guardiansStatus_\":\"array of structs setting allowed status for an address.                         status true => add guardian, false => remove guardian\"}},\"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])\":{\"params\":{\"tokensRateData_\":\"array of RateDataV1Params with rate data to set for each token\"}},\"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])\":{\"params\":{\"tokensRateData_\":\"array of RateDataV2Params with rate data to set for each token\"}},\"updateRevenueCollector(address)\":{\"params\":{\"revenueCollector_\":\"new revenue collector address\"}},\"updateTokenConfigs((address,uint256,uint256,uint256)[])\":{\"params\":{\"tokenConfigs_\":\"contains token address, fee & utilization threshold\"}},\"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])\":{\"params\":{\"userBorrowConfigs_\":\"struct array containing user borrow config, see `UserBorrowConfig` struct for more info\"}},\"updateUserClasses((address,uint256)[])\":{\"params\":{\"userClasses_\":\"struct array of uint256 value to assign for each user address\"}},\"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])\":{\"params\":{\"userSupplyConfigs_\":\"struct array containing user supply config, see `UserSupplyConfig` struct for more info\"}},\"updateUserWithdrawalLimit(address,address,uint256)\":{\"params\":{\"newLimit_\":\"new limit until which user supply can decrease to.                  Important: input in raw. Must account for exchange price in input param calculation.                  Note any limit that is < max expansion or > current user supply will set max expansion limit or                  current user supply as limit respectively.                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes                  below base limit then fully down to 0.                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit).\",\"token_\":\"token address for which to update the withdrawal limit\",\"user_\":\"user address for which to update the withdrawal limit\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"changeStatus(uint256)\":{\"notice\":\"changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths.\"},\"collectRevenue(address[])\":{\"notice\":\"collects revenue for tokens to configured revenueCollector address.\"},\"operate(address,int256,int256,address,address,bytes)\":{\"notice\":\"Single function which handles supply, withdraw, borrow & payback\"},\"operateOnBehalfOf(address,address,int256,int256,bytes)\":{\"notice\":\"Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.         Only callable by auths or governance. Token transfers still come from msg.sender:         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused.\"},\"pauseTokens(address[])\":{\"notice\":\"pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig. Only callable by Guardians.\"},\"pauseUser(address,address[],address[])\":{\"notice\":\"pause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians.\"},\"unpauseTokens(address[])\":{\"notice\":\"unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig. Only callable by Guardians.\"},\"unpauseUser(address,address[],address[])\":{\"notice\":\"unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians.\"},\"updateAuths((address,bool)[])\":{\"notice\":\"adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.         auths can be helpful in reducing governance overhead where it's not needed.\"},\"updateExchangePrices(address[])\":{\"notice\":\"gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage.\"},\"updateGuardians((address,bool)[])\":{\"notice\":\"adds/removes guardians. Only callable by Governance.\"},\"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])\":{\"notice\":\"update tokens rate data version 1. Only callable by Auths.\"},\"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])\":{\"notice\":\"update tokens rate data version 2. Only callable by Auths.\"},\"updateRevenueCollector(address)\":{\"notice\":\"changes the revenue collector address (contract that is sent revenue). Only callable by Governance.\"},\"updateTokenConfigs((address,uint256,uint256,uint256)[])\":{\"notice\":\"updates token configs: fee charge on borrowers interest & storage update utilization threshold.         Only callable by Auths.\"},\"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])\":{\"notice\":\"setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths.\"},\"updateUserClasses((address,uint256)[])\":{\"notice\":\"updates user classes: 0 is for new protocols, 1 is for established protocols.         Only callable by Auths.\"},\"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])\":{\"notice\":\"sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths.         Resets decay limit to 0.\"},\"updateUserWithdrawalLimit(address,address,uint256)\":{\"notice\":\"sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0\"}},\"notice\":\"Liquidity dummy implementation used for Fluid Liquidity infinite proxy.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/liquidity/dummyImpl.sol\":\"FluidLiquidityDummyImpl\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":10000000},\"remappings\":[]},\"sources\":{\"contracts/infiniteProxy/interfaces/iProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.21 <=0.8.29;\\n\\ninterface IProxy {\\n    function setAdmin(address newAdmin_) external;\\n\\n    function setDummyImplementation(address newDummyImplementation_) external;\\n\\n    function addImplementation(address implementation_, bytes4[] calldata sigs_) external;\\n\\n    function removeImplementation(address implementation_) external;\\n\\n    function getAdmin() external view returns (address);\\n\\n    function getDummyImplementation() external view returns (address);\\n\\n    function getImplementationSigs(address impl_) external view returns (bytes4[] memory);\\n\\n    function getSigsImplementation(bytes4 sig_) external view returns (address);\\n\\n    function readFromStorage(bytes32 slot_) external view returns (uint256 result_);\\n}\\n\",\"keccak256\":\"0x30d8b90d077a4ab2b116788f4b47ec7009dc49e11ef76f1d7bf07bd0cc65b406\",\"license\":\"MIT\"},\"contracts/liquidity/adminModule/structs.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity >=0.8.21 <=0.8.29;\\n\\nabstract contract Structs {\\n    struct AddressBool {\\n        address addr;\\n        bool value;\\n    }\\n\\n    struct AddressUint256 {\\n        address addr;\\n        uint256 value;\\n    }\\n\\n    /// @notice struct to set borrow rate data for version 1\\n    struct RateDataV1Params {\\n        ///\\n        /// @param token for rate data\\n        address token;\\n        ///\\n        /// @param kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\\n        /// utilization below kink usually means slow increase in rate, once utilization is above kink borrow rate increases fast\\n        uint256 kink;\\n        ///\\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\\n        /// i.e. constant minimum borrow rate\\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\\n        uint256 rateAtUtilizationZero;\\n        ///\\n        /// @param rateAtUtilizationKink borrow rate when utilization is at kink. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 7% at kink then rateAtUtilizationKink would be 700\\n        uint256 rateAtUtilizationKink;\\n        ///\\n        /// @param rateAtUtilizationMax borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\\n        uint256 rateAtUtilizationMax;\\n    }\\n\\n    /// @notice struct to set borrow rate data for version 2\\n    struct RateDataV2Params {\\n        ///\\n        /// @param token for rate data\\n        address token;\\n        ///\\n        /// @param kink1 first kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\\n        /// utilization below kink 1 usually means slow increase in rate, once utilization is above kink 1 borrow rate increases faster\\n        uint256 kink1;\\n        ///\\n        /// @param kink2 second kink in borrow rate. in 1e2: 100% = 10_000; 1% = 100\\n        /// utilization below kink 2 usually means slow / medium increase in rate, once utilization is above kink 2 borrow rate increases fast\\n        uint256 kink2;\\n        ///\\n        /// @param rateAtUtilizationZero desired borrow rate when utilization is zero. in 1e2: 100% = 10_000; 1% = 100\\n        /// i.e. constant minimum borrow rate\\n        /// e.g. at utilization = 0.01% rate could still be at least 4% (rateAtUtilizationZero would be 400 then)\\n        uint256 rateAtUtilizationZero;\\n        ///\\n        /// @param rateAtUtilizationKink1 desired borrow rate when utilization is at first kink. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 7% at first kink then rateAtUtilizationKink would be 700\\n        uint256 rateAtUtilizationKink1;\\n        ///\\n        /// @param rateAtUtilizationKink2 desired borrow rate when utilization is at second kink. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 7% at second kink then rateAtUtilizationKink would be 1_200\\n        uint256 rateAtUtilizationKink2;\\n        ///\\n        /// @param rateAtUtilizationMax desired borrow rate when utilization is maximum at 100%. in 1e2: 100% = 10_000; 1% = 100\\n        /// e.g. when rate should be 125% at 100% then rateAtUtilizationMax would be 12_500\\n        uint256 rateAtUtilizationMax;\\n    }\\n\\n    /// @notice struct to set token config\\n    struct TokenConfig {\\n        ///\\n        /// @param token address\\n        address token;\\n        ///\\n        /// @param fee charges on borrower's interest. in 1e2: 100% = 10_000; 1% = 100\\n        uint256 fee;\\n        ///\\n        /// @param threshold on when to update the storage slot. in 1e2: 100% = 10_000; 1% = 100\\n        uint256 threshold;\\n        ///\\n        /// @param maxUtilization maximum allowed utilization. in 1e2: 100% = 10_000; 1% = 100\\n        ///                       set to 100% to disable and have default limit of 100% (avoiding SLOAD).\\n        uint256 maxUtilization;\\n    }\\n\\n    /// @notice struct to set user supply & withdrawal config\\n    struct UserSupplyConfig {\\n        ///\\n        /// @param user address\\n        address user;\\n        ///\\n        /// @param token address\\n        address token;\\n        ///\\n        /// @param mode: 0 = without interest. 1 = with interest\\n        uint8 mode;\\n        ///\\n        /// @param expandPercent withdrawal limit expand percent. in 1e2: 100% = 10_000; 1% = 100\\n        /// Also used to calculate rate at which withdrawal limit should decrease (instant).\\n        uint256 expandPercent;\\n        ///\\n        /// @param expandDuration withdrawal limit expand duration in seconds.\\n        /// used to calculate rate together with expandPercent\\n        uint256 expandDuration;\\n        ///\\n        /// @param baseWithdrawalLimit base limit, below this, user can withdraw the entire amount.\\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\\n        /// with interest -> raw, without interest -> normal\\n        uint256 baseWithdrawalLimit;\\n    }\\n\\n    /// @notice struct to set user borrow & payback config\\n    struct UserBorrowConfig {\\n        ///\\n        /// @param user address\\n        address user;\\n        ///\\n        /// @param token address\\n        address token;\\n        ///\\n        /// @param mode: 0 = without interest. 1 = with interest\\n        uint8 mode;\\n        ///\\n        /// @param expandPercent debt limit expand percent. in 1e2: 100% = 10_000; 1% = 100\\n        /// Also used to calculate rate at which debt limit should decrease (instant).\\n        uint256 expandPercent;\\n        ///\\n        /// @param expandDuration debt limit expand duration in seconds.\\n        /// used to calculate rate together with expandPercent\\n        uint256 expandDuration;\\n        ///\\n        /// @param baseDebtCeiling base borrow limit. until here, borrow limit remains as baseDebtCeiling\\n        /// (user can borrow until this point at once without stepped expansion). Above this, automated limit comes in place.\\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\\n        /// with interest -> raw, without interest -> normal\\n        uint256 baseDebtCeiling;\\n        ///\\n        /// @param maxDebtCeiling max borrow ceiling, maximum amount the user can borrow.\\n        /// amount in raw (to be multiplied with exchange price) or normal depends on configured mode in user config for the token:\\n        /// with interest -> raw, without interest -> normal\\n        uint256 maxDebtCeiling;\\n    }\\n}\\n\",\"keccak256\":\"0xfa7cbe07b97f45acd0460deaff1ef54de9473164249e5527ee4da6efb6bf7e65\",\"license\":\"BUSL-1.1\"},\"contracts/liquidity/dummyImpl.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity >=0.8.21 <=0.8.29;\\n\\nimport { IFluidLiquidityLogic, IFluidLiquidityAdmin } from \\\"./interfaces/iLiquidity.sol\\\";\\nimport { Structs as AdminModuleStructs } from \\\"./adminModule/structs.sol\\\";\\n\\n/// @notice Liquidity dummy implementation used for Fluid Liquidity infinite proxy.\\n/// @dev see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation\\ncontract FluidLiquidityDummyImpl is IFluidLiquidityLogic {\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateRevenueCollector(address revenueCollector_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function changeStatus(uint256 newStatus_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function pauseTokens(address[] calldata tokens_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function unpauseTokens(address[] calldata tokens_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function collectRevenue(address[] calldata tokens_) external {}\\n\\n    /// @inheritdoc IFluidLiquidityAdmin\\n    function updateExchangePrices(\\n        address[] calldata tokens_\\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_) {}\\n\\n    /// @inheritdoc IFluidLiquidityLogic\\n    function operate(\\n        address token_,\\n        int256 supplyAmount_,\\n        int256 borrowAmount_,\\n        address withdrawTo_,\\n        address borrowTo_,\\n        bytes calldata callbackData_\\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\\n\\n    /// @inheritdoc IFluidLiquidityLogic\\n    function operateOnBehalfOf(\\n        address onBehalf_,\\n        address token_,\\n        int256 supplyAmount_,\\n        int256 borrowAmount_,\\n        bytes calldata callbackData_\\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_) {}\\n}\\n\",\"keccak256\":\"0xb49dc40f3c12b32cd1eb93b9eb8ac711c106e33cd85ccf4250a4e7c0d7adc576\",\"license\":\"BUSL-1.1\"},\"contracts/liquidity/interfaces/iLiquidity.sol\":{\"content\":\"//SPDX-License-Identifier: MIT\\npragma solidity >=0.8.21 <=0.8.29;\\n\\nimport { IProxy } from \\\"../../infiniteProxy/interfaces/iProxy.sol\\\";\\nimport { Structs as AdminModuleStructs } from \\\"../adminModule/structs.sol\\\";\\n\\ninterface IFluidLiquidityAdmin {\\n    /// @notice adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.\\n    ///         auths can be helpful in reducing governance overhead where it's not needed.\\n    /// @param authsStatus_ array of structs setting allowed status for an address.\\n    ///                     status true => add auth, false => remove auth\\n    function updateAuths(AdminModuleStructs.AddressBool[] calldata authsStatus_) external;\\n\\n    /// @notice adds/removes guardians. Only callable by Governance.\\n    /// @param guardiansStatus_ array of structs setting allowed status for an address.\\n    ///                         status true => add guardian, false => remove guardian\\n    function updateGuardians(AdminModuleStructs.AddressBool[] calldata guardiansStatus_) external;\\n\\n    /// @notice changes the revenue collector address (contract that is sent revenue). Only callable by Governance.\\n    /// @param revenueCollector_  new revenue collector address\\n    function updateRevenueCollector(address revenueCollector_) external;\\n\\n    /// @notice changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths.\\n    /// @param newStatus_ new status\\n    ///        status = 2 -> pause, status = 1 -> resume.\\n    function changeStatus(uint256 newStatus_) external;\\n\\n    /// @notice                  update tokens rate data version 1. Only callable by Auths.\\n    /// @param tokensRateData_   array of RateDataV1Params with rate data to set for each token\\n    function updateRateDataV1s(AdminModuleStructs.RateDataV1Params[] calldata tokensRateData_) external;\\n\\n    /// @notice                  update tokens rate data version 2. Only callable by Auths.\\n    /// @param tokensRateData_   array of RateDataV2Params with rate data to set for each token\\n    function updateRateDataV2s(AdminModuleStructs.RateDataV2Params[] calldata tokensRateData_) external;\\n\\n    /// @notice updates token configs: fee charge on borrowers interest & storage update utilization threshold.\\n    ///         Only callable by Auths.\\n    /// @param tokenConfigs_ contains token address, fee & utilization threshold\\n    function updateTokenConfigs(AdminModuleStructs.TokenConfig[] calldata tokenConfigs_) external;\\n\\n    /// @notice updates user classes: 0 is for new protocols, 1 is for established protocols.\\n    ///         Only callable by Auths.\\n    /// @param userClasses_ struct array of uint256 value to assign for each user address\\n    function updateUserClasses(AdminModuleStructs.AddressUint256[] calldata userClasses_) external;\\n\\n    /// @notice sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.\\n    ///         Only callable by Auths.\\n    ///         Resets decay limit to 0.\\n    /// @param userSupplyConfigs_ struct array containing user supply config, see `UserSupplyConfig` struct for more info\\n    function updateUserSupplyConfigs(AdminModuleStructs.UserSupplyConfig[] memory userSupplyConfigs_) external;\\n\\n    /// @notice sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0\\n    /// @param user_ user address for which to update the withdrawal limit\\n    /// @param token_ token address for which to update the withdrawal limit\\n    /// @param newLimit_ new limit until which user supply can decrease to.\\n    ///                  Important: input in raw. Must account for exchange price in input param calculation.\\n    ///                  Note any limit that is < max expansion or > current user supply will set max expansion limit or\\n    ///                  current user supply as limit respectively.\\n    ///                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes\\n    ///                  below base limit then fully down to 0.\\n    ///                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit).\\n    function updateUserWithdrawalLimit(address user_, address token_, uint256 newLimit_) external;\\n\\n    /// @notice setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.\\n    ///         Only callable by Auths.\\n    /// @param userBorrowConfigs_ struct array containing user borrow config, see `UserBorrowConfig` struct for more info\\n    function updateUserBorrowConfigs(AdminModuleStructs.UserBorrowConfig[] memory userBorrowConfigs_) external;\\n\\n    /// @notice pause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\\n    /// Only callable by Guardians.\\n    /// @param user_          address of user to pause operations for\\n    /// @param supplyTokens_  token addresses to pause withdrawals for\\n    /// @param borrowTokens_  token addresses to pause borrowings for\\n    function pauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\\n\\n    /// @notice unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians).\\n    /// Only callable by Guardians.\\n    /// @param user_          address of user to unpause operations for\\n    /// @param supplyTokens_  token addresses to unpause withdrawals for\\n    /// @param borrowTokens_  token addresses to unpause borrowings for\\n    function unpauseUser(address user_, address[] calldata supplyTokens_, address[] calldata borrowTokens_) external;\\n\\n    /// @notice pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig.\\n    /// Only callable by Guardians.\\n    /// @param tokens_ token addresses to pause\\n    function pauseTokens(address[] calldata tokens_) external;\\n\\n    /// @notice unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig.\\n    /// Only callable by Guardians.\\n    /// @param tokens_ token addresses to unpause\\n    function unpauseTokens(address[] calldata tokens_) external;\\n\\n    /// @notice         collects revenue for tokens to configured revenueCollector address.\\n    /// @param tokens_  array of tokens to collect revenue for\\n    /// @dev            Note that this can revert if token balance is < revenueAmount (utilization > 100%)\\n    function collectRevenue(address[] calldata tokens_) external;\\n\\n    /// @notice gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage.\\n    /// @param tokens_ tokens to update exchange prices for\\n    /// @return supplyExchangePrices_ new supply rates of overall system for each token\\n    /// @return borrowExchangePrices_ new borrow rates of overall system for each token\\n    function updateExchangePrices(\\n        address[] calldata tokens_\\n    ) external returns (uint256[] memory supplyExchangePrices_, uint256[] memory borrowExchangePrices_);\\n}\\n\\ninterface IFluidLiquidityLogic is IFluidLiquidityAdmin {\\n    /// @notice Single function which handles supply, withdraw, borrow & payback\\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\\n    /// @param supplyAmount_ if +ve then supply, if -ve then withdraw, if 0 then nothing\\n    /// @param borrowAmount_ if +ve then borrow, if -ve then payback, if 0 then nothing\\n    /// @param withdrawTo_ if withdrawal then to which address\\n    /// @param borrowTo_ if borrow then to which address\\n    /// @param callbackData_ callback data passed to `liquidityCallback` method of protocol\\n    /// @return memVar3_ updated supplyExchangePrice\\n    /// @return memVar4_ updated borrowExchangePrice\\n    /// @dev to trigger skipping in / out transfers (gas optimization):\\n    /// -  ` callbackData_` MUST be encoded so that \\\"from\\\" address is the last 20 bytes in the last 32 bytes slot,\\n    ///     also for native token operations where liquidityCallback is not triggered!\\n    ///     from address must come at last position if there is more data. I.e. encode like:\\n    ///     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end\\n    ///     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end.\\n    /// -   this \\\"from\\\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender`\\n    /// -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS\\n    ///     in the slot before (bytes 32 to 63)\\n    /// -   `msg.value` must be 0.\\n    /// -   Amounts must be either:\\n    ///     -  supply(+) == borrow(+), withdraw(-) == payback(-).\\n    ///     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).\\n    function operate(\\n        address token_,\\n        int256 supplyAmount_,\\n        int256 borrowAmount_,\\n        address withdrawTo_,\\n        address borrowTo_,\\n        bytes calldata callbackData_\\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\\n\\n    /// @notice Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.\\n    ///         Only callable by auths or governance. Token transfers still come from msg.sender:\\n    ///         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().\\n    ///         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.\\n    ///         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused.\\n    /// @param onBehalf_ the address (protocol) whose position to operate on. Must be != address(0)\\n    ///                   and must have a configured position (via admin) for the given token.\\n    /// @param token_ address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)\\n    /// @param supplyAmount_ if +ve then supply, if 0 then nothing. Must be >= 0.\\n    /// @param borrowAmount_ if -ve then payback, if 0 then nothing. Must be <= 0.\\n    ///                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.\\n    /// @param callbackData_ must be empty (length 0). Custom callbackData-powered transfer shortcuts like\\n    ///                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.\\n    /// @return memVar3_ updated supplyExchangePrice\\n    /// @return memVar4_ updated borrowExchangePrice\\n    function operateOnBehalfOf(\\n        address onBehalf_,\\n        address token_,\\n        int256 supplyAmount_,\\n        int256 borrowAmount_,\\n        bytes calldata callbackData_\\n    ) external payable returns (uint256 memVar3_, uint256 memVar4_);\\n}\\n\\ninterface IFluidLiquidity is IProxy, IFluidLiquidityLogic {}\\n\",\"keccak256\":\"0x3e020c10d52a450c12b70a496d05d00bcd849b4646cae1757595d1d3be76ff14\",\"license\":\"MIT\"}},\"version\":1}","userdoc":{"kind":"user","notice":"Liquidity dummy implementation used for Fluid Liquidity infinite proxy.","methods":{"changeStatus(uint256)":{"notice":"changes current status, e.g. for pausing or unpausing all user operations. Only callable by Auths."},"pauseTokens(address[])":{"notice":"pause all operations for the given tokens by setting bit 255 of exchangePricesAndConfig. Only callable by Guardians."},"unpauseTokens(address[])":{"notice":"unpause operations for the given tokens by clearing bit 255 of exchangePricesAndConfig. Only callable by Guardians."},"collectRevenue(address[])":{"notice":"collects revenue for tokens to configured revenueCollector address."},"updateAuths((address,bool)[])":{"notice":"adds/removes auths. Auths generally could be contracts which can have restricted actions defined on contract.         auths can be helpful in reducing governance overhead where it's not needed."},"updateExchangePrices(address[])":{"notice":"gets the current updated exchange prices for n tokens and updates all prices, rates related data in storage."},"updateRevenueCollector(address)":{"notice":"changes the revenue collector address (contract that is sent revenue). Only callable by Governance."},"updateGuardians((address,bool)[])":{"notice":"adds/removes guardians. Only callable by Governance."},"pauseUser(address,address[],address[])":{"notice":"pause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians."},"updateUserClasses((address,uint256)[])":{"notice":"updates user classes: 0 is for new protocols, 1 is for established protocols.         Only callable by Auths."},"unpauseUser(address,address[],address[])":{"notice":"unpause operations for a particular user in class 0 (class 1 users can't be paused by guardians). Only callable by Guardians."},"updateUserWithdrawalLimit(address,address,uint256)":{"notice":"sets a new withdrawal limit as the current limit for a certain user. Resets decay limit to 0"},"operate(address,int256,int256,address,address,bytes)":{"notice":"Single function which handles supply, withdraw, borrow & payback"},"operateOnBehalfOf(address,address,int256,int256,bytes)":{"notice":"Same as `operate` but executes against `onBehalf_`'s position instead of msg.sender's.         Only callable by auths or governance. Token transfers still come from msg.sender:         native token uses msg.value, while ERC20 still pulls funds via msg.sender.liquidityCallback().         Only supply (+ve supplyAmount) and payback (-ve borrowAmount) are allowed; no withdrawals or borrows.         Bypasses user pause status: deposits and paybacks can be made even when the target user is paused."},"updateTokenConfigs((address,uint256,uint256,uint256)[])":{"notice":"updates token configs: fee charge on borrowers interest & storage update utilization threshold.         Only callable by Auths."},"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])":{"notice":"update tokens rate data version 1. Only callable by Auths."},"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])":{"notice":"sets user supply configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths.         Resets decay limit to 0."},"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])":{"notice":"update tokens rate data version 2. Only callable by Auths."},"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])":{"notice":"setting user borrow configs per token basis. Eg: with interest or interest-free and automated limits.         Only callable by Auths."}},"version":1},"devdoc":{"kind":"dev","details":"see https://github.com/Instadapp/infinite-proxy?tab=readme-ov-file#dummy-implementation","methods":{"changeStatus(uint256)":{"params":{"newStatus_":"new status        status = 2 -> pause, status = 1 -> resume."}},"pauseTokens(address[])":{"params":{"tokens_":"token addresses to pause"}},"unpauseTokens(address[])":{"params":{"tokens_":"token addresses to unpause"}},"collectRevenue(address[])":{"params":{"tokens_":"array of tokens to collect revenue for"},"details":"Note that this can revert if token balance is < revenueAmount (utilization > 100%)"},"updateAuths((address,bool)[])":{"params":{"authsStatus_":"array of structs setting allowed status for an address.                     status true => add auth, false => remove auth"}},"updateExchangePrices(address[])":{"params":{"tokens_":"tokens to update exchange prices for"},"returns":{"borrowExchangePrices_":"new borrow rates of overall system for each token","supplyExchangePrices_":"new supply rates of overall system for each token"}},"updateRevenueCollector(address)":{"params":{"revenueCollector_":"new revenue collector address"}},"updateGuardians((address,bool)[])":{"params":{"guardiansStatus_":"array of structs setting allowed status for an address.                         status true => add guardian, false => remove guardian"}},"pauseUser(address,address[],address[])":{"params":{"user_":"address of user to pause operations for","borrowTokens_":"token addresses to pause borrowings for","supplyTokens_":"token addresses to pause withdrawals for"}},"updateUserClasses((address,uint256)[])":{"params":{"userClasses_":"struct array of uint256 value to assign for each user address"}},"unpauseUser(address,address[],address[])":{"params":{"user_":"address of user to unpause operations for","borrowTokens_":"token addresses to unpause borrowings for","supplyTokens_":"token addresses to unpause withdrawals for"}},"updateUserWithdrawalLimit(address,address,uint256)":{"params":{"user_":"user address for which to update the withdrawal limit","token_":"token address for which to update the withdrawal limit","newLimit_":"new limit until which user supply can decrease to.                  Important: input in raw. Must account for exchange price in input param calculation.                  Note any limit that is < max expansion or > current user supply will set max expansion limit or                  current user supply as limit respectively.                  - set 0 to make maximum possible withdrawable: instant full expansion, and if that goes                  below base limit then fully down to 0.                  - set type(uint256).max to make current withdrawable 0 (sets current user supply as limit)."}},"operate(address,int256,int256,address,address,bytes)":{"params":{"token_":"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)","borrowTo_":"if borrow then to which address","withdrawTo_":"if withdrawal then to which address","borrowAmount_":"if +ve then borrow, if -ve then payback, if 0 then nothing","callbackData_":"callback data passed to `liquidityCallback` method of protocol","supplyAmount_":"if +ve then supply, if -ve then withdraw, if 0 then nothing"},"details":"to trigger skipping in / out transfers (gas optimization): -  ` callbackData_` MUST be encoded so that \"from\" address is the last 20 bytes in the last 32 bytes slot,     also for native token operations where liquidityCallback is not triggered!     from address must come at last position if there is more data. I.e. encode like:     abi.encode(otherVar1, otherVar2, FROM_ADDRESS). Note dynamic types used with abi.encode come at the end     so if dynamic types are needed, you must use abi.encodePacked to ensure the from address is at the end. -   this \"from\" address must match withdrawTo_ or borrowTo_ and must be == `msg.sender` -   `callbackData_` must in addition to the from address as described above include bytes32 SKIP_TRANSFERS     in the slot before (bytes 32 to 63) -   `msg.value` must be 0. -   Amounts must be either:     -  supply(+) == borrow(+), withdraw(-) == payback(-).     -  Liquidity must be on the winning side (deposit < borrow OR payback < withdraw).","returns":{"memVar3_":"updated supplyExchangePrice","memVar4_":"updated borrowExchangePrice"}},"operateOnBehalfOf(address,address,int256,int256,bytes)":{"params":{"token_":"address of token (0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for native)","onBehalf_":"the address (protocol) whose position to operate on. Must be != address(0)                   and must have a configured position (via admin) for the given token.","borrowAmount_":"if -ve then payback, if 0 then nothing. Must be <= 0.                      At least one of supplyAmount_ or borrowAmount_ must be non-zero.","callbackData_":"must be empty (length 0). Custom callbackData-powered transfer shortcuts like                      SKIP_TRANSFERS / NET_TRANSFERS are not supported for onBehalfOf.","supplyAmount_":"if +ve then supply, if 0 then nothing. Must be >= 0."},"returns":{"memVar3_":"updated supplyExchangePrice","memVar4_":"updated borrowExchangePrice"}},"updateTokenConfigs((address,uint256,uint256,uint256)[])":{"params":{"tokenConfigs_":"contains token address, fee & utilization threshold"}},"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])":{"params":{"tokensRateData_":"array of RateDataV1Params with rate data to set for each token"}},"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])":{"params":{"userSupplyConfigs_":"struct array containing user supply config, see `UserSupplyConfig` struct for more info"}},"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])":{"params":{"tokensRateData_":"array of RateDataV2Params with rate data to set for each token"}},"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])":{"params":{"userBorrowConfigs_":"struct array containing user borrow config, see `UserBorrowConfig` struct for more info"}}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"420:3066:2:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"420:3066:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1903:109;;;;;;;;;;-1:-1:-1;1903:109:2;;;;;:::i;:::-;;;;;1604;;;;;;;;;;-1:-1:-1;1604:109:2;;;;;:::i;524:88::-;;;;;;;;;;-1:-1:-1;524:88:2;;;;;:::i;:::-;;;;1019:102;;;;;;;;;;-1:-1:-1;1019:102:2;;;;;:::i;802:70::-;;;;;;;;;;-1:-1:-1;802:70:2;;;;;:::i;2488:62::-;;;;;;;;;;-1:-1:-1;2488:62:2;;;;;:::i;1317:96::-;;;;;;;;;;-1:-1:-1;1317:96:2;;;;;:::i;1760:::-;;;;;;;;;;-1:-1:-1;1760:96:2;;;;;:::i;:::-;;;;;1168:102;;;;;;;;;;-1:-1:-1;1168:102:2;;;;;:::i;2926:265::-;;;;;;:::i;:::-;3153:16;3171;2926:265;;;;;;;;;;;;;;;10567:25:4;;;10623:2;10608:18;;10601:34;;;;10540:18;2926:265:2;;;;;;;;3238:246;;;;;;:::i;:::-;3446:16;3464;3238:246;;;;;;;;;;2059:113;;;;;;;;;;-1:-1:-1;2059:113:2;;;;;:::i;:::-;;;;;;;919:53;;;;;;;;;;-1:-1:-1;919:53:2;;;;;:::i;2707:172::-;;;;;;;;;;-1:-1:-1;2707:172:2;;;;;:::i;:::-;-1:-1:-1;2797:38:2;;;;-1:-1:-1;2707:172:2;;;;;;;;;:::i;14:184:4:-;66:77;63:1;56:88;163:4;160:1;153:15;187:4;184:1;177:15;203:253;275:2;269:9;317:4;305:17;;352:18;337:34;;373:22;;;334:62;331:88;;;399:18;;:::i;:::-;435:2;428:22;203:253;:::o;461:::-;533:2;527:9;575:4;563:17;;610:18;595:34;;631:22;;;592:62;589:88;;;657:18;;:::i;719:334::-;790:2;784:9;846:2;836:13;;851:66;832:86;820:99;;949:18;934:34;;970:22;;;931:62;928:88;;;996:18;;:::i;:::-;1032:2;1025:22;719:334;;-1:-1:-1;719:334:4:o;1058:199::-;1134:4;1167:18;1159:6;1156:30;1153:56;;;1189:18;;:::i;:::-;-1:-1:-1;1234:1:4;1230:14;1246:4;1226:25;;1058:199::o;1262:196::-;1330:20;;1390:42;1379:54;;1369:65;;1359:93;;1448:1;1445;1438:12;1359:93;1262:196;;;:::o;1463:156::-;1529:20;;1589:4;1578:16;;1568:27;;1558:55;;1609:1;1606;1599:12;1624:1722;1741:6;1794:2;1782:9;1773:7;1769:23;1765:32;1762:52;;;1810:1;1807;1800:12;1762:52;1850:9;1837:23;1883:18;1875:6;1872:30;1869:50;;;1915:1;1912;1905:12;1869:50;1938:22;;1991:4;1983:13;;1979:27;-1:-1:-1;1969:55:4;;2020:1;2017;2010:12;1969:55;2060:2;2047:16;2083:80;2099:63;2155:6;2099:63;:::i;:::-;2083:80;:::i;:::-;2185:3;2209:6;2204:3;2197:19;2241:2;2236:3;2232:12;2225:19;;2299:2;2291:4;2283:6;2279:17;2275:2;2271:26;2267:35;2253:49;;2325:7;2317:6;2314:19;2311:39;;;2346:1;2343;2336:12;2311:39;2378:2;2374;2370:11;2359:22;;2390:926;2406:6;2401:3;2398:15;2390:926;;;2488:4;2482:3;2473:7;2469:17;2465:28;2462:48;;;2506:1;2503;2496:12;2462:48;2536:22;;:::i;:::-;2585:23;2604:3;2585:23;:::i;:::-;2578:5;2571:38;2645:32;2673:2;2668:3;2664:12;2645:32;:::i;:::-;2640:2;2633:5;2629:14;2622:56;2714:30;2740:2;2735:3;2731:12;2714:30;:::i;:::-;2709:2;2698:14;;2691:54;2820:2;2811:12;;;2798:26;2844:14;;;2837:31;2943:3;2934:13;;;2921:27;2968:15;;;2961:32;3068:3;3059:13;;;3046:27;3093:15;;;3086:32;3193:3;3184:13;;;3171:27;3218:15;;;3211:32;3256:18;;2432:4;2423:14;;;;3303:2;3294:12;;;;2390:926;;;3335:5;1624:1722;-1:-1:-1;;;;;;1624:1722:4:o;3351:1597::-;3468:6;3521:2;3509:9;3500:7;3496:23;3492:32;3489:52;;;3537:1;3534;3527:12;3489:52;3577:9;3564:23;3610:18;3602:6;3599:30;3596:50;;;3642:1;3639;3632:12;3596:50;3665:22;;3718:4;3710:13;;3706:27;-1:-1:-1;3696:55:4;;3747:1;3744;3737:12;3696:55;3787:2;3774:16;3810:80;3826:63;3882:6;3826:63;:::i;3810:80::-;3912:3;3936:6;3931:3;3924:19;3968:2;3963:3;3959:12;3952:19;;4026:2;4018:4;4010:6;4006:17;4002:2;3998:26;3994:35;3980:49;;4052:7;4044:6;4041:19;4038:39;;;4073:1;4070;4063:12;4038:39;4105:2;4101;4097:11;4086:22;;4117:801;4133:6;4128:3;4125:15;4117:801;;;4215:4;4209:3;4200:7;4196:17;4192:28;4189:48;;;4233:1;4230;4223:12;4189:48;4263:22;;:::i;:::-;4312:23;4331:3;4312:23;:::i;:::-;4305:5;4298:38;4372:32;4400:2;4395:3;4391:12;4372:32;:::i;:::-;4367:2;4360:5;4356:14;4349:56;4441:30;4467:2;4462:3;4458:12;4441:30;:::i;:::-;4436:2;4425:14;;4418:54;4547:2;4538:12;;;4525:26;4571:14;;;4564:31;4670:3;4661:13;;;4648:27;4695:15;;;4688:32;4795:3;4786:13;;;4773:27;4820:15;;;4813:32;4858:18;;4159:4;4150:14;;;;4905:2;4896:12;;;;4117:801;;4953:387;5036:8;5046:6;5100:3;5093:4;5085:6;5081:17;5077:27;5067:55;;5118:1;5115;5108:12;5067:55;-1:-1:-1;5141:20:4;;5184:18;5173:30;;5170:50;;;5216:1;5213;5206:12;5170:50;5253:4;5245:6;5241:17;5229:29;;5313:3;5306:4;5296:6;5293:1;5289:14;5281:6;5277:27;5273:38;5270:47;5267:67;;;5330:1;5327;5320:12;5267:67;4953:387;;;;;:::o;5345:486::-;5460:6;5468;5521:2;5509:9;5500:7;5496:23;5492:32;5489:52;;;5537:1;5534;5527:12;5489:52;5577:9;5564:23;5610:18;5602:6;5599:30;5596:50;;;5642:1;5639;5632:12;5596:50;5681:90;5763:7;5754:6;5743:9;5739:22;5681:90;:::i;:::-;5790:8;;5655:116;;-1:-1:-1;5345:486:4;-1:-1:-1;;;;5345:486:4:o;5836:647::-;5956:6;5964;6017:2;6005:9;5996:7;5992:23;5988:32;5985:52;;;6033:1;6030;6023:12;5985:52;6073:9;6060:23;6106:18;6098:6;6095:30;6092:50;;;6138:1;6135;6128:12;6092:50;6161:22;;6214:4;6206:13;;6202:27;-1:-1:-1;6192:55:4;;6243:1;6240;6233:12;6192:55;6283:2;6270:16;6309:18;6301:6;6298:30;6295:50;;;6341:1;6338;6331:12;6295:50;6397:7;6392:2;6384:4;6376:6;6372:17;6368:2;6364:26;6360:35;6357:48;6354:68;;;6418:1;6415;6408:12;6354:68;6449:2;6441:11;;;;;6471:6;;-1:-1:-1;5836:647:4;-1:-1:-1;;;5836:647:4:o;6488:186::-;6547:6;6600:2;6588:9;6579:7;6575:23;6571:32;6568:52;;;6616:1;6613;6606:12;6568:52;6639:29;6658:9;6639:29;:::i;:::-;6629:39;6488:186;-1:-1:-1;;;6488:186:4:o;6679:367::-;6742:8;6752:6;6806:3;6799:4;6791:6;6787:17;6783:27;6773:55;;6824:1;6821;6814:12;6773:55;-1:-1:-1;6847:20:4;;6890:18;6879:30;;6876:50;;;6922:1;6919;6912:12;6876:50;6959:4;6951:6;6947:17;6935:29;;7019:3;7012:4;7002:6;6999:1;6995:14;6987:6;6983:27;6979:38;6976:47;6973:67;;;7036:1;7033;7026:12;7051:437;7137:6;7145;7198:2;7186:9;7177:7;7173:23;7169:32;7166:52;;;7214:1;7211;7204:12;7166:52;7254:9;7241:23;7287:18;7279:6;7276:30;7273:50;;;7319:1;7316;7309:12;7273:50;7358:70;7420:7;7411:6;7400:9;7396:22;7358:70;:::i;7493:640::-;7609:6;7617;7670:2;7658:9;7649:7;7645:23;7641:32;7638:52;;;7686:1;7683;7676:12;7638:52;7726:9;7713:23;7759:18;7751:6;7748:30;7745:50;;;7791:1;7788;7781:12;7745:50;7814:22;;7867:4;7859:13;;7855:27;-1:-1:-1;7845:55:4;;7896:1;7893;7886:12;7845:55;7936:2;7923:16;7962:18;7954:6;7951:30;7948:50;;;7994:1;7991;7984:12;7948:50;8047:7;8042:2;8032:6;8029:1;8025:14;8021:2;8017:23;8013:32;8010:45;8007:65;;;8068:1;8065;8058:12;8138:374;8215:6;8223;8231;8284:2;8272:9;8263:7;8259:23;8255:32;8252:52;;;8300:1;8297;8290:12;8252:52;8323:29;8342:9;8323:29;:::i;:::-;8313:39;;8371:38;8405:2;8394:9;8390:18;8371:38;:::i;:::-;8138:374;;8361:48;;-1:-1:-1;;;8478:2:4;8463:18;;;;8450:32;;8138:374::o;8517:648::-;8638:6;8646;8699:2;8687:9;8678:7;8674:23;8670:32;8667:52;;;8715:1;8712;8705:12;8667:52;8755:9;8742:23;8788:18;8780:6;8777:30;8774:50;;;8820:1;8817;8810:12;8774:50;8843:22;;8896:4;8888:13;;8884:27;-1:-1:-1;8874:55:4;;8925:1;8922;8915:12;8874:55;8965:2;8952:16;8991:18;8983:6;8980:30;8977:50;;;9023:1;9020;9013:12;8977:50;9079:7;9074:2;9066:4;9058:6;9054:17;9050:2;9046:26;9042:35;9039:48;9036:68;;;9100:1;9097;9090:12;9170:347;9221:8;9231:6;9285:3;9278:4;9270:6;9266:17;9262:27;9252:55;;9303:1;9300;9293:12;9252:55;-1:-1:-1;9326:20:4;;9369:18;9358:30;;9355:50;;;9401:1;9398;9391:12;9355:50;9438:4;9430:6;9426:17;9414:29;;9490:3;9483:4;9474:6;9466;9462:19;9458:30;9455:39;9452:59;;;9507:1;9504;9497:12;9522:866;9635:6;9643;9651;9659;9667;9675;9683;9736:3;9724:9;9715:7;9711:23;9707:33;9704:53;;;9753:1;9750;9743:12;9704:53;9776:29;9795:9;9776:29;:::i;:::-;9766:39;-1:-1:-1;9874:2:4;9859:18;;9846:32;;-1:-1:-1;9975:2:4;9960:18;;9947:32;;-1:-1:-1;10024:38:4;10058:2;10043:18;;10024:38;:::i;:::-;10014:48;;10081:39;10115:3;10104:9;10100:19;10081:39;:::i;:::-;10071:49;;10171:3;10160:9;10156:19;10143:33;10199:18;10191:6;10188:30;10185:50;;;10231:1;10228;10221:12;10185:50;10270:58;10320:7;10311:6;10300:9;10296:22;10270:58;:::i;:::-;9522:866;;;;-1:-1:-1;9522:866:4;;-1:-1:-1;9522:866:4;;;;10244:84;;-1:-1:-1;;;9522:866:4:o;11140:791::-;11244:6;11252;11260;11268;11276;11284;11337:3;11325:9;11316:7;11312:23;11308:33;11305:53;;;11354:1;11351;11344:12;11305:53;11377:29;11396:9;11377:29;:::i;:::-;11367:39;;11425:38;11459:2;11448:9;11444:18;11425:38;:::i;:::-;11415:48;-1:-1:-1;11532:2:4;11517:18;;11504:32;;-1:-1:-1;11633:2:4;11618:18;;11605:32;;-1:-1:-1;11714:3:4;11699:19;;11686:33;11742:18;11731:30;;11728:50;;;11774:1;11771;11764:12;11728:50;11813:58;11863:7;11854:6;11843:9;11839:22;11813:58;:::i;:::-;11140:791;;;;-1:-1:-1;11140:791:4;;-1:-1:-1;11140:791:4;;11890:8;;11140:791;-1:-1:-1;;;11140:791:4:o;11936:842::-;12067:6;12075;12083;12091;12099;12152:2;12140:9;12131:7;12127:23;12123:32;12120:52;;;12168:1;12165;12158:12;12120:52;12191:29;12210:9;12191:29;:::i;:::-;12181:39;;12271:2;12260:9;12256:18;12243:32;12298:18;12290:6;12287:30;12284:50;;;12330:1;12327;12320:12;12284:50;12369:70;12431:7;12422:6;12411:9;12407:22;12369:70;:::i;:::-;12458:8;;-1:-1:-1;12343:96:4;-1:-1:-1;;12546:2:4;12531:18;;12518:32;12575:18;12562:32;;12559:52;;;12607:1;12604;12597:12;12559:52;12646:72;12710:7;12699:8;12688:9;12684:24;12646:72;:::i;:::-;11936:842;;;;-1:-1:-1;11936:842:4;;-1:-1:-1;12737:8:4;;12620:98;11936:842;-1:-1:-1;;;11936:842:4:o;12783:226::-;12842:6;12895:2;12883:9;12874:7;12870:23;12866:32;12863:52;;;12911:1;12908;12901:12;12863:52;-1:-1:-1;12956:23:4;;12783:226;-1:-1:-1;12783:226:4:o;13014:420::-;13067:3;13105:5;13099:12;13132:6;13127:3;13120:19;13164:4;13159:3;13155:14;13148:21;;13203:4;13196:5;13192:16;13226:1;13236:173;13250:6;13247:1;13244:13;13236:173;;;13311:13;;13299:26;;13354:4;13345:14;;;;13382:17;;;;13272:1;13265:9;13236:173;;;-1:-1:-1;13425:3:4;;13014:420;-1:-1:-1;;;;13014:420:4:o;13439:465::-;13696:2;13685:9;13678:21;13659:4;13722:56;13774:2;13763:9;13759:18;13751:6;13722:56;:::i;:::-;13826:9;13818:6;13814:22;13809:2;13798:9;13794:18;13787:50;13854:44;13891:6;13883;13854:44;:::i;:::-;13846:52;13439:465;-1:-1:-1;;;;;13439:465:4:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"changeStatus(uint256)","signatureHash4":"0xe8025d77","signatureHash32":"0xe8025d77b080f474b98f8a392ee7e3a75b33699dfe925da7bdf0e29fd60db7ab"},{"signature":"collectRevenue(address[])","signatureHash4":"0xac862bfa","signatureHash32":"0xac862bfa6932e294bb8cf4af05cc0105e58ab2439399be1c0c68d20fb18d60b2"},{"signature":"operate(address,int256,int256,address,address,bytes)","signatureHash4":"0xad967e15","signatureHash32":"0xad967e15cd45399080b91bb932830d55fcf4f25c47ed0ea131455a751cac2cca"},{"signature":"operateOnBehalfOf(address,address,int256,int256,bytes)","signatureHash4":"0xdacb5419","signatureHash32":"0xdacb5419b3a364d15c0a7f04c12b64c98b665a88e8f945fd69383fb36d00d2d2"},{"signature":"pauseTokens(address[])","signatureHash4":"0xc609684a","signatureHash32":"0xc609684a8330aa7148741d1fcaf779d23f26d459ff5c0f96454e52fb36adedff"},{"signature":"pauseUser(address,address[],address[])","signatureHash4":"0xdd4cbf6b","signatureHash32":"0xdd4cbf6be643b1378a8d4e63e4acbfb51a8981132f36e860727779a1c0200475"},{"signature":"unpauseTokens(address[])","signatureHash4":"0x7a4df6eb","signatureHash32":"0x7a4df6eb6bbec36ac6dec6b12ad75106873c126855a365ffdce484663343967f"},{"signature":"unpauseUser(address,address[],address[])","signatureHash4":"0xec048401","signatureHash32":"0xec048401eed63114f6f0e83525ee812b144eccc2c39251ddd413a797a11be610"},{"signature":"updateAuths((address,bool)[])","signatureHash4":"0x3f66feff","signatureHash32":"0x3f66feff8079d2a43a52e8d0702e50e733b9cea0f74ca9c2ab79a3080ecd432f"},{"signature":"updateExchangePrices(address[])","signatureHash4":"0xf4bfa000","signatureHash32":"0xf4bfa0003c0a84ff0656178538f5693274f8c689eaf8199be8182ee68a6ad55f"},{"signature":"updateGuardians((address,bool)[])","signatureHash4":"0xa5eb43ef","signatureHash32":"0xa5eb43ef82b41b23894482144578531bb40540219f00cc619847b48bab1f954e"},{"signature":"updateRateDataV1s((address,uint256,uint256,uint256,uint256)[])","signatureHash4":"0x3fad77fc","signatureHash32":"0x3fad77fcd40e5697ae5f28d1777c61b4876a6e6f9fb9b0d2a7d24f6f56ed1db2"},{"signature":"updateRateDataV2s((address,uint256,uint256,uint256,uint256,uint256,uint256)[])","signatureHash4":"0x9dde5977","signatureHash32":"0x9dde5977e1c514ed67fc1b01c2a0efcd9ac4855f4bf22370cc43263315491332"},{"signature":"updateRevenueCollector(address)","signatureHash4":"0x54bb0c1d","signatureHash32":"0x54bb0c1de7a26360060c805780ca9bccab6ecb1b8811939fb33390a6e3243022"},{"signature":"updateTokenConfigs((address,uint256,uint256,uint256)[])","signatureHash4":"0x7f7b6002","signatureHash32":"0x7f7b60023f05f20f2c2fb4ef6e58da9f8e34949415defa713efeba253b31a70e"},{"signature":"updateUserBorrowConfigs((address,address,uint8,uint256,uint256,uint256,uint256)[])","signatureHash4":"0x01b88f86","signatureHash32":"0x01b88f86271ddf83c1298bbf26a2f26891e7b165fc150f14fefc8aa98a9d89c7"},{"signature":"updateUserClasses((address,uint256)[])","signatureHash4":"0xc2da75f0","signatureHash32":"0xc2da75f0ea67294d3e91ce1b15600b6cd783399d6d1ed7f0c991a55da16e85b2"},{"signature":"updateUserSupplyConfigs((address,address,uint8,uint256,uint256,uint256)[])","signatureHash4":"0x02c6bb6a","signatureHash32":"0x02c6bb6a561d561d274b19699d636a51261be56a5a0ad150349530659f403852"},{"signature":"updateUserWithdrawalLimit(address,address,uint256)","signatureHash4":"0x8f0c2916","signatureHash32":"0x8f0c2916cfa25ef9d049509cfc0a3e52491ff3338fa0fc55553e11a3cd0c3040"}],"event":[],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0xCc331daf69752BEcE3DC98dBC63eAcd5092266A2"}