{"matchId":"56824078","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-10-24T06:28:29Z","creationBytecode":{"onchainBytecode":"0x6080604052348015600e575f80fd5b506110608061001c5f395ff3fe608060405260043610610041575f3560e01c8063027d9b321461004c57806309c5eabe1461008157806356db50bb146100ae5780636bedfe93146100cd575f80fd5b3661004857005b5f80fd5b348015610057575f80fd5b5061006b610066366004610958565b6100ec565b6040516100789190610968565b60405180910390f35b34801561008c575f80fd5b506100a061009b3660046109bb565b610115565b604051908152602001610078565b3480156100b9575f80fd5b5061006b6100c8366004610a27565b610156565b3480156100d8575f80fd5b5061006b6100e7366004610a37565b610169565b6060816040516020016100ff9190610aad565b6040516020818303038152906040529050919050565b5f606082900361013057610129838361017c565b9050610150565b60808290036101435761012983836101b1565b61014d8383610341565b90505b92915050565b6060816040516020016100ff9190610b0a565b6060816040516020016100ff9190610c02565b5f8061018a83850185610d7b565b6020810151815160408301519293506101a69233929190610607565b604001519392505050565b5f806101bf83850185610de1565b60208101519091505f9073ffffffffffffffffffffffffffffffffffffffff16156101ee5781602001516101f0565b325b905073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee73ffffffffffffffffffffffffffffffffffffffff16825f015173ffffffffffffffffffffffffffffffffffffffff16036102a157604082015161024c9033906107b2565b5f61026f835f015173ffffffffffffffffffffffffffffffffffffffff166107cf565b905080156102975761029773ffffffffffffffffffffffffffffffffffffffff8316826107b2565b9250610150915050565b604082015182516102cc9173ffffffffffffffffffffffffffffffffffffffff909116903390610840565b5f6102ef835f015173ffffffffffffffffffffffffffffffffffffffff166107cf565b90505f60018211610300575f61030b565b61030b600183610e55565b905080156103365783516103369073ffffffffffffffffffffffffffffffffffffffff168483610840565b935061015092505050565b5f8061034f83850185610f34565b90508060c00151156103af576103af8161010001517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff836020015173ffffffffffffffffffffffffffffffffffffffff166108939092919063ffffffff16565b80515f906103bd575f6103e0565b6103e0826040015173ffffffffffffffffffffffffffffffffffffffff166107cf565b90505f82610100015173ffffffffffffffffffffffffffffffffffffffff168360e001518461012001516040516104179190611026565b5f6040518083038185875af1925050503d805f8114610451576040519150601f19603f3d011682016040523d82523d5f602084013e610456565b606091505b5050905080610491576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8251156105bc575f6104ce6104bf856020015173ffffffffffffffffffffffffffffffffffffffff166107cf565b85606001518660800151610925565b60a085015160208601519192506104e89133919084610607565b5f61050c856040015173ffffffffffffffffffffffffffffffffffffffff166107cf565b90505f84821161051c575f610526565b6105268583610e55565b905080156105ae5773eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee73ffffffffffffffffffffffffffffffffffffffff16866040015173ffffffffffffffffffffffffffffffffffffffff16036105885761058333826107b2565b6105ae565b60408601516105ae9073ffffffffffffffffffffffffffffffffffffffff163383610840565b829650505050505050610150565b5f6105e36104bf856040015173ffffffffffffffffffffffffffffffffffffffff166107cf565b60a085015160408601519192506105fd9133919084610607565b9695505050505050565b73ffffffffffffffffffffffffffffffffffffffff831615610629578261062b565b325b92507fffffffffffffffffffffffff111111111111111111111111111111111111111273ffffffffffffffffffffffffffffffffffffffff8316016106bd5780156106905761069073ffffffffffffffffffffffffffffffffffffffff8416826107b2565b4780156106b7576106b773ffffffffffffffffffffffffffffffffffffffff8616826107b2565b506107ac565b80156106e4576106e473ffffffffffffffffffffffffffffffffffffffff83168483610840565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201525f9073ffffffffffffffffffffffffffffffffffffffff8416906370a0823190602401602060405180830381865afa15801561074e573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610772919061103c565b905060018111156107aa576107aa8561078c600184610e55565b73ffffffffffffffffffffffffffffffffffffffff86169190610840565b505b50505050565b5f385f3884865af16107cb5763b12d13eb5f526004601cfd5b5050565b5f73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee821460018114610836576040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152602081602483875afa801561082f57815193505b505061083a565b4791505b50919050565b81601452806034526fa9059cbb0000000000000000000000005f5260205f604460105f875af18060015f51141661088957803d853b151710610889576390b8ec185f526004601cfd5b505f603452505050565b81601452806034526f095ea7b30000000000000000000000005f5260205f604460105f875af18060015f51141661088957803d853b151710610889575f6034526f095ea7b30000000000000000000000005f525f38604460105f885af1508160345260205f604460105f885af190508060015f51141661088957803d853b15171061088957633e3f8f735f526004601cfd5b5f80838511610934575f61093e565b61093e8486610e55565b905082811061094d578261094f565b805b95945050505050565b5f6080828403121561083a575f80fd5b602081525f82518060208401528060208501604085015e5f6040828501015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011684010191505092915050565b5f80602083850312156109cc575f80fd5b823567ffffffffffffffff808211156109e3575f80fd5b818501915085601f8301126109f6575f80fd5b813581811115610a04575f80fd5b866020828501011115610a15575f80fd5b60209290920196919550909350505050565b5f6060828403121561083a575f80fd5b5f60208284031215610a47575f80fd5b813567ffffffffffffffff811115610a5d575f80fd5b82016101408185031215610a6f575f80fd5b9392505050565b803573ffffffffffffffffffffffffffffffffffffffff81168114610a99575f80fd5b919050565b80358015158114610a99575f80fd5b6080810173ffffffffffffffffffffffffffffffffffffffff80610ad085610a76565b16835280610ae060208601610a76565b1660208401525060408301356040830152610afd60608401610a9e565b1515606083015292915050565b6060810173ffffffffffffffffffffffffffffffffffffffff80610b2d85610a76565b16835280610b3d60208601610a76565b166020840152506040830135604083015292915050565b5f8083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1843603018112610b87575f80fd5b830160208101925035905067ffffffffffffffff811115610ba6575f80fd5b803603821315610bb4575f80fd5b9250929050565b81835281816020850137505f602082840101525f60207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116840101905092915050565b60208152610c1c60208201610c1684610a9e565b15159052565b5f610c2960208401610a76565b73ffffffffffffffffffffffffffffffffffffffff8116604084015250610c5260408401610a76565b73ffffffffffffffffffffffffffffffffffffffff811660608401525060608301356080830152608083013560a0830152610c8f60a08401610a76565b73ffffffffffffffffffffffffffffffffffffffff811660c084015250610cb860c08401610a9e565b80151560e08401525061010060e084013581840152610cd8818501610a76565b9050610120610cfe8185018373ffffffffffffffffffffffffffffffffffffffff169052565b610d0a81860186610b54565b610140868101529250905061094f61016085018383610bbb565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b604051610140810167ffffffffffffffff81118282101715610d7557610d75610d24565b60405290565b5f60608284031215610d8b575f80fd5b6040516060810181811067ffffffffffffffff82111715610dae57610dae610d24565b604052610dba83610a76565b8152610dc860208401610a76565b6020820152604083013560408201528091505092915050565b5f60808284031215610df1575f80fd5b6040516080810181811067ffffffffffffffff82111715610e1457610e14610d24565b604052610e2083610a76565b8152610e2e60208401610a76565b602082015260408301356040820152610e4960608401610a9e565b60608201529392505050565b81810381811115610150577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f82601f830112610e9c575f80fd5b813567ffffffffffffffff80821115610eb757610eb7610d24565b604051601f83017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f01168101908282118183101715610efd57610efd610d24565b81604052838152866020858801011115610f15575f80fd5b836020870160208301375f602085830101528094505050505092915050565b5f60208284031215610f44575f80fd5b813567ffffffffffffffff80821115610f5b575f80fd5b908301906101408286031215610f6f575f80fd5b610f77610d51565b610f8083610a9e565b8152610f8e60208401610a76565b6020820152610f9f60408401610a76565b60408201526060830135606082015260808301356080820152610fc460a08401610a76565b60a0820152610fd560c08401610a9e565b60c082015260e083013560e0820152610100610ff2818501610a76565b908201526101208381013583811115611009575f80fd5b61101588828701610e8d565b918301919091525095945050505050565b5f82518060208501845e5f920191825250919050565b5f6020828403121561104c575f80fd5b505191905056fea164736f6c6343000819000a","recompiledBytecode":"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","sourceMap":"771:8503:2:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c6343000819000a","offset":4208}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"771:8503:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8782:143;;;;;;;;;;-1:-1:-1;8782:143:2;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4353:338;;;;;;;;;;-1:-1:-1;4353:338:2;;;;;:::i;:::-;;:::i;:::-;;;1444:25:5;;;1432:2;1417:18;4353:338:2;1298:177:5;8643:133:2;;;;;;;;;;-1:-1:-1;8643:133:2;;;;;:::i;:::-;;:::i;8931:125::-;;;;;;;;;;-1:-1:-1;8931:125:2;;;;;:::i;:::-;;:::i;8782:143::-;8871:12;8913:4;8902:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;8895:23;;8782:143;;;:::o;4353:338::-;4417:7;4463:4;4440:27;;;4436:95;;4490:30;4507:12;;4490:16;:30::i;:::-;4483:37;;;;4436:95;4568:4;4545:27;;;4541:100;;4595:35;4617:12;;4595:21;:35::i;4541:100::-;4658:26;4671:12;;4658;:26::i;:::-;4651:33;;4353:338;;;;;:::o;8643:133::-;8722:12;8764:4;8753:16;;;;;;;;:::i;8931:125::-;9002:12;9044:4;9033:16;;;;;;;;:::i;4697:285::-;4770:7;;4816:40;;;;4827:12;4816:40;:::i;:::-;4897:17;;;;4916:10;;4928:14;;;;4789:67;;-1:-1:-1;4867:76:2;;:10;;4897:17;4916:10;4867:29;:76::i;:::-;4961:14;;;;4697:285;-1:-1:-1;;;4697:285:2:o;4988:965::-;5066:7;;5117:45;;;;5128:12;5117:45;:::i;:::-;5196:17;;;;5085:77;;-1:-1:-1;5173:20:2;;5196:31;;;:63;;5242:4;:17;;;5196:63;;;5230:9;5196:63;5173:86;;815:42:3;5274:37:2;;:4;:10;;;:37;;;5270:677;;5354:17;;;;5327:45;;:10;;:26;:45::i;:::-;5386:17;5406:23;:4;:10;;;:21;;;:23::i;:::-;5386:43;-1:-1:-1;5447:13:2;;5443:91;;5480:39;:28;;;5509:9;5480:28;:39::i;:::-;5554:9;-1:-1:-1;5547:16:2;;-1:-1:-1;;5547:16:2;5270:677;5630:17;;;;5594:10;;:54;;:23;;;;;5618:10;;5594:23;:54::i;:::-;5662:24;5689:23;:4;:10;;;:21;;;:23::i;:::-;5662:50;;5726:17;5765:1;5746:16;:20;:47;;5792:1;5746:47;;;5769:20;5788:1;5769:16;:20;:::i;:::-;5726:67;-1:-1:-1;5811:13:2;;5807:100;;5844:10;;:48;;:23;;5868:12;5882:9;5844:23;:48::i;:::-;5927:9;-1:-1:-1;5920:16:2;;-1:-1:-1;;;5920:16:2;5959:2161;6028:7;;6070:36;;;;6081:12;6070:36;:::i;:::-;6047:59;;6121:4;:18;;;6117:115;;;6155:66;6190:4;:11;;;6203:17;6155:4;:13;;;:34;;;;:66;;;;;:::i;:::-;6582:10;;6554:25;;6582:44;;6625:1;6582:44;;;6595:27;:4;:14;;;:25;;;:27::i;:::-;6554:72;;6638:12;6655:4;:11;;;:16;;6680:4;:10;;;6693:4;:19;;;6655:58;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6637:76;;;6728:7;6723:63;;6758:17;;;;;;;;;;;;;;6723:63;6800:10;;6796:994;;;6999:20;7022:76;7033:26;:4;:13;;;:24;;;:26::i;:::-;7061:4;:17;;;7080:4;:17;;;7022:10;:76::i;:::-;7142:17;;;;7161:13;;;;6999:99;;-1:-1:-1;7112:77:2;;:10;;7142:17;6999:99;7112:29;:77::i;:::-;7310:14;7327:27;:4;:14;;;:25;;;:27::i;:::-;7310:44;;7368:20;7400:17;7391:6;:26;:59;;7449:1;7391:59;;;7420:26;7429:17;7420:6;:26;:::i;:::-;7368:82;-1:-1:-1;7468:16:2;;7464:282;;815:42:3;7508:41:2;;:4;:14;;;:41;;;7504:228;;7573:40;:10;7600:12;7573:26;:40::i;:::-;7504:228;;;7660:14;;;;:53;;:27;;7688:10;7700:12;7660:27;:53::i;:::-;7767:12;7760:19;;;;;;;;;;6796:994;7904:17;7924:77;7935:27;:4;:14;;;:25;;;:27::i;7924:77::-;8041:17;;;;8060:14;;;;7904:97;;-1:-1:-1;8011:75:2;;:10;;8041:17;7904:97;8011:29;:75::i;:::-;8104:9;5959:2161;-1:-1:-1;;;;;;5959:2161:2:o;1388:1447:3:-;1592:26;;;;:53;;1633:12;1592:53;;;1621:9;1592:53;1577:68;-1:-1:-1;1854:23:3;;;;;1850:979;;1897:13;;1893:155;;1994:39;:28;;;2023:9;1994:28;:39::i;:::-;2156:21;2195;;2191:103;;2236:43;:25;;;2262:16;2236:25;:43::i;:::-;1879:425;1850:979;;;2328:13;;2324:186;;2449:46;:21;;;2471:12;2485:9;2449:21;:46::i;:::-;2651:41;;;;;2686:4;2651:41;;;10479:74:5;2624:24:3;;2651:26;;;;;;10452:18:5;;2651:41:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2624:68;;2729:1;2710:16;:20;2706:113;;;2750:54;2772:9;2783:20;2802:1;2783:16;:20;:::i;:::-;2750:21;;;;:54;:21;:54::i;:::-;2310:519;1850:979;1388:1447;;;;:::o;3909:342:1:-;4111:4;4099:10;4093:4;4081:10;4073:6;4069:2;4062:5;4057:59;4047:188;;4149:10;4143:4;4136:24;4216:4;4210;4203:18;4047:188;3909:342;;:::o;13042:757:4:-;13100:17;13225:11;13218:5;13215:22;13274:4;13269:40;;;;13384:4;13378:11;13447:66;13444:1;13437:77;13574:9;13567:4;13564:1;13560:12;13553:31;13674:4;13671:1;13665:4;13662:1;13655:5;13648;13637:42;13717:7;13714:35;;;13746:1;13740:8;13727:21;;13714:35;;;13208:575;;13269:40;13294:13;13281:26;;13208:575;;13042:757;;;:::o;13125:887:1:-;13288:2;13282:4;13275:16;13345:6;13339:4;13332:20;13410:34;13404:4;13397:48;13606:4;13600;13594;13588;13585:1;13578:5;13571;13566:45;13658:7;13654:1;13647:4;13641:11;13638:18;13634:32;13624:275;;13749:7;13730:16;13721:5;13709:18;13702:26;13699:48;13696:61;13686:199;;13794:10;13788:4;13781:24;13862:4;13856;13849:18;13686:199;13624:275;13925:1;13919:4;13912:15;13125:887;;;:::o;16951:1707::-;17122:2;17116:4;17109:16;17179:6;17173:4;17166:20;17244:34;17238:4;17231:48;17438:4;17432;17426;17420;17417:1;17410:5;17403;17398:45;17490:7;17486:1;17479:4;17473:11;17470:18;17466:32;17456:1089;;17581:7;17562:16;17553:5;17541:18;17534:26;17531:48;17528:61;17518:1013;;17626:1;17620:4;17613:15;17691:34;17685:4;17678:48;17828:4;17816:10;17810:4;17804;17801:1;17794:5;17787;17782:51;17778:56;17891:6;17885:4;17878:20;18074:4;18068;18062;18056;18053:1;18046:5;18039;18034:45;18023:56;;18134:7;18130:1;18123:4;18117:11;18114:18;18110:32;18100:413;;18332:7;18313:16;18304:5;18292:18;18285:26;18282:48;18279:61;18269:222;;18385:10;18379:4;18372:24;18460:4;18454;18447:18;8195:260:2;8298:7;8317:15;8344:12;8335:6;:21;:49;;8383:1;8335:49;;;8359:21;8368:12;8359:6;:21;:::i;:::-;8317:67;;8411:12;8401:7;:22;:47;;8436:12;8401:47;;;8426:7;8401:47;8394:54;8195:260;-1:-1:-1;;;;;8195:260:2:o;14:203:5:-;109:6;162:3;150:9;141:7;137:23;133:33;130:53;;;179:1;176;169:12;222:475;369:2;358:9;351:21;332:4;401:6;395:13;444:6;439:2;428:9;424:18;417:34;503:6;498:2;490:6;486:15;481:2;470:9;466:18;460:50;559:1;554:2;545:6;534:9;530:22;526:31;519:42;688:2;618:66;613:2;605:6;601:15;597:88;586:9;582:104;578:113;570:121;;;222:475;;;;:::o;702:591::-;772:6;780;833:2;821:9;812:7;808:23;804:32;801:52;;;849:1;846;839:12;801:52;889:9;876:23;918:18;959:2;951:6;948:14;945:34;;;975:1;972;965:12;945:34;1013:6;1002:9;998:22;988:32;;1058:7;1051:4;1047:2;1043:13;1039:27;1029:55;;1080:1;1077;1070:12;1029:55;1120:2;1107:16;1146:2;1138:6;1135:14;1132:34;;;1162:1;1159;1152:12;1132:34;1207:7;1202:2;1193:6;1189:2;1185:15;1181:24;1178:37;1175:57;;;1228:1;1225;1218:12;1175:57;1259:2;1251:11;;;;;1281:6;;-1:-1:-1;702:591:5;;-1:-1:-1;;;;702:591:5:o;1480:197::-;1570:6;1623:2;1611:9;1602:7;1598:23;1594:32;1591:52;;;1639:1;1636;1629:12;1682:387;1768:6;1821:2;1809:9;1800:7;1796:23;1792:32;1789:52;;;1837:1;1834;1827:12;1789:52;1877:9;1864:23;1910:18;1902:6;1899:30;1896:50;;;1942:1;1939;1932:12;1896:50;1965:22;;2021:3;2003:16;;;1999:26;1996:46;;;2038:1;2035;2028:12;1996:46;2061:2;1682:387;-1:-1:-1;;;1682:387:5:o;2074:196::-;2142:20;;2202:42;2191:54;;2181:65;;2171:93;;2260:1;2257;2250:12;2171:93;2074:196;;;:::o;2407:160::-;2472:20;;2528:13;;2521:21;2511:32;;2501:60;;2557:1;2554;2547:12;2668:582;2872:3;2857:19;;2895:42;;2968:26;2987:6;2968:26;:::i;:::-;2964:35;2953:9;2946:54;3081:2;3042:37;3073:4;3065:6;3061:17;3042:37;:::i;:::-;3038:46;3031:4;3020:9;3016:20;3009:76;;3148:4;3140:6;3136:17;3123:31;3116:4;3105:9;3101:20;3094:61;3207:34;3235:4;3227:6;3223:17;3207:34;:::i;:::-;3200:42;3193:50;3186:4;3175:9;3171:20;3164:80;2668:582;;;;:::o;3255:482::-;3449:2;3434:18;;3471:42;;3544:26;3563:6;3544:26;:::i;:::-;3540:35;3529:9;3522:54;3657:2;3618:37;3649:4;3641:6;3637:17;3618:37;:::i;:::-;3614:46;3607:4;3596:9;3592:20;3585:76;;3724:4;3716:6;3712:17;3699:31;3692:4;3681:9;3677:20;3670:61;3255:482;;;;:::o;3742:559::-;3800:5;3807:6;3867:3;3854:17;3949:66;3938:8;3922:14;3918:29;3914:102;3894:18;3890:127;3880:155;;4031:1;4028;4021:12;3880:155;4059:33;;4163:4;4150:18;;;-1:-1:-1;4111:21:5;;-1:-1:-1;4191:18:5;4180:30;;4177:50;;;4223:1;4220;4213:12;4177:50;4270:6;4254:14;4250:27;4243:5;4239:39;4236:59;;;4291:1;4288;4281:12;4236:59;3742:559;;;;;:::o;4306:325::-;4394:6;4389:3;4382:19;4446:6;4439:5;4432:4;4427:3;4423:14;4410:43;;4498:1;4491:4;4482:6;4477:3;4473:16;4469:27;4462:38;4364:3;4620:4;4550:66;4545:2;4537:6;4533:15;4529:88;4524:3;4520:98;4516:109;4509:116;;4306:325;;;;:::o;4636:1401::-;4817:2;4806:9;4799:21;4829:60;4885:2;4874:9;4870:18;4845:23;4861:6;4845:23;:::i;:::-;2642:13;2635:21;2623:34;;2572:91;4829:60;4780:4;4918:35;4949:2;4941:6;4937:15;4918:35;:::i;:::-;2352:42;2341:54;;5010:2;4995:18;;2329:67;4962:52;5045:35;5076:2;5068:6;5064:15;5045:35;:::i;:::-;2352:42;2341:54;;5139:2;5124:18;;2329:67;5089:54;5205:2;5197:6;5193:15;5180:29;5174:3;5163:9;5159:19;5152:58;5272:3;5264:6;5260:16;5247:30;5241:3;5230:9;5226:19;5219:59;5309:36;5340:3;5332:6;5328:16;5309:36;:::i;:::-;2352:42;2341:54;;5404:3;5389:19;;2329:67;5354:55;5440:33;5468:3;5460:6;5456:16;5440:33;:::i;:::-;2642:13;;2635:21;5529:3;5514:19;;2623:34;5482:52;5553:3;5617;5609:6;5605:16;5592:30;5587:2;5576:9;5572:18;5565:58;5654:35;5685:2;5677:6;5673:15;5654:35;:::i;:::-;5632:57;;5708:3;5720:54;5770:2;5759:9;5755:18;5739:14;2352:42;2341:54;2329:67;;2275:127;5720:54;5819:55;5870:2;5862:6;5858:15;5850:6;5819:55;:::i;:::-;5893:6;5915:18;;;5908:30;5783:91;-1:-1:-1;5783:91:5;-1:-1:-1;5955:76:5;6026:3;6011:19;;5783:91;;5955:76;:::i;6042:184::-;6094:77;6091:1;6084:88;6191:4;6188:1;6181:15;6215:4;6212:1;6205:15;6231:250;6298:2;6292:9;6340:6;6328:19;;6377:18;6362:34;;6398:22;;;6359:62;6356:88;;;6424:18;;:::i;:::-;6460:2;6453:22;6231:250;:::o;6486:586::-;6574:6;6627:2;6615:9;6606:7;6602:23;6598:32;6595:52;;;6643:1;6640;6633:12;6595:52;6676:2;6670:9;6718:2;6710:6;6706:15;6787:6;6775:10;6772:22;6751:18;6739:10;6736:34;6733:62;6730:88;;;6798:18;;:::i;:::-;6834:2;6827:22;6873:29;6892:9;6873:29;:::i;:::-;6865:6;6858:45;6936:38;6970:2;6959:9;6955:18;6936:38;:::i;:::-;6931:2;6923:6;6919:15;6912:63;7036:2;7025:9;7021:18;7008:32;7003:2;6995:6;6991:15;6984:57;7060:6;7050:16;;;6486:586;;;;:::o;7077:662::-;7170:6;7223:3;7211:9;7202:7;7198:23;7194:33;7191:53;;;7240:1;7237;7230:12;7191:53;7273:2;7267:9;7315:3;7307:6;7303:16;7385:6;7373:10;7370:22;7349:18;7337:10;7334:34;7331:62;7328:88;;;7396:18;;:::i;:::-;7432:2;7425:22;7471:29;7490:9;7471:29;:::i;:::-;7463:6;7456:45;7534:38;7568:2;7557:9;7553:18;7534:38;:::i;:::-;7529:2;7521:6;7517:15;7510:63;7634:2;7623:9;7619:18;7606:32;7601:2;7593:6;7589:15;7582:57;7672:35;7703:2;7692:9;7688:18;7672:35;:::i;:::-;7667:2;7655:15;;7648:60;7659:6;7077:662;-1:-1:-1;;;7077:662:5:o;7744:282::-;7811:9;;;7832:11;;;7829:191;;;7876:77;7873:1;7866:88;7977:4;7974:1;7967:15;8005:4;8002:1;7995:15;8031:777;8073:5;8126:3;8119:4;8111:6;8107:17;8103:27;8093:55;;8144:1;8141;8134:12;8093:55;8180:6;8167:20;8206:18;8243:2;8239;8236:10;8233:36;;;8249:18;;:::i;:::-;8383:2;8377:9;8445:4;8437:13;;8288:66;8433:22;;;8457:2;8429:31;8425:40;8413:53;;;8481:18;;;8501:22;;;8478:46;8475:72;;;8527:18;;:::i;:::-;8567:10;8563:2;8556:22;8602:2;8594:6;8587:18;8648:3;8641:4;8636:2;8628:6;8624:15;8620:26;8617:35;8614:55;;;8665:1;8662;8655:12;8614:55;8729:2;8722:4;8714:6;8710:17;8703:4;8695:6;8691:17;8678:54;8776:1;8769:4;8764:2;8756:6;8752:15;8748:26;8741:37;8796:6;8787:15;;;;;;8031:777;;;;:::o;8813:1209::-;8897:6;8950:2;8938:9;8929:7;8925:23;8921:32;8918:52;;;8966:1;8963;8956:12;8918:52;9006:9;8993:23;9035:18;9076:2;9068:6;9065:14;9062:34;;;9092:1;9089;9082:12;9062:34;9115:22;;;;9171:6;9153:16;;;9149:29;9146:49;;;9191:1;9188;9181:12;9146:49;9217:17;;:::i;:::-;9257:19;9273:2;9257:19;:::i;:::-;9250:5;9243:34;9309:31;9336:2;9332;9328:11;9309:31;:::i;:::-;9304:2;9297:5;9293:14;9286:55;9373:31;9400:2;9396;9392:11;9373:31;:::i;:::-;9368:2;9361:5;9357:14;9350:55;9458:2;9454;9450:11;9437:25;9432:2;9425:5;9421:14;9414:49;9517:3;9513:2;9509:12;9496:26;9490:3;9483:5;9479:15;9472:51;9556:32;9583:3;9579:2;9575:12;9556:32;:::i;:::-;9550:3;9543:5;9539:15;9532:57;9622:29;9646:3;9642:2;9638:12;9622:29;:::i;:::-;9616:3;9609:5;9605:15;9598:54;9706:3;9702:2;9698:12;9685:26;9679:3;9672:5;9668:15;9661:51;9731:3;9766:31;9793:2;9789;9785:11;9766:31;:::i;:::-;9750:14;;;9743:55;9817:3;9858:11;;;9845:25;9882:16;;;9879:36;;;9911:1;9908;9901:12;9879:36;9947:44;9983:7;9972:8;9968:2;9964:17;9947:44;:::i;:::-;9931:14;;;9924:68;;;;-1:-1:-1;9935:5:5;8813:1209;-1:-1:-1;;;;;8813:1209:5:o;10027:301::-;10156:3;10194:6;10188:13;10240:6;10233:4;10225:6;10221:17;10216:3;10210:37;10302:1;10266:16;;10291:13;;;-1:-1:-1;10266:16:5;10027:301;-1:-1:-1;10027:301:5:o;10564:184::-;10634:6;10687:2;10675:9;10666:7;10662:23;10658:32;10655:52;;;10703:1;10700;10693:12;10655:52;-1:-1:-1;10726:16:5;;10564:184;-1:-1:-1;10564:184:5:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c6343000819000a","offset":4180}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x366bb1c1acf1ead03475914b2996372a7b7a6f0ada0c4dd83a6f50a029ca0d1f","blockNumber":"26198627","transactionIndex":"138","deployer":"0xdDd1984988735A53980f3c4e9011528d4dc4194A"},"sources":{"src/executors/example/GenericSwapExecutor.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Libraries\nimport { ExecutorLib } from \"@executors/libraries/ExecutorLib.sol\";\nimport { ERC20UtilsLib } from \"@modules/libraries/ERC20UtilsLib.sol\";\nimport { SafeTransferLib } from \"@solady/utils/SafeTransferLib.sol\";\n\n/// @title Generic Swap Executor\n/// @notice Variant of LaitaExecutor that calls an arbitrary caller-specified target instead of a fixed Augustus\n///         address. Intended for the winning-bid submission flow where the solver selects both the target and\n///         the calldata.\n/// @dev Return data from the target is not decoded; receivedAmount / spentAmount are inferred from the\n///      executor's post-call balances. Any dust left on this contract is accepted as a gas optimisation.\ncontract GenericSwapExecutor {\n    /*//////////////////////////////////////////////////////////////\n                                STRUCTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Executor data struct for a plain fee+output transfer (no target call).\n    /// @param token The address of the token to transfer.\n    /// @param feeRecipient The address to receive the fee.\n    /// @param feeAmount The amount of fee to be paid.\n    struct TransferData {\n        address token;\n        address feeRecipient;\n        uint256 feeAmount;\n    }\n\n    /// @notice Executor data struct for an exact-output transfer.\n    /// @param token The token to transfer.\n    /// @param feeRecipient The address to receive the residual fee.\n    /// @param outputAmount The exact amount of tokens to send to the caller.\n    /// @param isExactTransfer Discriminator, always true (shapes the encoded length).\n    struct ExactTransferData {\n        address token;\n        address feeRecipient;\n        uint256 outputAmount;\n        bool isExactTransfer;\n    }\n\n    /// @notice Executor data struct for a target-call swap.\n    /// @param isBuy Whether the swap is a BUY order.\n    /// @param srcToken Source token; approved to `target` when `shouldApprove` is true.\n    /// @param destToken Destination token (or ETH sentinel).\n    /// @param quotedAmount For sell: the baseline destToken output; surplus above it is fee-eligible. For buy:\n    ///                     the baseline srcToken refund returned to msg.sender; srcLeftover above it is\n    ///                     fee-eligible.\n    /// @param maxFeeAmount Cap on the fee. Fee-eligible surplus above the cap goes to msg.sender, so price\n    ///                     improvement over the quote reaches Delta instead of the fee recipient. Set to\n    ///                     type(uint256).max to take the whole surplus as fee.\n    /// @param feeRecipient Address receiving the fee (tx.origin when zero).\n    /// @param shouldApprove Whether to approve srcToken to target.\n    /// @param value Native ETH value to forward to the target.\n    /// @param target Arbitrary contract to call.\n    /// @param targetCalldata Calldata to execute on target.\n    struct SwapData {\n        bool isBuy;\n        address srcToken;\n        address destToken;\n        uint256 quotedAmount;\n        uint256 maxFeeAmount;\n        address feeRecipient;\n        bool shouldApprove;\n        uint256 value;\n        address target;\n        bytes targetCalldata;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Raised when the target call reverts.\n    error ExecutionFailed();\n\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using ExecutorLib for address;\n    using ERC20UtilsLib for address;\n    using SafeTransferLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                                EXECUTE\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Entrypoint dispatched by settlement / probe modules.\n    /// @dev Dispatch is by encoded length: 0x60 → Transfer, 0x80 → ExactTransfer, else → Swap.\n    /// @param executorData Encoded struct: `TransferData`, `ExactTransferData`, or `SwapData`.\n    /// @return feeAmount The fee collected on this execution.\n    function execute(bytes calldata executorData) external returns (uint256) {\n        if (executorData.length == 0x60) {\n            return _executeTransfer(executorData);\n        }\n\n        if (executorData.length == 0x80) {\n            return _executeExactTransfer(executorData);\n        }\n\n        return _executeSwap(executorData);\n    }\n\n    function _executeTransfer(bytes calldata executorData) internal returns (uint256) {\n        TransferData memory data = abi.decode(executorData, (TransferData));\n\n        msg.sender.transferFeesAndETH(data.feeRecipient, data.token, data.feeAmount);\n\n        return data.feeAmount;\n    }\n\n    function _executeExactTransfer(bytes calldata executorData) internal returns (uint256) {\n        ExactTransferData memory data = abi.decode(executorData, (ExactTransferData));\n\n        address feeRecipient = data.feeRecipient == address(0) ? tx.origin : data.feeRecipient;\n\n        if (data.token == ExecutorLib.ETH_ADDRESS) {\n            msg.sender.safeTransferETH(data.outputAmount);\n            uint256 feeAmount = data.token.getBalance();\n            if (feeAmount > 0) {\n                feeRecipient.safeTransferETH(feeAmount);\n            }\n            return feeAmount;\n        } else {\n            data.token.safeTransfer(msg.sender, data.outputAmount);\n            uint256 remainingBalance = data.token.getBalance();\n            uint256 feeAmount = remainingBalance > 1 ? remainingBalance - 1 : 0;\n            if (feeAmount > 0) {\n                data.token.safeTransfer(feeRecipient, feeAmount);\n            }\n            return feeAmount;\n        }\n    }\n\n    function _executeSwap(bytes calldata executorData) internal returns (uint256) {\n        SwapData memory data = abi.decode(executorData, (SwapData));\n\n        if (data.shouldApprove) {\n            data.srcToken.safeApproveWithRetry(data.target, type(uint256).max);\n        }\n\n        // BUY is exact-output: settlement expects to receive *exactly* the amount the target produced\n        // on this call, not whatever happens to sit on the executor afterwards. Snapshot the dest balance\n        // pre-call so any pre-existing dust (e.g. 1-wei kept by a prior SELL) stays on the contract.\n        uint256 destBalanceBefore = data.isBuy ? data.destToken.getBalance() : 0;\n\n        (bool success,) = data.target.call{ value: data.value }(data.targetCalldata);\n        if (!success) {\n            revert ExecutionFailed();\n        }\n\n        if (data.isBuy) {\n            // srcLeftover above quotedAmount is the fee, up to maxFeeAmount; the rest is refunded to msg.sender\n            // by `transferFeesAndETH` (its remainder leg).\n            uint256 buyFeeAmount = _cappedFee(data.srcToken.getBalance(), data.quotedAmount, data.maxFeeAmount);\n            msg.sender.transferFeesAndETH(data.feeRecipient, data.srcToken, buyFeeAmount);\n\n            // Forward only the destToken / ETH delta produced by this call (pre-existing dust excluded).\n            uint256 balNow = data.destToken.getBalance();\n            uint256 destReceived = balNow > destBalanceBefore ? balNow - destBalanceBefore : 0;\n            if (destReceived > 0) {\n                if (data.destToken == ExecutorLib.ETH_ADDRESS) {\n                    msg.sender.safeTransferETH(destReceived);\n                } else {\n                    data.destToken.safeTransfer(msg.sender, destReceived);\n                }\n            }\n\n            return buyFeeAmount;\n        }\n\n        // Sell: surplus over quotedAmount is the fee, up to maxFeeAmount; the rest goes to msg.sender.\n        uint256 feeAmount = _cappedFee(data.destToken.getBalance(), data.quotedAmount, data.maxFeeAmount);\n        msg.sender.transferFeesAndETH(data.feeRecipient, data.destToken, feeAmount);\n\n        return feeAmount;\n    }\n\n    /// @dev Fee = min(max(0, amount - quotedAmount), maxFeeAmount).\n    function _cappedFee(uint256 amount, uint256 quotedAmount, uint256 maxFeeAmount) internal pure returns (uint256) {\n        uint256 surplus = amount > quotedAmount ? amount - quotedAmount : 0;\n        return surplus < maxFeeAmount ? surplus : maxFeeAmount;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                            EXTERNAL UTILS\n    //////////////////////////////////////////////////////////////*/\n\n    function encodeTransferData(TransferData calldata data) external pure returns (bytes memory) {\n        return abi.encode(data);\n    }\n\n    function encodeExactTransferData(ExactTransferData calldata data) external pure returns (bytes memory) {\n        return abi.encode(data);\n    }\n\n    function encodeSwapData(SwapData calldata data) external pure returns (bytes memory) {\n        return abi.encode(data);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                 RECEIVE\n    //////////////////////////////////////////////////////////////*/\n\n    receive() external payable { }\n}\n"},"src/executors/libraries/ExecutorLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/token/ERC20/IERC20.sol\";\n\n// Libraries\nimport { SafeTransferLib } from \"@solady/utils/SafeTransferLib.sol\";\n\n/// @title ExecutorLib\n/// @dev Library with functions that can be reused by Executor contracts\nlibrary ExecutorLib {\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using SafeTransferLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Native ETH address\n    address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n\n    /*//////////////////////////////////////////////////////////////\n                                  FEES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Transfers ERC20 or native ETH fees to the fee recipient, transfer native ETH or ERC20 to recipient\n    /// @param recipient The address to transfer the funds to\n    /// @param feeRecipient The address to transfer the fees to\n    /// @param feeToken The address of the fee token\n    /// @param feeAmount The amount of fee to transfer\n    function transferFeesAndETH(address recipient, address feeRecipient, address feeToken, uint256 feeAmount) internal {\n        // If the fee recipient is not set, set it to tx.origin\n        feeRecipient = feeRecipient == address(0) ? tx.origin : feeRecipient;\n        // If the destToken is ETH, transfer fee amount to the owner,\n        // and the remaining balance to the Delta contract. Otherwise,\n        // ERC20 transfer the fee amount to the owner\n        if (feeToken == ETH_ADDRESS) {\n            if (feeAmount > 0) {\n                // Transfer the fee amount to the fee recipient\n                feeRecipient.safeTransferETH(feeAmount);\n            }\n            // Transfer any remaining balance to the Delta contract\n            uint256 remainingBalance = address(this).balance;\n            if (remainingBalance != 0) {\n                recipient.safeTransferETH(remainingBalance);\n            }\n        } else {\n            if (feeAmount > 0) {\n                // Transfer the fee amount to the fee recipient or tx.origin if not set\n                feeToken.safeTransfer(feeRecipient, feeAmount);\n            }\n            // Transfer any remaining balance to the recipient, deducting 1 wei for gas optimization\n            uint256 remainingBalance = IERC20(feeToken).balanceOf(address(this));\n            if (remainingBalance > 1) {\n                feeToken.safeTransfer(recipient, remainingBalance - 1);\n            }\n        }\n    }\n}\n"},"src/modules/libraries/ERC20UtilsLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Libraries\nimport { SafeTransferLib } from \"@solady/utils/SafeTransferLib.sol\";\n\n/// @title ERC20 Utility Library\n/// @dev Library with common functions used by different modules within the Portikus V2 protocol\nlibrary ERC20UtilsLib {\n    /*//////////////////////////////////////////////////////////////\n                                 ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when the permit execution fails\n    error PermitFailed();\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev An address used to represent the native token\n    address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n    /// @dev The address of the Permit2 contract\n    address internal constant PERMIT2_ADDRESS = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using SafeTransferLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                                TRANSFER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Transfer the dest token to the order beneficiary, reducing the amount by 1 wei for gas optimization\n    ///      purposes. If the destToken is ETH, it will transfer native ETH to recipient\n    /// @param destToken The address of the dest token\n    /// @param recipient The address to transfer to\n    /// @param amount The amount to transfer\n    function transferTo(address destToken, address recipient, uint256 amount) internal {\n        // If the destToken is ETH, transfer native ETH\n        if (isEth(destToken)) {\n            recipient.safeTransferETH(amount);\n        } else {\n            // Otherwise, transfer the dest token to the recipient, reducing the amount by 1 wei\n            // for gas optimization purposes\n            destToken.safeTransfer(recipient, amount);\n        }\n    }\n\n    /// @dev Transfer the src token from the user to a recipient, using permit2 allowance or erc20 allowance based on\n    ///      permit length, if the permit length is 192 or 1 it will call transferFrom using permit2\n    ///      allowance, otherwise it will call transferFrom using erc20 allowance unless permit length is 96\n    /// @param srcToken The address of the src token\n    /// @param owner The owner of the token\n    /// @param recipient The recipient of the token\n    /// @param amount The amount to transfer\n    /// @param permitLength The length of the permit\n    function transferFrom(\n        address srcToken,\n        address owner,\n        address recipient,\n        uint256 amount,\n        uint256 permitLength\n    )\n        internal\n    {\n        // Skip transferring if the permit length is 96 (permit2TransferFrom)\n        if (permitLength == 96) {\n            return;\n        }\n        // If the permit length is 192 or 1 execute permit2TransferFrom to transfer the\n        // input assets from the owner to the agent, otherwise execute ERC20 transferFrom\n        if (permitLength == 192 || permitLength == 1) {\n            // Transfer the input assets from the owner to the recipient using permit2 allowance\n            srcToken.permit2TransferFrom(owner, recipient, amount);\n        } else {\n            // Transfer the input assets from the owner to the recipient using the ERC20 transferFrom function\n            srcToken.safeTransferFrom(owner, recipient, amount);\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                 PERMIT\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Executes the permit function on the provided token, depending on the permit length,\n    ///      it will call the EIP2612 permit (224), DAI-Style permit (256), Permit2 AllowanceTransfer (192)\n    ///      or Permit2 Signature (96)\n    /// @param token The address of the token\n    /// @param data The permit data\n    /// @param owner The owner of the token (used for Permit2)\n    /// @param deadline The deadline for the permit (used for Permit2)\n    /// @param amount The amount to permit (used for Permit2)\n    function permit(\n        address token,\n        bytes calldata data,\n        address owner,\n        uint256 deadline,\n        uint256 amount,\n        address recipient\n    )\n        internal\n    {\n        // solhint-disable-next-line no-inline-assembly\n        assembly (\"memory-safe\") {\n            // check the permit length\n            switch data.length\n            // 0x00 = no permit\n            case 0x00 {\n            // do nothing\n            }\n            case 0x01 {\n            // 0x01 is used to signify already existing permit2 allowance\n            }\n            // 32(permit2nonce) + 64(signature) = 96 Permit2 Transfer format\n            case 0x60 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x30f28b7a00000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), token) // store the srcToken\n                mstore(add(x, 0x24), amount) // store the amount\n                calldatacopy(add(x, 0x44), data.offset, 0x20) // copy the nonce\n                mstore(add(x, 0x64), deadline) // store the deadline\n                mstore(add(x, 0x84), recipient) // store the recipient address (executor)\n                mstore(add(x, 0xa4), amount) // store the amount\n                mstore(add(x, 0xc4), owner) // store the owner\n                mstore(add(x, 0xe4), 0x100) // store the offset\n                mstore(add(x, 0x104), 0x40) // store the length\n                calldatacopy(add(x, 0x124), add(data.offset, 0x20), 0x40) // copy the signature\n                // Call Permit2 contract and revert on failure\n                if iszero(call(gas(), PERMIT2_ADDRESS, 0x00, x, 0x164, 0x00, 0x00)) {\n                    mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the\n                    // selector\n                    revert(0x00, 0x04) // Revert with PermitFailed error\n                }\n            }\n            // 32(amount) + 32(nonce) + 32(expiration) + 32(sigDeadline) + 64(signature) = 192 Permit2 allowance format\n            case 0xc0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x2b67b57000000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), owner) // store the owner address\n                mstore(add(x, 0x24), token) // store the token address\n                calldatacopy(add(x, 0x44), data.offset, 0x60) // copy amount, expiration, nonce\n                mstore(add(x, 0xa4), address()) // store this contract's address as the spender\n                calldatacopy(add(x, 0xc4), add(data.offset, 0x60), 0x20) // copy sigDeadline\n                mstore(add(x, 0xe4), 0x100) // store the offset for signature\n                mstore(add(x, 0x104), 0x40) // store the length of signature\n                calldatacopy(add(x, 0x124), add(data.offset, 0x80), 0x40) // copy the signature\n                // Call Permit2 contract and revert on failure\n                if iszero(call(gas(), PERMIT2_ADDRESS, 0x00, x, 0x164, 0x00, 0x00)) {\n                    mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the\n                    // selector\n                    revert(0x00, 0x04) // Revert with PermitFailed error\n                }\n            }\n            // 32 * 7 = 224 EIP2612 Permit\n            case 0xe0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0xd505accf00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0xe0) // store the args\n                pop(call(gas(), token, 0x00, x, 0xe4, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // 32 * 8 = 256 DAI-Style Permit\n            case 0x100 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x8fcbaf0c00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0x100) // store the args\n                pop(call(gas(), token, 0x00, x, 0x104, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // Otherwise revert\n            default {\n                mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the selector\n                revert(0x00, 0x04) // Revert with PermitFailed error\n            }\n        }\n    }\n\n    /// @dev A fillable version of the permit function from this lib, that doesn't support Permit2 SignatureTransfer\n    /// @param token The address of the token\n    /// @param data The permit data\n    /// @param owner The owner of the token (used for Permit2)\n    function permit(address token, bytes calldata data, address owner) internal {\n        // solhint-disable-next-line no-inline-assembly\n        assembly (\"memory-safe\") {\n            // check the permit length\n            switch data.length\n            // 0x00 = no permit\n            case 0x00 {\n            // do nothing\n            }\n            case 0x01 {\n            // 0x01 is used to signify already existing permit2 allowance\n            }\n            // 32(amount) + 32(nonce) + 32(expiration) + 32(sigDeadline) + 64(signature) = 192 Permit2 allowance format\n            case 0xc0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x2b67b57000000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), owner) // store the owner address\n                mstore(add(x, 0x24), token) // store the token address\n                calldatacopy(add(x, 0x44), data.offset, 0x60) // copy amount, expiration, nonce\n                mstore(add(x, 0xa4), address()) // store this contract's address as the spender\n                calldatacopy(add(x, 0xc4), add(data.offset, 0x60), 0x20) // copy sigDeadline\n                mstore(add(x, 0xe4), 0x100) // store the offset for signature\n                mstore(add(x, 0x104), 0x40) // store the length of signature\n                calldatacopy(add(x, 0x124), add(data.offset, 0x80), 0x40) // copy the signature\n                // Call Permit2 contract and revert on failure\n                if iszero(call(gas(), PERMIT2_ADDRESS, 0x00, x, 0x164, 0x00, 0x00)) {\n                    mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the\n                    // selector\n                    revert(0x00, 0x04) // Revert with PermitFailed error\n                }\n            }\n            // 32 * 7 = 224 EIP2612 Permit\n            case 0xe0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0xd505accf00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0xe0) // store the args\n                pop(call(gas(), token, 0x00, x, 0xe4, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // 32 * 8 = 256 DAI-Style Permit\n            case 0x100 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x8fcbaf0c00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0x100) // store the args\n                pop(call(gas(), token, 0x00, x, 0x104, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // Otherwise revert\n            default {\n                mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the selector\n                revert(0x00, 0x04) // Revert with PermitFailed error\n            }\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                UTILITIES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Checks if a token is ETH\n    /// @param token The token address to check\n    /// @return True if the token represents ETH\n    function isEth(address token) internal pure returns (bool) {\n        return token == ETH_ADDRESS;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                BALANCE\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Returns the balance of address(this), works for both ETH and ERC20 tokens\n    function getBalance(address token) internal view returns (uint256 balanceOf) {\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            switch eq(token, ETH_ADDRESS)\n            // ETH\n            case 0x01 { balanceOf := selfbalance() }\n            // ERC20\n            default {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x70a0823100000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), address()) // store the account\n                let success := staticcall(gas(), token, x, 0x24, x, 0x20) // call balanceOf\n                if success { balanceOf := mload(x)} // load the balance\n            }\n        }\n    }\n}\n"},"lib/solady/src/utils/SafeTransferLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)\n///\n/// @dev Note:\n/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.\nlibrary SafeTransferLib {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ETH transfer has failed.\n    error ETHTransferFailed();\n\n    /// @dev The ERC20 `transferFrom` has failed.\n    error TransferFromFailed();\n\n    /// @dev The ERC20 `transfer` has failed.\n    error TransferFailed();\n\n    /// @dev The ERC20 `approve` has failed.\n    error ApproveFailed();\n\n    /// @dev The Permit2 operation has failed.\n    error Permit2Failed();\n\n    /// @dev The Permit2 amount must be less than `2**160 - 1`.\n    error Permit2AmountOverflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.\n    uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;\n\n    /// @dev Suggested gas stipend for contract receiving ETH to perform a few\n    /// storage reads and writes, but low enough to prevent griefing.\n    uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;\n\n    /// @dev The unique EIP-712 domain domain separator for the DAI token contract.\n    bytes32 internal constant DAI_DOMAIN_SEPARATOR =\n        0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;\n\n    /// @dev The address for the WETH9 contract on Ethereum mainnet.\n    address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n\n    /// @dev The canonical Permit2 address.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ETH OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.\n    //\n    // The regular variants:\n    // - Forwards all remaining gas to the target.\n    // - Reverts if the target reverts.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The force variants:\n    // - Forwards with an optional gas stipend\n    //   (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).\n    // - If the target reverts, or if the gas stipend is exhausted,\n    //   creates a temporary contract to force send the ETH via `SELFDESTRUCT`.\n    //   Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The try variants:\n    // - Forwards with a mandatory gas stipend.\n    // - Instead of reverting, returns whether the transfer succeeded.\n\n    /// @dev Sends `amount` (in wei) ETH to `to`.\n    function safeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`.\n    function safeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Transfer all the ETH and check if it succeeded or not.\n            if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // forgefmt: disable-next-item\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function trySafeTransferAllETH(address to, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      ERC20 OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for\n    /// the current contract to manage.\n    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function trySafeTransferFrom(address token, address from, address to, uint256 amount)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                success := lt(or(iszero(extcodesize(token)), returndatasize()), success)\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have their entire balance approved for the current contract to manage.\n    function safeTransferAllFrom(address token, address from, address to)\n        internal\n        returns (uint256 amount)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.\n            amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.\n            // Perform the transfer, reverting upon failure.\n            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransfer(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransferAll(address token, address to) internal returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.\n            mstore(0x20, address()) // Store the address of the current contract.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x14, to) // Store the `to` argument.\n            amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// Reverts upon failure.\n    function safeApprove(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,\n    /// then retries the approval again (some tokens, e.g. USDT, requires this).\n    /// Reverts upon failure.\n    function safeApproveWithRetry(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            // Perform the approval, retrying upon failure.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x34, 0) // Store 0 for the `amount`.\n                    mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n                    pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.\n                    mstore(0x34, amount) // Store back the original `amount`.\n                    // Retry the approval, reverting upon failure.\n                    success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                    if iszero(and(eq(mload(0x00), 1), success)) {\n                        // Check the `extcodesize` again just in case the token selfdestructs lol.\n                        if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                            mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                            revert(0x1c, 0x04)\n                        }\n                    }\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Returns the amount of ERC20 `token` owned by `account`.\n    /// Returns zero if the `token` does not exist.\n    function balanceOf(address token, address account) internal view returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, account) // Store the `account` argument.\n            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            amount :=\n                mul( // The arguments of `mul` are evaluated from right to left.\n                    mload(0x20),\n                    and( // The arguments of `and` are evaluated from right to left.\n                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)\n                    )\n                )\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// If the initial attempt fails, try to use Permit2 to transfer the token.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {\n        if (!trySafeTransferFrom(token, from, to, amount)) {\n            permit2TransferFrom(token, from, to, amount);\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2.\n    /// Reverts upon failure.\n    function permit2TransferFrom(address token, address from, address to, uint256 amount)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(add(m, 0x74), shr(96, shl(96, token)))\n            mstore(add(m, 0x54), amount)\n            mstore(add(m, 0x34), to)\n            mstore(add(m, 0x20), shl(96, from))\n            // `transferFrom(address,address,uint160,address)`.\n            mstore(m, 0x36c78516000000000000000000000000)\n            let p := PERMIT2\n            let exists := eq(chainid(), 1)\n            if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }\n            if iszero(\n                and(\n                    call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),\n                    lt(iszero(extcodesize(token)), exists) // Token has code and Permit2 exists.\n                )\n            ) {\n                mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)\n            }\n        }\n    }\n\n    /// @dev Permit a user to spend a given amount of\n    /// another user's tokens via native EIP-2612 permit if possible, falling\n    /// back to Permit2 if native permit fails or is not implemented on the token.\n    function permit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly {\n            for {} shl(96, xor(token, WETH9)) {} {\n                mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.\n                if iszero(\n                    and( // The arguments of `and` are evaluated from right to left.\n                        lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.\n                        // Gas stipend to limit gas burn for tokens that don't refund gas when\n                        // an non-existing function is called. 5K should be enough for a SLOAD.\n                        staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)\n                    )\n                ) { break }\n                // After here, we can be sure that token is a contract.\n                let m := mload(0x40)\n                mstore(add(m, 0x34), spender)\n                mstore(add(m, 0x20), shl(96, owner))\n                mstore(add(m, 0x74), deadline)\n                if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {\n                    mstore(0x14, owner)\n                    mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.\n                    mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))\n                    mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.\n                    // `nonces` is already at `add(m, 0x54)`.\n                    // `1` is already stored at `add(m, 0x94)`.\n                    mstore(add(m, 0xb4), and(0xff, v))\n                    mstore(add(m, 0xd4), r)\n                    mstore(add(m, 0xf4), s)\n                    success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)\n                    break\n                }\n                mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.\n                mstore(add(m, 0x54), amount)\n                mstore(add(m, 0x94), and(0xff, v))\n                mstore(add(m, 0xb4), r)\n                mstore(add(m, 0xd4), s)\n                success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)\n                break\n            }\n        }\n        if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);\n    }\n\n    /// @dev Simple permit on the Permit2 contract.\n    function simplePermit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(m, 0x927da105) // `allowance(address,address,address)`.\n            {\n                let addressMask := shr(96, not(0))\n                mstore(add(m, 0x20), and(addressMask, owner))\n                mstore(add(m, 0x40), and(addressMask, token))\n                mstore(add(m, 0x60), and(addressMask, spender))\n                mstore(add(m, 0xc0), and(addressMask, spender))\n            }\n            let p := mul(PERMIT2, iszero(shr(160, amount)))\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.\n                    staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)\n                )\n            ) {\n                mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(p))), 0x04)\n            }\n            mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).\n            // `owner` is already `add(m, 0x20)`.\n            // `token` is already at `add(m, 0x40)`.\n            mstore(add(m, 0x60), amount)\n            mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.\n            // `nonce` is already at `add(m, 0xa0)`.\n            // `spender` is already at `add(m, 0xc0)`.\n            mstore(add(m, 0xe0), deadline)\n            mstore(add(m, 0x100), 0x100) // `signature` offset.\n            mstore(add(m, 0x120), 0x41) // `signature` length.\n            mstore(add(m, 0x140), r)\n            mstore(add(m, 0x160), s)\n            mstore(add(m, 0x180), shl(248, v))\n            if iszero( // Revert if token does not have code, or if the call fails.\n            mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))) {\n                mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.25+commit.b61c2a91","compilerSettings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"none","useLiteralContent":false},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun","remappings":["@forge-std/=lib/forge-std/src/","@interfaces/=src/interfaces/","@types/=src/types/","@libraries/=src/libraries/","@solady/=lib/solady/src/","@prb-test/=lib/prb-test/src/","@openzeppelin/=lib/openzeppelin-contracts/contracts/","@admin/=src/admin/","@executors/=src/executors/","@mocks/=test/mocks/","@factory/=src/factory/","@registry/=src/registry/","@modules/=src/modules/","@adapter/=src/adapter/","@tokens/=src/tokens/","@test/=test/","@aave-v3-core/=lib/aave-v3-core/contracts/","@create3/=lib/create3-factory/src/","@morpho/=lib/morpho-blue/src/","@uniswap-v4-core/=lib/v4-core/src/","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","aave-v3-core/=lib/aave-v3-core/","create3-factory/=lib/create3-factory/","ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","hardhat/=lib/v4-core/node_modules/hardhat/","morpho-blue/=lib/morpho-blue/","openzeppelin-contracts/=lib/openzeppelin-contracts/","prb-test/=lib/prb-test/src/","solady/=lib/solady/src/","solmate/=lib/v4-core/lib/solmate/","v4-core/=lib/v4-core/src/"]},"name":"GenericSwapExecutor","fullyQualifiedName":"src/executors/example/GenericSwapExecutor.sol:GenericSwapExecutor"},"abi":[{"name":"ExecutionFailed","type":"error","inputs":[]},{"name":"encodeExactTransferData","type":"function","inputs":[{"name":"data","type":"tuple","components":[{"name":"token","type":"address","internalType":"address"},{"name":"feeRecipient","type":"address","internalType":"address"},{"name":"outputAmount","type":"uint256","internalType":"uint256"},{"name":"isExactTransfer","type":"bool","internalType":"bool"}],"internalType":"struct GenericSwapExecutor.ExactTransferData"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"encodeSwapData","type":"function","inputs":[{"name":"data","type":"tuple","components":[{"name":"isBuy","type":"bool","internalType":"bool"},{"name":"srcToken","type":"address","internalType":"address"},{"name":"destToken","type":"address","internalType":"address"},{"name":"quotedAmount","type":"uint256","internalType":"uint256"},{"name":"maxFeeAmount","type":"uint256","internalType":"uint256"},{"name":"feeRecipient","type":"address","internalType":"address"},{"name":"shouldApprove","type":"bool","internalType":"bool"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"target","type":"address","internalType":"address"},{"name":"targetCalldata","type":"bytes","internalType":"bytes"}],"internalType":"struct GenericSwapExecutor.SwapData"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"encodeTransferData","type":"function","inputs":[{"name":"data","type":"tuple","components":[{"name":"token","type":"address","internalType":"address"},{"name":"feeRecipient","type":"address","internalType":"address"},{"name":"feeAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct GenericSwapExecutor.TransferData"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"execute","type":"function","inputs":[{"name":"executorData","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.25+commit.b61c2a91"},"language":"Solidity","output":{"abi":[{"inputs":[],"name":"ExecutionFailed","type":"error"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"feeRecipient","type":"address"},{"internalType":"uint256","name":"outputAmount","type":"uint256"},{"internalType":"bool","name":"isExactTransfer","type":"bool"}],"internalType":"struct GenericSwapExecutor.ExactTransferData","name":"data","type":"tuple"}],"name":"encodeExactTransferData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"bool","name":"isBuy","type":"bool"},{"internalType":"address","name":"srcToken","type":"address"},{"internalType":"address","name":"destToken","type":"address"},{"internalType":"uint256","name":"quotedAmount","type":"uint256"},{"internalType":"uint256","name":"maxFeeAmount","type":"uint256"},{"internalType":"address","name":"feeRecipient","type":"address"},{"internalType":"bool","name":"shouldApprove","type":"bool"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"targetCalldata","type":"bytes"}],"internalType":"struct GenericSwapExecutor.SwapData","name":"data","type":"tuple"}],"name":"encodeSwapData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"feeRecipient","type":"address"},{"internalType":"uint256","name":"feeAmount","type":"uint256"}],"internalType":"struct GenericSwapExecutor.TransferData","name":"data","type":"tuple"}],"name":"encodeTransferData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"executorData","type":"bytes"}],"name":"execute","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"details":"Return data from the target is not decoded; receivedAmount / spentAmount are inferred from the      executor's post-call balances. Any dust left on this contract is accepted as a gas optimisation.","kind":"dev","methods":{"execute(bytes)":{"details":"Dispatch is by encoded length: 0x60 → Transfer, 0x80 → ExactTransfer, else → Swap.","params":{"executorData":"Encoded struct: `TransferData`, `ExactTransferData`, or `SwapData`."},"returns":{"_0":"feeAmount The fee collected on this execution."}}},"title":"Generic Swap Executor","version":1},"userdoc":{"errors":{"ExecutionFailed()":[{"notice":"Raised when the target call reverts."}]},"kind":"user","methods":{"execute(bytes)":{"notice":"Entrypoint dispatched by settlement / probe modules."}},"notice":"Variant of LaitaExecutor that calls an arbitrary caller-specified target instead of a fixed Augustus         address. Intended for the winning-bid submission flow where the solver selects both the target and         the calldata.","version":1}},"settings":{"compilationTarget":{"src/executors/example/GenericSwapExecutor.sol":"GenericSwapExecutor"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":1000000},"remappings":[":@aave-v3-core/=lib/aave-v3-core/contracts/",":@adapter/=src/adapter/",":@admin/=src/admin/",":@create3/=lib/create3-factory/src/",":@ensdomains/=lib/v4-core/node_modules/@ensdomains/",":@executors/=src/executors/",":@factory/=src/factory/",":@forge-std/=lib/forge-std/src/",":@interfaces/=src/interfaces/",":@libraries/=src/libraries/",":@mocks/=test/mocks/",":@modules/=src/modules/",":@morpho/=lib/morpho-blue/src/",":@openzeppelin/=lib/openzeppelin-contracts/contracts/",":@prb-test/=lib/prb-test/src/",":@registry/=src/registry/",":@solady/=lib/solady/src/",":@test/=test/",":@tokens/=src/tokens/",":@types/=src/types/",":@uniswap-v4-core/=lib/v4-core/src/",":aave-v3-core/=lib/aave-v3-core/",":create3-factory/=lib/create3-factory/",":ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":hardhat/=lib/v4-core/node_modules/hardhat/",":morpho-blue/=lib/morpho-blue/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":prb-test/=lib/prb-test/src/",":solady/=lib/solady/src/",":solmate/=lib/v4-core/lib/solmate/",":v4-core/=lib/v4-core/src/"]},"sources":{"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"keccak256":"0xee2337af2dc162a973b4be6d3f7c16f06298259e0af48c5470d2839bfa8a22f4","license":"MIT","urls":["bzz-raw://30c476b4b2f405c1bb3f0bae15b006d129c80f1bfd9d0f2038160a3bb9745009","dweb:/ipfs/Qmb3VcuDufv6xbHeVgksC4tHpc5gKYVqBEwjEXW72XzSvN"]},"lib/solady/src/utils/SafeTransferLib.sol":{"keccak256":"0x7d0de1ff3be5dc32635283280b000d4794015a1b61d7dae7f3ff7b0721b07210","license":"MIT","urls":["bzz-raw://e307c9eece677565e7d584ee77c56134b5db38a70f557f9d2b1b308219276c0c","dweb:/ipfs/QmTEtqaTFgRBFGpJyb5o4v2w8yrSpcNThov4bNpcLr2tTR"]},"src/executors/example/GenericSwapExecutor.sol":{"keccak256":"0x5c1459872762b3a39ecfef922bfafbe4fc54ed8114f7c043e68aa36bbf039574","license":"MIT","urls":["bzz-raw://fe22101226cf47a108cfd65ced2646c0d496f7c672386c1f7f66ca78f756a94a","dweb:/ipfs/QmT82PDu2exLdCxAJYP5LdhKX1BHjhqDNJDNn2pz68WxoR"]},"src/executors/libraries/ExecutorLib.sol":{"keccak256":"0xb8d78cd226b837d3165c393b32c5ecc9d3e0e31d489b6207471233d0d99fbb94","license":"MIT","urls":["bzz-raw://f364fecf08f6bde288f59b3b28015e75ad1c13593de614c86046f1a2f8f7aefa","dweb:/ipfs/QmV7vmkFJEDhcZaDMoETHC3zSQXLyK2AbjBfnfongWndsq"]},"src/modules/libraries/ERC20UtilsLib.sol":{"keccak256":"0xbaae3794d78094d9853a3db33f87fdcde45a601a96e57de819b420454e08c7bd","license":"MIT","urls":["bzz-raw://14327aa2d5cb182c377e8ecb83bd4da60d2032a76fa672e1a2884a210438b7f3","dweb:/ipfs/QmYicRHtGVJjkyzhHAVCSZuSFVA95NBuQasMpGUU6aNSMZ"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"ExecutionFailed()":[{"notice":"Raised when the target call reverts."}]},"notice":"Variant of LaitaExecutor that calls an arbitrary caller-specified target instead of a fixed Augustus         address. Intended for the winning-bid submission flow where the solver selects both the target and         the calldata.","methods":{"execute(bytes)":{"notice":"Entrypoint dispatched by settlement / probe modules."}},"version":1},"devdoc":{"kind":"dev","title":"Generic Swap Executor","details":"Return data from the target is not decoded; receivedAmount / spentAmount are inferred from the      executor's post-call balances. Any dust left on this contract is accepted as a gas optimisation.","methods":{"execute(bytes)":{"params":{"executorData":"Encoded struct: `TransferData`, `ExactTransferData`, or `SwapData`."},"details":"Dispatch is by encoded length: 0x60 → Transfer, 0x80 → ExactTransfer, else → Swap.","returns":{"_0":"feeAmount The fee collected on this execution."}}},"version":1},"sourceIds":{"src/executors/libraries/ExecutorLib.sol":{"id":3},"src/modules/libraries/ERC20UtilsLib.sol":{"id":4},"lib/solady/src/utils/SafeTransferLib.sol":{"id":1},"src/executors/example/GenericSwapExecutor.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":0}},"additionalInput":null,"stdJsonInput":{"sources":{"src/executors/libraries/ExecutorLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Interfaces\nimport { IERC20 } from \"@openzeppelin/token/ERC20/IERC20.sol\";\n\n// Libraries\nimport { SafeTransferLib } from \"@solady/utils/SafeTransferLib.sol\";\n\n/// @title ExecutorLib\n/// @dev Library with functions that can be reused by Executor contracts\nlibrary ExecutorLib {\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using SafeTransferLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Native ETH address\n    address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n\n    /*//////////////////////////////////////////////////////////////\n                                  FEES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Transfers ERC20 or native ETH fees to the fee recipient, transfer native ETH or ERC20 to recipient\n    /// @param recipient The address to transfer the funds to\n    /// @param feeRecipient The address to transfer the fees to\n    /// @param feeToken The address of the fee token\n    /// @param feeAmount The amount of fee to transfer\n    function transferFeesAndETH(address recipient, address feeRecipient, address feeToken, uint256 feeAmount) internal {\n        // If the fee recipient is not set, set it to tx.origin\n        feeRecipient = feeRecipient == address(0) ? tx.origin : feeRecipient;\n        // If the destToken is ETH, transfer fee amount to the owner,\n        // and the remaining balance to the Delta contract. Otherwise,\n        // ERC20 transfer the fee amount to the owner\n        if (feeToken == ETH_ADDRESS) {\n            if (feeAmount > 0) {\n                // Transfer the fee amount to the fee recipient\n                feeRecipient.safeTransferETH(feeAmount);\n            }\n            // Transfer any remaining balance to the Delta contract\n            uint256 remainingBalance = address(this).balance;\n            if (remainingBalance != 0) {\n                recipient.safeTransferETH(remainingBalance);\n            }\n        } else {\n            if (feeAmount > 0) {\n                // Transfer the fee amount to the fee recipient or tx.origin if not set\n                feeToken.safeTransfer(feeRecipient, feeAmount);\n            }\n            // Transfer any remaining balance to the recipient, deducting 1 wei for gas optimization\n            uint256 remainingBalance = IERC20(feeToken).balanceOf(address(this));\n            if (remainingBalance > 1) {\n                feeToken.safeTransfer(recipient, remainingBalance - 1);\n            }\n        }\n    }\n}\n"},"src/modules/libraries/ERC20UtilsLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Libraries\nimport { SafeTransferLib } from \"@solady/utils/SafeTransferLib.sol\";\n\n/// @title ERC20 Utility Library\n/// @dev Library with common functions used by different modules within the Portikus V2 protocol\nlibrary ERC20UtilsLib {\n    /*//////////////////////////////////////////////////////////////\n                                 ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Emitted when the permit execution fails\n    error PermitFailed();\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTANTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev An address used to represent the native token\n    address internal constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n    /// @dev The address of the Permit2 contract\n    address internal constant PERMIT2_ADDRESS = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using SafeTransferLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                                TRANSFER\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Transfer the dest token to the order beneficiary, reducing the amount by 1 wei for gas optimization\n    ///      purposes. If the destToken is ETH, it will transfer native ETH to recipient\n    /// @param destToken The address of the dest token\n    /// @param recipient The address to transfer to\n    /// @param amount The amount to transfer\n    function transferTo(address destToken, address recipient, uint256 amount) internal {\n        // If the destToken is ETH, transfer native ETH\n        if (isEth(destToken)) {\n            recipient.safeTransferETH(amount);\n        } else {\n            // Otherwise, transfer the dest token to the recipient, reducing the amount by 1 wei\n            // for gas optimization purposes\n            destToken.safeTransfer(recipient, amount);\n        }\n    }\n\n    /// @dev Transfer the src token from the user to a recipient, using permit2 allowance or erc20 allowance based on\n    ///      permit length, if the permit length is 192 or 1 it will call transferFrom using permit2\n    ///      allowance, otherwise it will call transferFrom using erc20 allowance unless permit length is 96\n    /// @param srcToken The address of the src token\n    /// @param owner The owner of the token\n    /// @param recipient The recipient of the token\n    /// @param amount The amount to transfer\n    /// @param permitLength The length of the permit\n    function transferFrom(\n        address srcToken,\n        address owner,\n        address recipient,\n        uint256 amount,\n        uint256 permitLength\n    )\n        internal\n    {\n        // Skip transferring if the permit length is 96 (permit2TransferFrom)\n        if (permitLength == 96) {\n            return;\n        }\n        // If the permit length is 192 or 1 execute permit2TransferFrom to transfer the\n        // input assets from the owner to the agent, otherwise execute ERC20 transferFrom\n        if (permitLength == 192 || permitLength == 1) {\n            // Transfer the input assets from the owner to the recipient using permit2 allowance\n            srcToken.permit2TransferFrom(owner, recipient, amount);\n        } else {\n            // Transfer the input assets from the owner to the recipient using the ERC20 transferFrom function\n            srcToken.safeTransferFrom(owner, recipient, amount);\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                 PERMIT\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Executes the permit function on the provided token, depending on the permit length,\n    ///      it will call the EIP2612 permit (224), DAI-Style permit (256), Permit2 AllowanceTransfer (192)\n    ///      or Permit2 Signature (96)\n    /// @param token The address of the token\n    /// @param data The permit data\n    /// @param owner The owner of the token (used for Permit2)\n    /// @param deadline The deadline for the permit (used for Permit2)\n    /// @param amount The amount to permit (used for Permit2)\n    function permit(\n        address token,\n        bytes calldata data,\n        address owner,\n        uint256 deadline,\n        uint256 amount,\n        address recipient\n    )\n        internal\n    {\n        // solhint-disable-next-line no-inline-assembly\n        assembly (\"memory-safe\") {\n            // check the permit length\n            switch data.length\n            // 0x00 = no permit\n            case 0x00 {\n            // do nothing\n            }\n            case 0x01 {\n            // 0x01 is used to signify already existing permit2 allowance\n            }\n            // 32(permit2nonce) + 64(signature) = 96 Permit2 Transfer format\n            case 0x60 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x30f28b7a00000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), token) // store the srcToken\n                mstore(add(x, 0x24), amount) // store the amount\n                calldatacopy(add(x, 0x44), data.offset, 0x20) // copy the nonce\n                mstore(add(x, 0x64), deadline) // store the deadline\n                mstore(add(x, 0x84), recipient) // store the recipient address (executor)\n                mstore(add(x, 0xa4), amount) // store the amount\n                mstore(add(x, 0xc4), owner) // store the owner\n                mstore(add(x, 0xe4), 0x100) // store the offset\n                mstore(add(x, 0x104), 0x40) // store the length\n                calldatacopy(add(x, 0x124), add(data.offset, 0x20), 0x40) // copy the signature\n                // Call Permit2 contract and revert on failure\n                if iszero(call(gas(), PERMIT2_ADDRESS, 0x00, x, 0x164, 0x00, 0x00)) {\n                    mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the\n                    // selector\n                    revert(0x00, 0x04) // Revert with PermitFailed error\n                }\n            }\n            // 32(amount) + 32(nonce) + 32(expiration) + 32(sigDeadline) + 64(signature) = 192 Permit2 allowance format\n            case 0xc0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x2b67b57000000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), owner) // store the owner address\n                mstore(add(x, 0x24), token) // store the token address\n                calldatacopy(add(x, 0x44), data.offset, 0x60) // copy amount, expiration, nonce\n                mstore(add(x, 0xa4), address()) // store this contract's address as the spender\n                calldatacopy(add(x, 0xc4), add(data.offset, 0x60), 0x20) // copy sigDeadline\n                mstore(add(x, 0xe4), 0x100) // store the offset for signature\n                mstore(add(x, 0x104), 0x40) // store the length of signature\n                calldatacopy(add(x, 0x124), add(data.offset, 0x80), 0x40) // copy the signature\n                // Call Permit2 contract and revert on failure\n                if iszero(call(gas(), PERMIT2_ADDRESS, 0x00, x, 0x164, 0x00, 0x00)) {\n                    mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the\n                    // selector\n                    revert(0x00, 0x04) // Revert with PermitFailed error\n                }\n            }\n            // 32 * 7 = 224 EIP2612 Permit\n            case 0xe0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0xd505accf00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0xe0) // store the args\n                pop(call(gas(), token, 0x00, x, 0xe4, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // 32 * 8 = 256 DAI-Style Permit\n            case 0x100 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x8fcbaf0c00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0x100) // store the args\n                pop(call(gas(), token, 0x00, x, 0x104, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // Otherwise revert\n            default {\n                mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the selector\n                revert(0x00, 0x04) // Revert with PermitFailed error\n            }\n        }\n    }\n\n    /// @dev A fillable version of the permit function from this lib, that doesn't support Permit2 SignatureTransfer\n    /// @param token The address of the token\n    /// @param data The permit data\n    /// @param owner The owner of the token (used for Permit2)\n    function permit(address token, bytes calldata data, address owner) internal {\n        // solhint-disable-next-line no-inline-assembly\n        assembly (\"memory-safe\") {\n            // check the permit length\n            switch data.length\n            // 0x00 = no permit\n            case 0x00 {\n            // do nothing\n            }\n            case 0x01 {\n            // 0x01 is used to signify already existing permit2 allowance\n            }\n            // 32(amount) + 32(nonce) + 32(expiration) + 32(sigDeadline) + 64(signature) = 192 Permit2 allowance format\n            case 0xc0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x2b67b57000000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), owner) // store the owner address\n                mstore(add(x, 0x24), token) // store the token address\n                calldatacopy(add(x, 0x44), data.offset, 0x60) // copy amount, expiration, nonce\n                mstore(add(x, 0xa4), address()) // store this contract's address as the spender\n                calldatacopy(add(x, 0xc4), add(data.offset, 0x60), 0x20) // copy sigDeadline\n                mstore(add(x, 0xe4), 0x100) // store the offset for signature\n                mstore(add(x, 0x104), 0x40) // store the length of signature\n                calldatacopy(add(x, 0x124), add(data.offset, 0x80), 0x40) // copy the signature\n                // Call Permit2 contract and revert on failure\n                if iszero(call(gas(), PERMIT2_ADDRESS, 0x00, x, 0x164, 0x00, 0x00)) {\n                    mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the\n                    // selector\n                    revert(0x00, 0x04) // Revert with PermitFailed error\n                }\n            }\n            // 32 * 7 = 224 EIP2612 Permit\n            case 0xe0 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0xd505accf00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0xe0) // store the args\n                pop(call(gas(), token, 0x00, x, 0xe4, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // 32 * 8 = 256 DAI-Style Permit\n            case 0x100 {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x8fcbaf0c00000000000000000000000000000000000000000000000000000000) // store the selector\n                calldatacopy(add(x, 0x04), data.offset, 0x100) // store the args\n                pop(call(gas(), token, 0x00, x, 0x104, 0x00, 0x20)) // call ERC20 permit, skip checking return data\n            }\n            // Otherwise revert\n            default {\n                mstore(0x00, 0xb78cb0dd00000000000000000000000000000000000000000000000000000000) // store the selector\n                revert(0x00, 0x04) // Revert with PermitFailed error\n            }\n        }\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                UTILITIES\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Checks if a token is ETH\n    /// @param token The token address to check\n    /// @return True if the token represents ETH\n    function isEth(address token) internal pure returns (bool) {\n        return token == ETH_ADDRESS;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                BALANCE\n    //////////////////////////////////////////////////////////////*/\n\n    /// @dev Returns the balance of address(this), works for both ETH and ERC20 tokens\n    function getBalance(address token) internal view returns (uint256 balanceOf) {\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            switch eq(token, ETH_ADDRESS)\n            // ETH\n            case 0x01 { balanceOf := selfbalance() }\n            // ERC20\n            default {\n                let x := mload(0x40) // get the free memory pointer\n                mstore(x, 0x70a0823100000000000000000000000000000000000000000000000000000000) // store the selector\n                mstore(add(x, 0x04), address()) // store the account\n                let success := staticcall(gas(), token, x, 0x24, x, 0x20) // call balanceOf\n                if success { balanceOf := mload(x)} // load the balance\n            }\n        }\n    }\n}\n"},"lib/solady/src/utils/SafeTransferLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)\n///\n/// @dev Note:\n/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.\nlibrary SafeTransferLib {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ETH transfer has failed.\n    error ETHTransferFailed();\n\n    /// @dev The ERC20 `transferFrom` has failed.\n    error TransferFromFailed();\n\n    /// @dev The ERC20 `transfer` has failed.\n    error TransferFailed();\n\n    /// @dev The ERC20 `approve` has failed.\n    error ApproveFailed();\n\n    /// @dev The Permit2 operation has failed.\n    error Permit2Failed();\n\n    /// @dev The Permit2 amount must be less than `2**160 - 1`.\n    error Permit2AmountOverflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.\n    uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;\n\n    /// @dev Suggested gas stipend for contract receiving ETH to perform a few\n    /// storage reads and writes, but low enough to prevent griefing.\n    uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;\n\n    /// @dev The unique EIP-712 domain domain separator for the DAI token contract.\n    bytes32 internal constant DAI_DOMAIN_SEPARATOR =\n        0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;\n\n    /// @dev The address for the WETH9 contract on Ethereum mainnet.\n    address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n\n    /// @dev The canonical Permit2 address.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ETH OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.\n    //\n    // The regular variants:\n    // - Forwards all remaining gas to the target.\n    // - Reverts if the target reverts.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The force variants:\n    // - Forwards with an optional gas stipend\n    //   (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).\n    // - If the target reverts, or if the gas stipend is exhausted,\n    //   creates a temporary contract to force send the ETH via `SELFDESTRUCT`.\n    //   Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The try variants:\n    // - Forwards with a mandatory gas stipend.\n    // - Instead of reverting, returns whether the transfer succeeded.\n\n    /// @dev Sends `amount` (in wei) ETH to `to`.\n    function safeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`.\n    function safeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Transfer all the ETH and check if it succeeded or not.\n            if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // forgefmt: disable-next-item\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function trySafeTransferAllETH(address to, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      ERC20 OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for\n    /// the current contract to manage.\n    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function trySafeTransferFrom(address token, address from, address to, uint256 amount)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                success := lt(or(iszero(extcodesize(token)), returndatasize()), success)\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have their entire balance approved for the current contract to manage.\n    function safeTransferAllFrom(address token, address from, address to)\n        internal\n        returns (uint256 amount)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.\n            amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.\n            // Perform the transfer, reverting upon failure.\n            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransfer(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransferAll(address token, address to) internal returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.\n            mstore(0x20, address()) // Store the address of the current contract.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x14, to) // Store the `to` argument.\n            amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// Reverts upon failure.\n    function safeApprove(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,\n    /// then retries the approval again (some tokens, e.g. USDT, requires this).\n    /// Reverts upon failure.\n    function safeApproveWithRetry(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            // Perform the approval, retrying upon failure.\n            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x34, 0) // Store 0 for the `amount`.\n                    mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n                    pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.\n                    mstore(0x34, amount) // Store back the original `amount`.\n                    // Retry the approval, reverting upon failure.\n                    success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                    if iszero(and(eq(mload(0x00), 1), success)) {\n                        // Check the `extcodesize` again just in case the token selfdestructs lol.\n                        if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                            mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                            revert(0x1c, 0x04)\n                        }\n                    }\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Returns the amount of ERC20 `token` owned by `account`.\n    /// Returns zero if the `token` does not exist.\n    function balanceOf(address token, address account) internal view returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, account) // Store the `account` argument.\n            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            amount :=\n                mul( // The arguments of `mul` are evaluated from right to left.\n                    mload(0x20),\n                    and( // The arguments of `and` are evaluated from right to left.\n                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)\n                    )\n                )\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// If the initial attempt fails, try to use Permit2 to transfer the token.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {\n        if (!trySafeTransferFrom(token, from, to, amount)) {\n            permit2TransferFrom(token, from, to, amount);\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2.\n    /// Reverts upon failure.\n    function permit2TransferFrom(address token, address from, address to, uint256 amount)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(add(m, 0x74), shr(96, shl(96, token)))\n            mstore(add(m, 0x54), amount)\n            mstore(add(m, 0x34), to)\n            mstore(add(m, 0x20), shl(96, from))\n            // `transferFrom(address,address,uint160,address)`.\n            mstore(m, 0x36c78516000000000000000000000000)\n            let p := PERMIT2\n            let exists := eq(chainid(), 1)\n            if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }\n            if iszero(\n                and(\n                    call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),\n                    lt(iszero(extcodesize(token)), exists) // Token has code and Permit2 exists.\n                )\n            ) {\n                mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)\n            }\n        }\n    }\n\n    /// @dev Permit a user to spend a given amount of\n    /// another user's tokens via native EIP-2612 permit if possible, falling\n    /// back to Permit2 if native permit fails or is not implemented on the token.\n    function permit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly {\n            for {} shl(96, xor(token, WETH9)) {} {\n                mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.\n                if iszero(\n                    and( // The arguments of `and` are evaluated from right to left.\n                        lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.\n                        // Gas stipend to limit gas burn for tokens that don't refund gas when\n                        // an non-existing function is called. 5K should be enough for a SLOAD.\n                        staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)\n                    )\n                ) { break }\n                // After here, we can be sure that token is a contract.\n                let m := mload(0x40)\n                mstore(add(m, 0x34), spender)\n                mstore(add(m, 0x20), shl(96, owner))\n                mstore(add(m, 0x74), deadline)\n                if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {\n                    mstore(0x14, owner)\n                    mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.\n                    mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))\n                    mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.\n                    // `nonces` is already at `add(m, 0x54)`.\n                    // `1` is already stored at `add(m, 0x94)`.\n                    mstore(add(m, 0xb4), and(0xff, v))\n                    mstore(add(m, 0xd4), r)\n                    mstore(add(m, 0xf4), s)\n                    success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)\n                    break\n                }\n                mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.\n                mstore(add(m, 0x54), amount)\n                mstore(add(m, 0x94), and(0xff, v))\n                mstore(add(m, 0xb4), r)\n                mstore(add(m, 0xd4), s)\n                success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)\n                break\n            }\n        }\n        if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);\n    }\n\n    /// @dev Simple permit on the Permit2 contract.\n    function simplePermit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(m, 0x927da105) // `allowance(address,address,address)`.\n            {\n                let addressMask := shr(96, not(0))\n                mstore(add(m, 0x20), and(addressMask, owner))\n                mstore(add(m, 0x40), and(addressMask, token))\n                mstore(add(m, 0x60), and(addressMask, spender))\n                mstore(add(m, 0xc0), and(addressMask, spender))\n            }\n            let p := mul(PERMIT2, iszero(shr(160, amount)))\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.\n                    staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)\n                )\n            ) {\n                mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(p))), 0x04)\n            }\n            mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).\n            // `owner` is already `add(m, 0x20)`.\n            // `token` is already at `add(m, 0x40)`.\n            mstore(add(m, 0x60), amount)\n            mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.\n            // `nonce` is already at `add(m, 0xa0)`.\n            // `spender` is already at `add(m, 0xc0)`.\n            mstore(add(m, 0xe0), deadline)\n            mstore(add(m, 0x100), 0x100) // `signature` offset.\n            mstore(add(m, 0x120), 0x41) // `signature` length.\n            mstore(add(m, 0x140), r)\n            mstore(add(m, 0x160), s)\n            mstore(add(m, 0x180), shl(248, v))\n            if iszero( // Revert if token does not have code, or if the call fails.\n            mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))) {\n                mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n}\n"},"src/executors/example/GenericSwapExecutor.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.25;\n\n// Libraries\nimport { ExecutorLib } from \"@executors/libraries/ExecutorLib.sol\";\nimport { ERC20UtilsLib } from \"@modules/libraries/ERC20UtilsLib.sol\";\nimport { SafeTransferLib } from \"@solady/utils/SafeTransferLib.sol\";\n\n/// @title Generic Swap Executor\n/// @notice Variant of LaitaExecutor that calls an arbitrary caller-specified target instead of a fixed Augustus\n///         address. Intended for the winning-bid submission flow where the solver selects both the target and\n///         the calldata.\n/// @dev Return data from the target is not decoded; receivedAmount / spentAmount are inferred from the\n///      executor's post-call balances. Any dust left on this contract is accepted as a gas optimisation.\ncontract GenericSwapExecutor {\n    /*//////////////////////////////////////////////////////////////\n                                STRUCTS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Executor data struct for a plain fee+output transfer (no target call).\n    /// @param token The address of the token to transfer.\n    /// @param feeRecipient The address to receive the fee.\n    /// @param feeAmount The amount of fee to be paid.\n    struct TransferData {\n        address token;\n        address feeRecipient;\n        uint256 feeAmount;\n    }\n\n    /// @notice Executor data struct for an exact-output transfer.\n    /// @param token The token to transfer.\n    /// @param feeRecipient The address to receive the residual fee.\n    /// @param outputAmount The exact amount of tokens to send to the caller.\n    /// @param isExactTransfer Discriminator, always true (shapes the encoded length).\n    struct ExactTransferData {\n        address token;\n        address feeRecipient;\n        uint256 outputAmount;\n        bool isExactTransfer;\n    }\n\n    /// @notice Executor data struct for a target-call swap.\n    /// @param isBuy Whether the swap is a BUY order.\n    /// @param srcToken Source token; approved to `target` when `shouldApprove` is true.\n    /// @param destToken Destination token (or ETH sentinel).\n    /// @param quotedAmount For sell: the baseline destToken output; surplus above it is fee-eligible. For buy:\n    ///                     the baseline srcToken refund returned to msg.sender; srcLeftover above it is\n    ///                     fee-eligible.\n    /// @param maxFeeAmount Cap on the fee. Fee-eligible surplus above the cap goes to msg.sender, so price\n    ///                     improvement over the quote reaches Delta instead of the fee recipient. Set to\n    ///                     type(uint256).max to take the whole surplus as fee.\n    /// @param feeRecipient Address receiving the fee (tx.origin when zero).\n    /// @param shouldApprove Whether to approve srcToken to target.\n    /// @param value Native ETH value to forward to the target.\n    /// @param target Arbitrary contract to call.\n    /// @param targetCalldata Calldata to execute on target.\n    struct SwapData {\n        bool isBuy;\n        address srcToken;\n        address destToken;\n        uint256 quotedAmount;\n        uint256 maxFeeAmount;\n        address feeRecipient;\n        bool shouldApprove;\n        uint256 value;\n        address target;\n        bytes targetCalldata;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                ERRORS\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Raised when the target call reverts.\n    error ExecutionFailed();\n\n    /*//////////////////////////////////////////////////////////////\n                               LIBRARIES\n    //////////////////////////////////////////////////////////////*/\n\n    using ExecutorLib for address;\n    using ERC20UtilsLib for address;\n    using SafeTransferLib for address;\n\n    /*//////////////////////////////////////////////////////////////\n                                EXECUTE\n    //////////////////////////////////////////////////////////////*/\n\n    /// @notice Entrypoint dispatched by settlement / probe modules.\n    /// @dev Dispatch is by encoded length: 0x60 → Transfer, 0x80 → ExactTransfer, else → Swap.\n    /// @param executorData Encoded struct: `TransferData`, `ExactTransferData`, or `SwapData`.\n    /// @return feeAmount The fee collected on this execution.\n    function execute(bytes calldata executorData) external returns (uint256) {\n        if (executorData.length == 0x60) {\n            return _executeTransfer(executorData);\n        }\n\n        if (executorData.length == 0x80) {\n            return _executeExactTransfer(executorData);\n        }\n\n        return _executeSwap(executorData);\n    }\n\n    function _executeTransfer(bytes calldata executorData) internal returns (uint256) {\n        TransferData memory data = abi.decode(executorData, (TransferData));\n\n        msg.sender.transferFeesAndETH(data.feeRecipient, data.token, data.feeAmount);\n\n        return data.feeAmount;\n    }\n\n    function _executeExactTransfer(bytes calldata executorData) internal returns (uint256) {\n        ExactTransferData memory data = abi.decode(executorData, (ExactTransferData));\n\n        address feeRecipient = data.feeRecipient == address(0) ? tx.origin : data.feeRecipient;\n\n        if (data.token == ExecutorLib.ETH_ADDRESS) {\n            msg.sender.safeTransferETH(data.outputAmount);\n            uint256 feeAmount = data.token.getBalance();\n            if (feeAmount > 0) {\n                feeRecipient.safeTransferETH(feeAmount);\n            }\n            return feeAmount;\n        } else {\n            data.token.safeTransfer(msg.sender, data.outputAmount);\n            uint256 remainingBalance = data.token.getBalance();\n            uint256 feeAmount = remainingBalance > 1 ? remainingBalance - 1 : 0;\n            if (feeAmount > 0) {\n                data.token.safeTransfer(feeRecipient, feeAmount);\n            }\n            return feeAmount;\n        }\n    }\n\n    function _executeSwap(bytes calldata executorData) internal returns (uint256) {\n        SwapData memory data = abi.decode(executorData, (SwapData));\n\n        if (data.shouldApprove) {\n            data.srcToken.safeApproveWithRetry(data.target, type(uint256).max);\n        }\n\n        // BUY is exact-output: settlement expects to receive *exactly* the amount the target produced\n        // on this call, not whatever happens to sit on the executor afterwards. Snapshot the dest balance\n        // pre-call so any pre-existing dust (e.g. 1-wei kept by a prior SELL) stays on the contract.\n        uint256 destBalanceBefore = data.isBuy ? data.destToken.getBalance() : 0;\n\n        (bool success,) = data.target.call{ value: data.value }(data.targetCalldata);\n        if (!success) {\n            revert ExecutionFailed();\n        }\n\n        if (data.isBuy) {\n            // srcLeftover above quotedAmount is the fee, up to maxFeeAmount; the rest is refunded to msg.sender\n            // by `transferFeesAndETH` (its remainder leg).\n            uint256 buyFeeAmount = _cappedFee(data.srcToken.getBalance(), data.quotedAmount, data.maxFeeAmount);\n            msg.sender.transferFeesAndETH(data.feeRecipient, data.srcToken, buyFeeAmount);\n\n            // Forward only the destToken / ETH delta produced by this call (pre-existing dust excluded).\n            uint256 balNow = data.destToken.getBalance();\n            uint256 destReceived = balNow > destBalanceBefore ? balNow - destBalanceBefore : 0;\n            if (destReceived > 0) {\n                if (data.destToken == ExecutorLib.ETH_ADDRESS) {\n                    msg.sender.safeTransferETH(destReceived);\n                } else {\n                    data.destToken.safeTransfer(msg.sender, destReceived);\n                }\n            }\n\n            return buyFeeAmount;\n        }\n\n        // Sell: surplus over quotedAmount is the fee, up to maxFeeAmount; the rest goes to msg.sender.\n        uint256 feeAmount = _cappedFee(data.destToken.getBalance(), data.quotedAmount, data.maxFeeAmount);\n        msg.sender.transferFeesAndETH(data.feeRecipient, data.destToken, feeAmount);\n\n        return feeAmount;\n    }\n\n    /// @dev Fee = min(max(0, amount - quotedAmount), maxFeeAmount).\n    function _cappedFee(uint256 amount, uint256 quotedAmount, uint256 maxFeeAmount) internal pure returns (uint256) {\n        uint256 surplus = amount > quotedAmount ? amount - quotedAmount : 0;\n        return surplus < maxFeeAmount ? surplus : maxFeeAmount;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                            EXTERNAL UTILS\n    //////////////////////////////////////////////////////////////*/\n\n    function encodeTransferData(TransferData calldata data) external pure returns (bytes memory) {\n        return abi.encode(data);\n    }\n\n    function encodeExactTransferData(ExactTransferData calldata data) external pure returns (bytes memory) {\n        return abi.encode(data);\n    }\n\n    function encodeSwapData(SwapData calldata data) external pure returns (bytes memory) {\n        return abi.encode(data);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                                 RECEIVE\n    //////////////////////////////////////////////////////////////*/\n\n    receive() external payable { }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"none","useLiteralContent":false},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun","remappings":["@forge-std/=lib/forge-std/src/","@interfaces/=src/interfaces/","@types/=src/types/","@libraries/=src/libraries/","@solady/=lib/solady/src/","@prb-test/=lib/prb-test/src/","@openzeppelin/=lib/openzeppelin-contracts/contracts/","@admin/=src/admin/","@executors/=src/executors/","@mocks/=test/mocks/","@factory/=src/factory/","@registry/=src/registry/","@modules/=src/modules/","@adapter/=src/adapter/","@tokens/=src/tokens/","@test/=test/","@aave-v3-core/=lib/aave-v3-core/contracts/","@create3/=lib/create3-factory/src/","@morpho/=lib/morpho-blue/src/","@uniswap-v4-core/=lib/v4-core/src/","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","aave-v3-core/=lib/aave-v3-core/","create3-factory/=lib/create3-factory/","ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","hardhat/=lib/v4-core/node_modules/hardhat/","morpho-blue/=lib/morpho-blue/","openzeppelin-contracts/=lib/openzeppelin-contracts/","prb-test/=lib/prb-test/src/","solady/=lib/solady/src/","solmate/=lib/v4-core/lib/solmate/","v4-core/=lib/v4-core/src/"]}},"stdJsonOutput":{"sources":{"src/executors/libraries/ExecutorLib.sol":{"id":3},"src/modules/libraries/ERC20UtilsLib.sol":{"id":4},"lib/solady/src/utils/SafeTransferLib.sol":{"id":1},"src/executors/example/GenericSwapExecutor.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":0}},"contracts":{"src/executors/example/GenericSwapExecutor.sol":{"GenericSwapExecutor":{"abi":[{"name":"ExecutionFailed","type":"error","inputs":[]},{"name":"encodeExactTransferData","type":"function","inputs":[{"name":"data","type":"tuple","components":[{"name":"token","type":"address","internalType":"address"},{"name":"feeRecipient","type":"address","internalType":"address"},{"name":"outputAmount","type":"uint256","internalType":"uint256"},{"name":"isExactTransfer","type":"bool","internalType":"bool"}],"internalType":"struct GenericSwapExecutor.ExactTransferData"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"encodeSwapData","type":"function","inputs":[{"name":"data","type":"tuple","components":[{"name":"isBuy","type":"bool","internalType":"bool"},{"name":"srcToken","type":"address","internalType":"address"},{"name":"destToken","type":"address","internalType":"address"},{"name":"quotedAmount","type":"uint256","internalType":"uint256"},{"name":"maxFeeAmount","type":"uint256","internalType":"uint256"},{"name":"feeRecipient","type":"address","internalType":"address"},{"name":"shouldApprove","type":"bool","internalType":"bool"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"target","type":"address","internalType":"address"},{"name":"targetCalldata","type":"bytes","internalType":"bytes"}],"internalType":"struct GenericSwapExecutor.SwapData"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"encodeTransferData","type":"function","inputs":[{"name":"data","type":"tuple","components":[{"name":"token","type":"address","internalType":"address"},{"name":"feeRecipient","type":"address","internalType":"address"},{"name":"feeAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct GenericSwapExecutor.TransferData"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"execute","type":"function","inputs":[{"name":"executorData","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.25+commit.b61c2a91\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"feeRecipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"outputAmount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isExactTransfer\",\"type\":\"bool\"}],\"internalType\":\"struct GenericSwapExecutor.ExactTransferData\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"encodeExactTransferData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isBuy\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"srcToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"quotedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxFeeAmount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"feeRecipient\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"shouldApprove\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"targetCalldata\",\"type\":\"bytes\"}],\"internalType\":\"struct GenericSwapExecutor.SwapData\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"encodeSwapData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"feeRecipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"feeAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct GenericSwapExecutor.TransferData\",\"name\":\"data\",\"type\":\"tuple\"}],\"name\":\"encodeTransferData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"executorData\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"details\":\"Return data from the target is not decoded; receivedAmount / spentAmount are inferred from the      executor's post-call balances. Any dust left on this contract is accepted as a gas optimisation.\",\"kind\":\"dev\",\"methods\":{\"execute(bytes)\":{\"details\":\"Dispatch is by encoded length: 0x60 → Transfer, 0x80 → ExactTransfer, else → Swap.\",\"params\":{\"executorData\":\"Encoded struct: `TransferData`, `ExactTransferData`, or `SwapData`.\"},\"returns\":{\"_0\":\"feeAmount The fee collected on this execution.\"}}},\"title\":\"Generic Swap Executor\",\"version\":1},\"userdoc\":{\"errors\":{\"ExecutionFailed()\":[{\"notice\":\"Raised when the target call reverts.\"}]},\"kind\":\"user\",\"methods\":{\"execute(bytes)\":{\"notice\":\"Entrypoint dispatched by settlement / probe modules.\"}},\"notice\":\"Variant of LaitaExecutor that calls an arbitrary caller-specified target instead of a fixed Augustus         address. Intended for the winning-bid submission flow where the solver selects both the target and         the calldata.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/executors/example/GenericSwapExecutor.sol\":\"GenericSwapExecutor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[\":@aave-v3-core/=lib/aave-v3-core/contracts/\",\":@adapter/=src/adapter/\",\":@admin/=src/admin/\",\":@create3/=lib/create3-factory/src/\",\":@ensdomains/=lib/v4-core/node_modules/@ensdomains/\",\":@executors/=src/executors/\",\":@factory/=src/factory/\",\":@forge-std/=lib/forge-std/src/\",\":@interfaces/=src/interfaces/\",\":@libraries/=src/libraries/\",\":@mocks/=test/mocks/\",\":@modules/=src/modules/\",\":@morpho/=lib/morpho-blue/src/\",\":@openzeppelin/=lib/openzeppelin-contracts/contracts/\",\":@prb-test/=lib/prb-test/src/\",\":@registry/=src/registry/\",\":@solady/=lib/solady/src/\",\":@test/=test/\",\":@tokens/=src/tokens/\",\":@types/=src/types/\",\":@uniswap-v4-core/=lib/v4-core/src/\",\":aave-v3-core/=lib/aave-v3-core/\",\":create3-factory/=lib/create3-factory/\",\":ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":hardhat/=lib/v4-core/node_modules/hardhat/\",\":morpho-blue/=lib/morpho-blue/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":prb-test/=lib/prb-test/src/\",\":solady/=lib/solady/src/\",\":solmate/=lib/v4-core/lib/solmate/\",\":v4-core/=lib/v4-core/src/\"]},\"sources\":{\"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xee2337af2dc162a973b4be6d3f7c16f06298259e0af48c5470d2839bfa8a22f4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://30c476b4b2f405c1bb3f0bae15b006d129c80f1bfd9d0f2038160a3bb9745009\",\"dweb:/ipfs/Qmb3VcuDufv6xbHeVgksC4tHpc5gKYVqBEwjEXW72XzSvN\"]},\"lib/solady/src/utils/SafeTransferLib.sol\":{\"keccak256\":\"0x7d0de1ff3be5dc32635283280b000d4794015a1b61d7dae7f3ff7b0721b07210\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e307c9eece677565e7d584ee77c56134b5db38a70f557f9d2b1b308219276c0c\",\"dweb:/ipfs/QmTEtqaTFgRBFGpJyb5o4v2w8yrSpcNThov4bNpcLr2tTR\"]},\"src/executors/example/GenericSwapExecutor.sol\":{\"keccak256\":\"0x5c1459872762b3a39ecfef922bfafbe4fc54ed8114f7c043e68aa36bbf039574\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://fe22101226cf47a108cfd65ced2646c0d496f7c672386c1f7f66ca78f756a94a\",\"dweb:/ipfs/QmT82PDu2exLdCxAJYP5LdhKX1BHjhqDNJDNn2pz68WxoR\"]},\"src/executors/libraries/ExecutorLib.sol\":{\"keccak256\":\"0xb8d78cd226b837d3165c393b32c5ecc9d3e0e31d489b6207471233d0d99fbb94\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f364fecf08f6bde288f59b3b28015e75ad1c13593de614c86046f1a2f8f7aefa\",\"dweb:/ipfs/QmV7vmkFJEDhcZaDMoETHC3zSQXLyK2AbjBfnfongWndsq\"]},\"src/modules/libraries/ERC20UtilsLib.sol\":{\"keccak256\":\"0xbaae3794d78094d9853a3db33f87fdcde45a601a96e57de819b420454e08c7bd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://14327aa2d5cb182c377e8ecb83bd4da60d2032a76fa672e1a2884a210438b7f3\",\"dweb:/ipfs/QmYicRHtGVJjkyzhHAVCSZuSFVA95NBuQasMpGUU6aNSMZ\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"ExecutionFailed()":[{"notice":"Raised when the target call reverts."}]},"notice":"Variant of LaitaExecutor that calls an arbitrary caller-specified target instead of a fixed Augustus         address. Intended for the winning-bid submission flow where the solver selects both the target and         the calldata.","methods":{"execute(bytes)":{"notice":"Entrypoint dispatched by settlement / probe modules."}},"version":1},"devdoc":{"kind":"dev","title":"Generic Swap Executor","details":"Return data from the target is not decoded; receivedAmount / spentAmount are inferred from the      executor's post-call balances. Any dust left on this contract is accepted as a gas optimisation.","methods":{"execute(bytes)":{"params":{"executorData":"Encoded struct: `TransferData`, `ExactTransferData`, or `SwapData`."},"details":"Dispatch is by encoded length: 0x60 → Transfer, 0x80 → ExactTransfer, else → Swap.","returns":{"_0":"feeAmount The fee collected on this execution."}}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"771:8503:2:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"771:8503:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8782:143;;;;;;;;;;-1:-1:-1;8782:143:2;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4353:338;;;;;;;;;;-1:-1:-1;4353:338:2;;;;;:::i;:::-;;:::i;:::-;;;1444:25:5;;;1432:2;1417:18;4353:338:2;1298:177:5;8643:133:2;;;;;;;;;;-1:-1:-1;8643:133:2;;;;;:::i;:::-;;:::i;8931:125::-;;;;;;;;;;-1:-1:-1;8931:125:2;;;;;:::i;:::-;;:::i;8782:143::-;8871:12;8913:4;8902:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;8895:23;;8782:143;;;:::o;4353:338::-;4417:7;4463:4;4440:27;;;4436:95;;4490:30;4507:12;;4490:16;:30::i;:::-;4483:37;;;;4436:95;4568:4;4545:27;;;4541:100;;4595:35;4617:12;;4595:21;:35::i;4541:100::-;4658:26;4671:12;;4658;:26::i;:::-;4651:33;;4353:338;;;;;:::o;8643:133::-;8722:12;8764:4;8753:16;;;;;;;;:::i;8931:125::-;9002:12;9044:4;9033:16;;;;;;;;:::i;4697:285::-;4770:7;;4816:40;;;;4827:12;4816:40;:::i;:::-;4897:17;;;;4916:10;;4928:14;;;;4789:67;;-1:-1:-1;4867:76:2;;:10;;4897:17;4916:10;4867:29;:76::i;:::-;4961:14;;;;4697:285;-1:-1:-1;;;4697:285:2:o;4988:965::-;5066:7;;5117:45;;;;5128:12;5117:45;:::i;:::-;5196:17;;;;5085:77;;-1:-1:-1;5173:20:2;;5196:31;;;:63;;5242:4;:17;;;5196:63;;;5230:9;5196:63;5173:86;;815:42:3;5274:37:2;;:4;:10;;;:37;;;5270:677;;5354:17;;;;5327:45;;:10;;:26;:45::i;:::-;5386:17;5406:23;:4;:10;;;:21;;;:23::i;:::-;5386:43;-1:-1:-1;5447:13:2;;5443:91;;5480:39;:28;;;5509:9;5480:28;:39::i;:::-;5554:9;-1:-1:-1;5547:16:2;;-1:-1:-1;;5547:16:2;5270:677;5630:17;;;;5594:10;;:54;;:23;;;;;5618:10;;5594:23;:54::i;:::-;5662:24;5689:23;:4;:10;;;:21;;;:23::i;:::-;5662:50;;5726:17;5765:1;5746:16;:20;:47;;5792:1;5746:47;;;5769:20;5788:1;5769:16;:20;:::i;:::-;5726:67;-1:-1:-1;5811:13:2;;5807:100;;5844:10;;:48;;:23;;5868:12;5882:9;5844:23;:48::i;:::-;5927:9;-1:-1:-1;5920:16:2;;-1:-1:-1;;;5920:16:2;5959:2161;6028:7;;6070:36;;;;6081:12;6070:36;:::i;:::-;6047:59;;6121:4;:18;;;6117:115;;;6155:66;6190:4;:11;;;6203:17;6155:4;:13;;;:34;;;;:66;;;;;:::i;:::-;6582:10;;6554:25;;6582:44;;6625:1;6582:44;;;6595:27;:4;:14;;;:25;;;:27::i;:::-;6554:72;;6638:12;6655:4;:11;;;:16;;6680:4;:10;;;6693:4;:19;;;6655:58;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6637:76;;;6728:7;6723:63;;6758:17;;;;;;;;;;;;;;6723:63;6800:10;;6796:994;;;6999:20;7022:76;7033:26;:4;:13;;;:24;;;:26::i;:::-;7061:4;:17;;;7080:4;:17;;;7022:10;:76::i;:::-;7142:17;;;;7161:13;;;;6999:99;;-1:-1:-1;7112:77:2;;:10;;7142:17;6999:99;7112:29;:77::i;:::-;7310:14;7327:27;:4;:14;;;:25;;;:27::i;:::-;7310:44;;7368:20;7400:17;7391:6;:26;:59;;7449:1;7391:59;;;7420:26;7429:17;7420:6;:26;:::i;:::-;7368:82;-1:-1:-1;7468:16:2;;7464:282;;815:42:3;7508:41:2;;:4;:14;;;:41;;;7504:228;;7573:40;:10;7600:12;7573:26;:40::i;:::-;7504:228;;;7660:14;;;;:53;;:27;;7688:10;7700:12;7660:27;:53::i;:::-;7767:12;7760:19;;;;;;;;;;6796:994;7904:17;7924:77;7935:27;:4;:14;;;:25;;;:27::i;7924:77::-;8041:17;;;;8060:14;;;;7904:97;;-1:-1:-1;8011:75:2;;:10;;8041:17;7904:97;8011:29;:75::i;:::-;8104:9;5959:2161;-1:-1:-1;;;;;;5959:2161:2:o;1388:1447:3:-;1592:26;;;;:53;;1633:12;1592:53;;;1621:9;1592:53;1577:68;-1:-1:-1;1854:23:3;;;;;1850:979;;1897:13;;1893:155;;1994:39;:28;;;2023:9;1994:28;:39::i;:::-;2156:21;2195;;2191:103;;2236:43;:25;;;2262:16;2236:25;:43::i;:::-;1879:425;1850:979;;;2328:13;;2324:186;;2449:46;:21;;;2471:12;2485:9;2449:21;:46::i;:::-;2651:41;;;;;2686:4;2651:41;;;10479:74:5;2624:24:3;;2651:26;;;;;;10452:18:5;;2651:41:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2624:68;;2729:1;2710:16;:20;2706:113;;;2750:54;2772:9;2783:20;2802:1;2783:16;:20;:::i;:::-;2750:21;;;;:54;:21;:54::i;:::-;2310:519;1850:979;1388:1447;;;;:::o;3909:342:1:-;4111:4;4099:10;4093:4;4081:10;4073:6;4069:2;4062:5;4057:59;4047:188;;4149:10;4143:4;4136:24;4216:4;4210;4203:18;4047:188;3909:342;;:::o;13042:757:4:-;13100:17;13225:11;13218:5;13215:22;13274:4;13269:40;;;;13384:4;13378:11;13447:66;13444:1;13437:77;13574:9;13567:4;13564:1;13560:12;13553:31;13674:4;13671:1;13665:4;13662:1;13655:5;13648;13637:42;13717:7;13714:35;;;13746:1;13740:8;13727:21;;13714:35;;;13208:575;;13269:40;13294:13;13281:26;;13208:575;;13042:757;;;:::o;13125:887:1:-;13288:2;13282:4;13275:16;13345:6;13339:4;13332:20;13410:34;13404:4;13397:48;13606:4;13600;13594;13588;13585:1;13578:5;13571;13566:45;13658:7;13654:1;13647:4;13641:11;13638:18;13634:32;13624:275;;13749:7;13730:16;13721:5;13709:18;13702:26;13699:48;13696:61;13686:199;;13794:10;13788:4;13781:24;13862:4;13856;13849:18;13686:199;13624:275;13925:1;13919:4;13912:15;13125:887;;;:::o;16951:1707::-;17122:2;17116:4;17109:16;17179:6;17173:4;17166:20;17244:34;17238:4;17231:48;17438:4;17432;17426;17420;17417:1;17410:5;17403;17398:45;17490:7;17486:1;17479:4;17473:11;17470:18;17466:32;17456:1089;;17581:7;17562:16;17553:5;17541:18;17534:26;17531:48;17528:61;17518:1013;;17626:1;17620:4;17613:15;17691:34;17685:4;17678:48;17828:4;17816:10;17810:4;17804;17801:1;17794:5;17787;17782:51;17778:56;17891:6;17885:4;17878:20;18074:4;18068;18062;18056;18053:1;18046:5;18039;18034:45;18023:56;;18134:7;18130:1;18123:4;18117:11;18114:18;18110:32;18100:413;;18332:7;18313:16;18304:5;18292:18;18285:26;18282:48;18279:61;18269:222;;18385:10;18379:4;18372:24;18460:4;18454;18447:18;8195:260:2;8298:7;8317:15;8344:12;8335:6;:21;:49;;8383:1;8335:49;;;8359:21;8368:12;8359:6;:21;:::i;:::-;8317:67;;8411:12;8401:7;:22;:47;;8436:12;8401:47;;;8426:7;8401:47;8394:54;8195:260;-1:-1:-1;;;;;8195:260:2:o;14:203:5:-;109:6;162:3;150:9;141:7;137:23;133:33;130:53;;;179:1;176;169:12;222:475;369:2;358:9;351:21;332:4;401:6;395:13;444:6;439:2;428:9;424:18;417:34;503:6;498:2;490:6;486:15;481:2;470:9;466:18;460:50;559:1;554:2;545:6;534:9;530:22;526:31;519:42;688:2;618:66;613:2;605:6;601:15;597:88;586:9;582:104;578:113;570:121;;;222:475;;;;:::o;702:591::-;772:6;780;833:2;821:9;812:7;808:23;804:32;801:52;;;849:1;846;839:12;801:52;889:9;876:23;918:18;959:2;951:6;948:14;945:34;;;975:1;972;965:12;945:34;1013:6;1002:9;998:22;988:32;;1058:7;1051:4;1047:2;1043:13;1039:27;1029:55;;1080:1;1077;1070:12;1029:55;1120:2;1107:16;1146:2;1138:6;1135:14;1132:34;;;1162:1;1159;1152:12;1132:34;1207:7;1202:2;1193:6;1189:2;1185:15;1181:24;1178:37;1175:57;;;1228:1;1225;1218:12;1175:57;1259:2;1251:11;;;;;1281:6;;-1:-1:-1;702:591:5;;-1:-1:-1;;;;702:591:5:o;1480:197::-;1570:6;1623:2;1611:9;1602:7;1598:23;1594:32;1591:52;;;1639:1;1636;1629:12;1682:387;1768:6;1821:2;1809:9;1800:7;1796:23;1792:32;1789:52;;;1837:1;1834;1827:12;1789:52;1877:9;1864:23;1910:18;1902:6;1899:30;1896:50;;;1942:1;1939;1932:12;1896:50;1965:22;;2021:3;2003:16;;;1999:26;1996:46;;;2038:1;2035;2028:12;1996:46;2061:2;1682:387;-1:-1:-1;;;1682:387:5:o;2074:196::-;2142:20;;2202:42;2191:54;;2181:65;;2171:93;;2260:1;2257;2250:12;2171:93;2074:196;;;:::o;2407:160::-;2472:20;;2528:13;;2521:21;2511:32;;2501:60;;2557:1;2554;2547:12;2668:582;2872:3;2857:19;;2895:42;;2968:26;2987:6;2968:26;:::i;:::-;2964:35;2953:9;2946:54;3081:2;3042:37;3073:4;3065:6;3061:17;3042:37;:::i;:::-;3038:46;3031:4;3020:9;3016:20;3009:76;;3148:4;3140:6;3136:17;3123:31;3116:4;3105:9;3101:20;3094:61;3207:34;3235:4;3227:6;3223:17;3207:34;:::i;:::-;3200:42;3193:50;3186:4;3175:9;3171:20;3164:80;2668:582;;;;:::o;3255:482::-;3449:2;3434:18;;3471:42;;3544:26;3563:6;3544:26;:::i;:::-;3540:35;3529:9;3522:54;3657:2;3618:37;3649:4;3641:6;3637:17;3618:37;:::i;:::-;3614:46;3607:4;3596:9;3592:20;3585:76;;3724:4;3716:6;3712:17;3699:31;3692:4;3681:9;3677:20;3670:61;3255:482;;;;:::o;3742:559::-;3800:5;3807:6;3867:3;3854:17;3949:66;3938:8;3922:14;3918:29;3914:102;3894:18;3890:127;3880:155;;4031:1;4028;4021:12;3880:155;4059:33;;4163:4;4150:18;;;-1:-1:-1;4111:21:5;;-1:-1:-1;4191:18:5;4180:30;;4177:50;;;4223:1;4220;4213:12;4177:50;4270:6;4254:14;4250:27;4243:5;4239:39;4236:59;;;4291:1;4288;4281:12;4236:59;3742:559;;;;;:::o;4306:325::-;4394:6;4389:3;4382:19;4446:6;4439:5;4432:4;4427:3;4423:14;4410:43;;4498:1;4491:4;4482:6;4477:3;4473:16;4469:27;4462:38;4364:3;4620:4;4550:66;4545:2;4537:6;4533:15;4529:88;4524:3;4520:98;4516:109;4509:116;;4306:325;;;;:::o;4636:1401::-;4817:2;4806:9;4799:21;4829:60;4885:2;4874:9;4870:18;4845:23;4861:6;4845:23;:::i;:::-;2642:13;2635:21;2623:34;;2572:91;4829:60;4780:4;4918:35;4949:2;4941:6;4937:15;4918:35;:::i;:::-;2352:42;2341:54;;5010:2;4995:18;;2329:67;4962:52;5045:35;5076:2;5068:6;5064:15;5045:35;:::i;:::-;2352:42;2341:54;;5139:2;5124:18;;2329:67;5089:54;5205:2;5197:6;5193:15;5180:29;5174:3;5163:9;5159:19;5152:58;5272:3;5264:6;5260:16;5247:30;5241:3;5230:9;5226:19;5219:59;5309:36;5340:3;5332:6;5328:16;5309:36;:::i;:::-;2352:42;2341:54;;5404:3;5389:19;;2329:67;5354:55;5440:33;5468:3;5460:6;5456:16;5440:33;:::i;:::-;2642:13;;2635:21;5529:3;5514:19;;2623:34;5482:52;5553:3;5617;5609:6;5605:16;5592:30;5587:2;5576:9;5572:18;5565:58;5654:35;5685:2;5677:6;5673:15;5654:35;:::i;:::-;5632:57;;5708:3;5720:54;5770:2;5759:9;5755:18;5739:14;2352:42;2341:54;2329:67;;2275:127;5720:54;5819:55;5870:2;5862:6;5858:15;5850:6;5819:55;:::i;:::-;5893:6;5915:18;;;5908:30;5783:91;-1:-1:-1;5783:91:5;-1:-1:-1;5955:76:5;6026:3;6011:19;;5783:91;;5955:76;:::i;6042:184::-;6094:77;6091:1;6084:88;6191:4;6188:1;6181:15;6215:4;6212:1;6205:15;6231:250;6298:2;6292:9;6340:6;6328:19;;6377:18;6362:34;;6398:22;;;6359:62;6356:88;;;6424:18;;:::i;:::-;6460:2;6453:22;6231:250;:::o;6486:586::-;6574:6;6627:2;6615:9;6606:7;6602:23;6598:32;6595:52;;;6643:1;6640;6633:12;6595:52;6676:2;6670:9;6718:2;6710:6;6706:15;6787:6;6775:10;6772:22;6751:18;6739:10;6736:34;6733:62;6730:88;;;6798:18;;:::i;:::-;6834:2;6827:22;6873:29;6892:9;6873:29;:::i;:::-;6865:6;6858:45;6936:38;6970:2;6959:9;6955:18;6936:38;:::i;:::-;6931:2;6923:6;6919:15;6912:63;7036:2;7025:9;7021:18;7008:32;7003:2;6995:6;6991:15;6984:57;7060:6;7050:16;;;6486:586;;;;:::o;7077:662::-;7170:6;7223:3;7211:9;7202:7;7198:23;7194:33;7191:53;;;7240:1;7237;7230:12;7191:53;7273:2;7267:9;7315:3;7307:6;7303:16;7385:6;7373:10;7370:22;7349:18;7337:10;7334:34;7331:62;7328:88;;;7396:18;;:::i;:::-;7432:2;7425:22;7471:29;7490:9;7471:29;:::i;:::-;7463:6;7456:45;7534:38;7568:2;7557:9;7553:18;7534:38;:::i;:::-;7529:2;7521:6;7517:15;7510:63;7634:2;7623:9;7619:18;7606:32;7601:2;7593:6;7589:15;7582:57;7672:35;7703:2;7692:9;7688:18;7672:35;:::i;:::-;7667:2;7655:15;;7648:60;7659:6;7077:662;-1:-1:-1;;;7077:662:5:o;7744:282::-;7811:9;;;7832:11;;;7829:191;;;7876:77;7873:1;7866:88;7977:4;7974:1;7967:15;8005:4;8002:1;7995:15;8031:777;8073:5;8126:3;8119:4;8111:6;8107:17;8103:27;8093:55;;8144:1;8141;8134:12;8093:55;8180:6;8167:20;8206:18;8243:2;8239;8236:10;8233:36;;;8249:18;;:::i;:::-;8383:2;8377:9;8445:4;8437:13;;8288:66;8433:22;;;8457:2;8429:31;8425:40;8413:53;;;8481:18;;;8501:22;;;8478:46;8475:72;;;8527:18;;:::i;:::-;8567:10;8563:2;8556:22;8602:2;8594:6;8587:18;8648:3;8641:4;8636:2;8628:6;8624:15;8620:26;8617:35;8614:55;;;8665:1;8662;8655:12;8614:55;8729:2;8722:4;8714:6;8710:17;8703:4;8695:6;8691:17;8678:54;8776:1;8769:4;8764:2;8756:6;8752:15;8748:26;8741:37;8796:6;8787:15;;;;;;8031:777;;;;:::o;8813:1209::-;8897:6;8950:2;8938:9;8929:7;8925:23;8921:32;8918:52;;;8966:1;8963;8956:12;8918:52;9006:9;8993:23;9035:18;9076:2;9068:6;9065:14;9062:34;;;9092:1;9089;9082:12;9062:34;9115:22;;;;9171:6;9153:16;;;9149:29;9146:49;;;9191:1;9188;9181:12;9146:49;9217:17;;:::i;:::-;9257:19;9273:2;9257:19;:::i;:::-;9250:5;9243:34;9309:31;9336:2;9332;9328:11;9309:31;:::i;:::-;9304:2;9297:5;9293:14;9286:55;9373:31;9400:2;9396;9392:11;9373:31;:::i;:::-;9368:2;9361:5;9357:14;9350:55;9458:2;9454;9450:11;9437:25;9432:2;9425:5;9421:14;9414:49;9517:3;9513:2;9509:12;9496:26;9490:3;9483:5;9479:15;9472:51;9556:32;9583:3;9579:2;9575:12;9556:32;:::i;:::-;9550:3;9543:5;9539:15;9532:57;9622:29;9646:3;9642:2;9638:12;9622:29;:::i;:::-;9616:3;9609:5;9605:15;9598:54;9706:3;9702:2;9698:12;9685:26;9679:3;9672:5;9668:15;9661:51;9731:3;9766:31;9793:2;9789;9785:11;9766:31;:::i;:::-;9750:14;;;9743:55;9817:3;9858:11;;;9845:25;9882:16;;;9879:36;;;9911:1;9908;9901:12;9879:36;9947:44;9983:7;9972:8;9968:2;9964:17;9947:44;:::i;:::-;9931:14;;;9924:68;;;;-1:-1:-1;9935:5:5;8813:1209;-1:-1:-1;;;;;8813:1209:5:o;10027:301::-;10156:3;10194:6;10188:13;10240:6;10233:4;10225:6;10221:17;10216:3;10210:37;10302:1;10266:16;;10291:13;;;-1:-1:-1;10266:16:5;10027:301;-1:-1:-1;10027:301:5:o;10564:184::-;10634:6;10687:2;10675:9;10666:7;10662:23;10658:32;10655:52;;;10703:1;10700;10693:12;10655:52;-1:-1:-1;10726:16:5;;10564:184;-1:-1:-1;10564:184:5:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"encodeExactTransferData((address,address,uint256,bool))","signatureHash4":"0x027d9b32","signatureHash32":"0x027d9b32040718abc7c45d88eca72aff7298667513b10f21ccf06e67b1fec312"},{"signature":"encodeSwapData((bool,address,address,uint256,uint256,address,bool,uint256,address,bytes))","signatureHash4":"0x6bedfe93","signatureHash32":"0x6bedfe93cee06c67ccb4ad84dc54085ae56a9b9c5a8e8544845dbf879121e82e"},{"signature":"encodeTransferData((address,address,uint256))","signatureHash4":"0x56db50bb","signatureHash32":"0x56db50bbc022b29649b93e3a80d13e6eb856aaa72f32347dc78c3271b467e612"},{"signature":"execute(bytes)","signatureHash4":"0x09c5eabe","signatureHash32":"0x09c5eabe8d7d17edb2a5ee22b8241b3c45db7f41e72a7ae433139a0e48dc3584"}],"event":[],"error":[{"signature":"ExecutionFailed()","signatureHash4":"0xacfdb444","signatureHash32":"0xacfdb444727b3b8994850a379f4bfc8a5ca665a55604339199daafa16f687b1a"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0xF99f08F69F45541222429AeC99315630639Bd81b"}