{"matchId":"32114615","creationMatch":null,"runtimeMatch":"match","verifiedAt":"2026-06-11T12:20:25Z","creationBytecode":{"onchainBytecode":null,"recompiledBytecode":"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","sourceMap":"1298:26723:29:-:0;;;8684:53;;;;;;;;;-1:-1:-1;3428:431:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;3428:431:21;;;;;3501:45;3428:431;-1:-1:-1;3501:30:21;:45::i;:::-;3493:53;;3567:51;:7;3601:16;3567:33;:51::i;:::-;3556:62;;3642:22;;;;;;;;;;3628:36;;3691:25;;;;;;3674:42;;3744:13;3727:30;;3792:23;4326:11;;4339:14;;4304:80;;;2079:95;4304:80;;;2914:25:30;2955:18;;;2948:34;;;;2998:18;;;2991:34;4355:13:21;3041:18:30;;;3034:34;4378:4:21;3084:19:30;;;3077:61;4268:7:21;;2886:19:30;;4304:80:21;;;;;;;;;;;;4294:91;;;;;;4287:98;;4213:179;;3792:23;3767:48;;-1:-1:-1;;3847:4:21;3825:27;;1298:26723:29;;2893:342:16;2989:11;3038:4;3022:5;3016:19;:26;3012:217;;;3065:20;3079:5;3065:13;:20::i;:::-;3058:27;;;;3012:217;3142:5;3116:46;3157:5;3142;3116:46;:::i;:::-;-1:-1:-1;1390:66:16;;-1:-1:-1;3012:217:16;2893:342;;;;:::o;1708:288::-;1773:11;1796:17;1822:3;1796:30;;1854:4;1840;:11;:18;1836:74;;;1895:3;1881:18;;-1:-1:-1;;;1881:18:16;;;;;;;;:::i;:::-;;;;;;;;1836:74;1976:11;;1959:13;1976:4;1959:13;:::i;:::-;1951:36;;1708:288;-1:-1:-1;;;1708:288:16:o;14:127:30:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:380;225:1;221:12;;;;268;;;289:61;;343:4;335:6;331:17;321:27;;289:61;396:2;388:6;385:14;365:18;362:38;359:161;;442:10;437:3;433:20;430:1;423:31;477:4;474:1;467:15;505:4;502:1;495:15;359:161;;146:380;;;:::o;657:518::-;759:2;754:3;751:11;748:421;;;795:5;792:1;785:16;839:4;836:1;826:18;909:2;897:10;893:19;890:1;886:27;880:4;876:38;945:4;933:10;930:20;927:47;;;-1:-1:-1;968:4:30;927:47;1023:2;1018:3;1014:12;1011:1;1007:20;1001:4;997:31;987:41;;1078:81;1096:2;1089:5;1086:13;1078:81;;;1155:1;1141:16;;1122:1;1111:13;1078:81;;;1082:3;;748:421;657:518;;;:::o;1351:1299::-;1471:10;;-1:-1:-1;;;;;1493:30:30;;1490:56;;;1526:18;;:::i;:::-;1555:97;1645:6;1605:38;1637:4;1631:11;1605:38;:::i;:::-;1599:4;1555:97;:::i;:::-;1701:4;1732:2;1721:14;;1749:1;1744:649;;;;2437:1;2454:6;2451:89;;;-1:-1:-1;2506:19:30;;;2500:26;2451:89;-1:-1:-1;;1308:1:30;1304:11;;;1300:24;1296:29;1286:40;1332:1;1328:11;;;1283:57;2553:81;;1714:930;;1744:649;604:1;597:14;;;641:4;628:18;;-1:-1:-1;;1780:20:30;;;1898:222;1912:7;1909:1;1906:14;1898:222;;;1994:19;;;1988:26;1973:42;;2101:4;2086:20;;;;2054:1;2042:14;;;;1928:12;1898:222;;;1902:3;2148:6;2139:7;2136:19;2133:201;;;2209:19;;;2203:26;-1:-1:-1;;2292:1:30;2288:14;;;2304:3;2284:24;2280:37;2276:42;2261:58;2246:74;;2133:201;-1:-1:-1;;;;2380:1:30;2364:14;;;2360:22;2347:36;;-1:-1:-1;1351:1299:30:o;3149:418::-;3298:2;3287:9;3280:21;3261:4;3330:6;3324:13;3373:6;3368:2;3357:9;3353:18;3346:34;3432:6;3427:2;3419:6;3415:15;3410:2;3399:9;3395:18;3389:50;3488:1;3483:2;3474:6;3463:9;3459:22;3455:31;3448:42;3558:2;3551;3547:7;3542:2;3534:6;3530:15;3526:29;3515:9;3511:45;3507:54;3499:62;;;3149:418;;;;:::o;3572:297::-;3690:12;;3737:4;3726:16;;;3720:23;;3690:12;3755:16;;3752:111;;;-1:-1:-1;;3829:4:30;3825:17;;;;3822:1;3818:25;3814:38;3803:50;;3572:297;-1:-1:-1;3572:297:30:o;:::-;1298:26723:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{},"transformations":null,"transformationValues":null},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1298:26723:29:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9502:1547;;;;;;:::i;:::-;;:::i;:::-;;4221:109;;4263:67;4221:109;;;;;1754:25:30;;;1742:2;1727:18;4221:109:29;;;;;;;;3615:51;;3659:7;3615:51;;;;;2065:12:30;2053:25;;;2035:44;;2023:2;2008:18;3615:51:29;1891:194:30;5822:85:29;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5822:85:29;;;;-1:-1:-1;;;5822:85:29;;;;;;;;;-1:-1:-1;;;;;2547:47:30;;;2529:66;;2631:47;;;;2626:2;2611:18;;2604:75;2502:18;5822:85:29;2355:330:30;11894:466:29;;;;;;:::i;:::-;;:::i;23485:953::-;;;;;;:::i;:::-;;:::i;4709:182::-;;4756:135;4709:182;;21268:193;;;;;;:::i;:::-;;:::i;5076:58::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;5076:58:29;;;;-1:-1:-1;;;5076:58:29;;;;;5228:557:21;;;:::i;:::-;;;;;;;;;;;;;:::i;21775:215:29:-;;;;;;:::i;:::-;;:::i;3877:221::-;;3927:171;3877:221;;4105:109;;4148:66;4105:109;;14100:393;;;;;;:::i;:::-;;:::i;1224:482:13:-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3555:54:29:-;;3599:10;3555:54;;20032:600;;;;;;:::i;:::-;;:::i;5745:71::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;5745:71:29;;;-1:-1:-1;;;5745:71:29;;;;;;;;;;-1:-1:-1;;;;;8100:47:30;;;8082:66;;8196:12;8184:25;;;8179:2;8164:18;;8157:53;8055:18;5745:71:29;7910:306:30;4465:145:29;;4520:90;4465:145;;15471:884;;;;;;:::i;:::-;;:::i;18944:238::-;;;;;;:::i;:::-;;:::i;22616:211::-;;;;;;:::i;:::-;;:::i;12985:773::-;;;;;;:::i;:::-;;:::i;16884:1170::-;;;;;;:::i;:::-;;:::i;5683:56::-;;;;;;:::i;:::-;;;;;;;;;;;;;;9502:1547;1239:21:15;:19;:21::i;:::-;9713:1:29::1;9689:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;9689:26:29::1;::::0;9685:55:::1;;9724:16;;-1:-1:-1::0;;;9724:16:29::1;;;;;;;;;;;9685:55;9781:1;9754:15;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;9754:29:29::1;::::0;9750:58:::1;;9792:16;;-1:-1:-1::0;;;9792:16:29::1;;;;;;;;;;;9750:58;9859:1;9822:25;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;9822:39:29::1;::::0;9818:68:::1;;9870:16;;-1:-1:-1::0;;;9870:16:29::1;;;;;;;;;;;9818:68;9924:1;9900:12;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;9900:26:29::1;::::0;9896:55:::1;;9935:16;;-1:-1:-1::0;;;9935:16:29::1;;;;;;;;;;;9896:55;3599:10;9965:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;:41;;;:86;;;-1:-1:-1::0;3659:7:29::1;10010:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;:41;;;9965:86;9961:149;;;10074:25;;-1:-1:-1::0;;;10074:25:29::1;;;;;;;;;;;9961:149;10123:6;-1:-1:-1::0;;;;;10123:11:29::1;10133:1;10123:11:::0;10119:37:::1;;10143:13;;-1:-1:-1::0;;;10143:13:29::1;;;;;;;;;;;10119:37;-1:-1:-1::0;;;;;10170:23:29;::::1;10166:54;;10202:18;;-1:-1:-1::0;;;10202:18:29::1;;;;;;;;;;;10166:54;10231:17;10251:20;10264:6;10251:12;:20::i;:::-;10281:23;10307:19:::0;;;:8:::1;:19;::::0;;;;10370:10;;10231:40;;-1:-1:-1;10307:19:29;10350:30:::1;::::0;-1:-1:-1;;;;;10370:10:29;;::::1;::::0;10350:30:::1;:::i;:::-;-1:-1:-1::0;;;;;10341:39:29::1;:6;-1:-1:-1::0;;;;;10341:39:29::1;;10337:69;;;10389:17;;-1:-1:-1::0;;;10389:17:29::1;;;;;;;;;;;10337:69;10416:20:::0;;10430:6;;10416:2;;:10:::1;::::0;:20:::1;::::0;10430:6;;-1:-1:-1;;;;;10416:20:29::1;;:::i;:::-;;;;;;;;-1:-1:-1::0;;;;;10416:20:29::1;;;;;-1:-1:-1::0;;;;;10416:20:29::1;;;;;;10447:17;10474:6;:12;;;;;;;;;;:::i;:::-;10467:45;::::0;-1:-1:-1;;;10467:45:29;;10506:4:::1;10467:45;::::0;::::1;11278:51:30::0;-1:-1:-1;;;;;10467:30:29;;;::::1;::::0;::::1;::::0;11251:18:30;;10467:45:29::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10447:65:::0;-1:-1:-1;;;;;;10522:36:29;::::1;;10559:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;10573;::::0;;;::::1;::::0;::::1;;:::i;:::-;10587:6;10595:9;10606:13;;10522:98;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;10630:16:29::1;::::0;-1:-1:-1;10656:12:29::1;::::0;-1:-1:-1;;10656:12:29;;;::::1;::::0;::::1;;:::i;:::-;10649:45;::::0;-1:-1:-1;;;10649:45:29;;10688:4:::1;10649:45;::::0;::::1;11278:51:30::0;-1:-1:-1;;;;;10649:30:29;;;::::1;::::0;::::1;::::0;11251:18:30;;10649:45:29::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10630:64:::0;-1:-1:-1;10720:18:29::1;-1:-1:-1::0;;;;;10720:18:29;::::1;:9:::0;:18:::1;:::i;:::-;10708:8;:30;10704:68;;10747:25;;-1:-1:-1::0;;;10747:25:29::1;;;;;;;;;;;10704:68;10867:10:::0;;-1:-1:-1;;;;;10867:20:29;;::::1;:10:::0;::::1;:20;:44:::0;::::1;;;-1:-1:-1::0;10891:15:29;;-1:-1:-1;;;10891:15:29;::::1;-1:-1:-1::0;;;;;10891:15:29::1;:20:::0;10867:44:::1;10863:113;;;10947:9;10932:33;10958:6;10932:33;;;;;;:::i;:::-;;;;;;;;10863:113;11031:10:::0;;10990:52:::1;::::0;;-1:-1:-1;;;;;2547:47:30;;;2529:66;;11031:10:29;;::::1;2626:2:30::0;2611:18;;2604:75;11011:10:29::1;::::0;11000:9;;10990:52:::1;::::0;2502:18:30;10990:52:29::1;;;;;;;9675:1374;;;;1281:20:15::0;:18;:20::i;:::-;9502:1547:29;;;;;:::o;11894:466::-;1239:21:15;:19;:21::i;:::-;12022:1:29::1;11998:25:::0;;;11994:50:::1;;12032:12;;-1:-1:-1::0;;;12032:12:29::1;;;;;;;;;;;11994:50;12060:9;12055:299;12075:24:::0;;::::1;12055:299;;;12120:24;12147:13;;12161:1;12147:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:24:::0;-1:-1:-1;12198:30:29::1;12214:10;12147:24:::0;12198:15:::1;:30::i;:::-;12193:99;;12255:22;;-1:-1:-1::0;;;12255:22:29::1;;;;;;;;;;;12193:99;12305:38;12326:13;;12340:1;12326:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;12305:20;:38::i;:::-;-1:-1:-1::0;12101:3:29::1;;12055:299;;;;1281:20:15::0;:18;:20::i;:::-;11894:466:29;;:::o;23485:953::-;23588:7;23619:13;23588:7;23682:6;;;23678:663;;-1:-1:-1;23718:13:29;23678:663;;;23762:28;23807:1;23793:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23793:16:29;-1:-1:-1;23762:47:29;-1:-1:-1;23828:9:29;23823:440;23847:1;23843;:5;23823:440;;;23873:11;23887:46;23900:13;;23914:1;23900:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;23887:46::-;23873:60;;4520:90;24081:3;24110:13;;24124:1;24110:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:43;;;;;;;;;:::i;:::-;24179:13;;24193:1;24179:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:29;;;;;;;;;:::i;:::-;23999:231;;;;;;14503:25:30;;;;14544:18;;14537:34;;;;-1:-1:-1;;;;;14607:47:30;;;14587:18;;;14580:75;14691:47;14671:18;;;14664:75;14475:19;;23999:231:29;;;;;;;;;;;;23968:280;;;;;;23951:11;23963:1;23951:14;;;;;;;;:::i;:::-;;;;;;;;;;:297;-1:-1:-1;23850:3:29;;23823:440;;;;24317:11;24300:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;24290:40;;;;;;24276:54;;23748:593;23678:663;24384:45;;;4756:135;24384:45;;;15455:25:30;15496:18;;;15489:34;;;24357:74:29;;15428:18:30;;24384:45:29;;;;;;;;;;;;;24374:56;;;;;;24357:16;:74::i;:::-;24350:81;;;;23485:953;;;;;:::o;21268:193::-;21356:7;21382:72;3927:171;21445:6;21409:43;;;;;;;;;:::i;5228:557:21:-;5326:13;5353:18;5385:21;5420:15;5449:25;5488:12;5514:27;5617:13;:11;:13::i;:::-;5644:16;:14;:16::i;:::-;5752;;;5736:1;5752:16;;;;;;;;;-1:-1:-1;;;5566:212:21;;;-1:-1:-1;5566:212:21;;-1:-1:-1;5674:13:21;;-1:-1:-1;5709:4:21;;-1:-1:-1;5736:1:21;-1:-1:-1;5752:16:21;-1:-1:-1;5566:212:21;-1:-1:-1;5228:557:21:o;21775:215:29:-;21922:59;;;4148:66;21922:59;;;16088:25:30;16129:18;;;16122:34;;;-1:-1:-1;;;;;16192:47:30;;16172:18;;;16165:75;21869:7:29;;21895:88;;16061:18:30;;21922:59:29;15886:360:30;21895:88:29;21888:95;21775:215;-1:-1:-1;;;21775:215:29:o;14100:393::-;1239:21:15;:19;:21::i;:::-;-1:-1:-1;;;;;14208:19:29;;::::1;14181:24;14208:19:::0;;;:9:::1;:19;::::0;;;;;;;:26;;::::1;::::0;;;;;;;;14279:15;;14208:26;;14181:24;14261:33:::1;::::0;-1:-1:-1;;;;;;;;14279:15:29;::::1;::::0;::::1;::::0;14261::::1;:33;:::i;:::-;14244:50;;14308:6;-1:-1:-1::0;;;;;14308:11:29::1;14318:1;14308:11:::0;14304:24:::1;;14321:7;;;;14304:24;14356:15:::0;;-1:-1:-1;;;;;14356:15:29;;::::1;-1:-1:-1::0;;;14338:33:29;::::1;;::::0;;14382:44:::1;::::0;-1:-1:-1;;;;;14382:26:29;::::1;::::0;14409:8;;14382:44;::::1;:26;:44::i;:::-;14442;::::0;-1:-1:-1;;;;;16415:47:30;;16397:66;;14467:10:29::1;::::0;-1:-1:-1;;;;;14442:44:29;;::::1;::::0;;;::::1;::::0;::::1;::::0;16385:2:30;16370:18;14442:44:29::1;;;;;;;14171:322;;1270:1:15;1281:20:::0;:18;:20::i;1224:482:13:-;1388:12;;;1324:20;1388:12;;;;;;;;1290:22;;1499:4;1487:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1477:34:13;-1:-1:-1;1526:9:13;1521:155;1541:15;;;1521:155;;;1590:75;1627:4;1647;;1652:1;1647:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;1656;1634:30;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1590:28;:75::i;:::-;1577:7;1585:1;1577:10;;;;;;;;:::i;:::-;;;;;;;;;;:88;1558:3;;1521:155;;;;1685:14;1224:482;;;;:::o;20032:600:29:-;1239:21:15;:19;:21::i;:::-;20237:17:29::1;20257:20;20270:6;20257:12;:20::i;:::-;20300:22;::::0;;;:11:::1;:22;::::0;;;;;20237:40;;-1:-1:-1;20291:31:29;::::1;20287:64;;20331:20;;-1:-1:-1::0;;;20331:20:29::1;;;;;;;;;;;20287:64;20361:14;20378:41;20394:9;20405:5;20412:6;20378:15;:41::i;:::-;20361:58:::0;-1:-1:-1;20434:100:29::1;20471:25;::::0;;;::::1;::::0;::::1;;:::i;:::-;20498:6;20506:27;;20434:100;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;20434:36:29::1;::::0;-1:-1:-1;;;20434:100:29:i:1;:::-;20429:157;;20557:18;;-1:-1:-1::0;;;20557:18:29::1;;;;;;;;;;;20429:157;20595:30;20610:6;20618;20595:14;:30::i;:::-;20227:405;;1281:20:15::0;:18;:20::i;15471:884:29:-;1239:21:15;:19;:21::i;:::-;15594:12:29::1;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;15580:26:29::1;:10;-1:-1:-1::0;;;;;15580:26:29::1;;;:66;;;;-1:-1:-1::0;15624:22:29::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;15610:36:29::1;:10;-1:-1:-1::0;;;;;15610:36:29::1;;;15580:66;15576:120;;;15669:16;;-1:-1:-1::0;;;15669:16:29::1;;;;;;;;;;;15576:120;15709:6;-1:-1:-1::0;;;;;15709:11:29::1;15719:1;15709:11:::0;15705:43:::1;;15729:19;;-1:-1:-1::0;;;15729:19:29::1;;;;;;;;;;;15705:43;15759:17;15779:20;15792:6;15779:12;:20::i;:::-;15810:26;15839:29:::0;;;:18:::1;:29;::::0;;;;15882:14;;15839:29;;-1:-1:-1;15839:29:29;-1:-1:-1;;;15882:14:29;::::1;;;:19:::0;15878:58:::1;;15910:26;;-1:-1:-1::0;;;15910:26:29::1;;;;;;;;;;;15878:58;15947:23;15973:19:::0;;;:8:::1;:19;::::0;;;;16035:15;;15973:19;;15947:23;16022:28:::1;::::0;-1:-1:-1;;;;;;;;16035:15:29;::::1;::::0;::::1;::::0;16022:10:::1;:28;:::i;:::-;16002:48;;16073:9;-1:-1:-1::0;;;;;16064:18:29::1;:6;-1:-1:-1::0;;;;;16064:18:29::1;;16060:63;;;16091:32;;-1:-1:-1::0;;;16091:32:29::1;;;;;;;;;;;16060:63;16134:18:::0;;16162:40:::1;16186:15;16162:40;-1:-1:-1::0;;;16162:40:29::1;-1:-1:-1::0;;;;;;16162:40:29;;;-1:-1:-1;;;;;16134:18:29;::::1;16162:40:::0;::::1;::::0;;16134:9:::1;16262:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;16236:46;::::0;16243:15:::1;16236:46;:::i;:::-;16297:51;::::0;;-1:-1:-1;;;;;8100:47:30;;8082:66;;8196:12;8184:25;;8179:2;8164:18;;8157:53;16213:69:29;;-1:-1:-1;16315:9:29;;16297:51:::1;::::0;8055:18:30;16297:51:29::1;;;;;;;15566:789;;;;;1281:20:15::0;:18;:20::i;18944:238:29:-;1239:21:15;:19;:21::i;:::-;19044:35:29::1;19060:10;19072:6;19044:15;:35::i;:::-;19039:97;;19102:23;;-1:-1:-1::0;;;19102:23:29::1;;;;;;;;;;;19039:97;19145:30;19160:6;19168;19145:14;:30::i;22616:211::-:0;22765:53;;;4263:67;22765:53;;;18337:25:30;18378:18;;;18371:34;;;18421:18;;;18414:34;;;-1:-1:-1;;;;;18484:47:30;;18464:18;;;18457:75;22712:7:29;;22738:82;;18309:19:30;;22765:53:29;18106:432:30;22738:82:29;22731:89;22616:211;-1:-1:-1;;;;22616:211:29:o;12985:773::-;1239:21:15;:19;:21::i;:::-;13170:1:29::1;13146:25:::0;;;13142:50:::1;;13180:12;;-1:-1:-1::0;;;13180:12:29::1;;;;;;;;;;;13142:50;13203:18;13224:13;;13238:1;13224:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:51;::::0;;;;;::::1;;;:::i;:::-;13203:72;;13286:14;13303:34;13323:13;;13303:19;:34::i;:::-;13286:51;;13352:77;13389:10;13401:6;13409:19;;13352:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;13352:36:29::1;::::0;-1:-1:-1;;;13352:77:29:i:1;:::-;13347:134;;13452:18;;-1:-1:-1::0;;;13452:18:29::1;;;;;;;;;;;13347:134;13496:9;13491:261;13511:24:::0;;::::1;13491:261;;;13615:10;-1:-1:-1::0;;;;;13560:65:29::1;:13;;13574:1;13560:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:51;::::0;;;;;::::1;;;:::i;:::-;-1:-1:-1::0;;;;;13560:65:29::1;;13556:134;;13652:23;;-1:-1:-1::0;;;13652:23:29::1;;;;;;;;;;;13556:134;13703:38;13724:13;;13738:1;13724:16;;;;;;;:::i;13703:38::-;13537:3;;13491:261;;;;13132:626;;1281:20:15::0;:18;:20::i;:::-;12985:773:29;;;;:::o;16884:1170::-;1239:21:15;:19;:21::i;:::-;17005:12:29::1;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;16991:26:29::1;:10;-1:-1:-1::0;;;;;16991:26:29::1;;;:66;;;;-1:-1:-1::0;17035:22:29::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;17021:36:29::1;:10;-1:-1:-1::0;;;;;17021:36:29::1;;;16991:66;16987:137;;;17080:33;;-1:-1:-1::0;;;17080:33:29::1;;;;;;;;;;;16987:137;17134:17;17154:20;17167:6;17154:12;:20::i;:::-;17184:26;17213:29:::0;;;:18:::1;:29;::::0;;;;17257:14;;17213:29;;-1:-1:-1;17213:29:29;-1:-1:-1;;;17257:14:29;::::1;;;:19:::0;;17253:54:::1;;17285:22;;-1:-1:-1::0;;;17285:22:29::1;;;;;;;;;;;17253:54;17373:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;17347:14:::0;;17339:55:::1;::::0;17365:29:::1;::::0;;::::1;::::0;-1:-1:-1;;;17347:14:29;::::1;;17339:55;:::i;:::-;17321:15;:73;17317:136;;;17417:25;;-1:-1:-1::0;;;17417:25:29::1;;;;;;;;;;;17317:136;17463:23;17489:19:::0;;;:8:::1;:19;::::0;;;;17551:15;;17489:19;;17463:23;17538:28:::1;::::0;-1:-1:-1;;;;;;;;17551:15:29;::::1;::::0;::::1;::::0;17538:10:::1;:28;:::i;:::-;17601:9:::0;;17518:48;;-1:-1:-1;17576:22:29::1;::::0;-1:-1:-1;;;;;17601:21:29;;::::1;:9:::0;::::1;:21;:45;;17637:9:::0;;-1:-1:-1;;;;;17637:9:29::1;17601:45;;;17625:9;17601:45;17657:13:::0;;-1:-1:-1;;;;;;17680:18:29;;;17708:28;;17576:70;;-1:-1:-1;17576:70:29;;17708:2;;17669:1:::1;::::0;17708:28:::1;::::0;17576:70;;-1:-1:-1;;;;;17708:28:29::1;;:::i;:::-;;;;;;;;-1:-1:-1::0;;;;;17708:28:29::1;;;;;-1:-1:-1::0;;;;;17708:28:29::1;;;;;;17781:10;-1:-1:-1::0;;;;;17752:56:29::1;17770:9;17752:56;17793:14;17752:56;;;;;-1:-1:-1::0;;;;;16415:47:30;;;;16397:66;;16385:2;16370:18;;16251:218;17752:56:29::1;;;;;;;;17823:10:::0;;-1:-1:-1;;;;;17823:10:29::1;:15:::0;:39;::::1;;;-1:-1:-1::0;17842:15:29;;-1:-1:-1;;;17842:15:29;::::1;-1:-1:-1::0;;;;;17842:15:29::1;:20:::0;17823:39:::1;17819:107;;;17897:9;17883:32;17908:6;17883:32;;;;;;:::i;:::-;;;;;;;;17819:107;-1:-1:-1::0;;;;;17940:18:29;::::1;::::0;17936:112:::1;;17974:63;18008:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;17974:63:29;::::1;17981:12;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;17974:33:29::1;::::0;:63;:33:::1;:63::i;:::-;16977:1077;;;;;1281:20:15::0;:18;:20::i;:::-;16884:1170:29;:::o;1965:315:15:-;2119:25;:23;:25::i;:::-;2219:54;2268:4;661:66;2219:41;:48;;:54::i;:::-;1965:315::o;2286:110::-;2334:55;2383:5;661:66;2334:41;1666:115:19;24735:189:29;24830:4;24863:25;;;;;;;;:::i;:::-;-1:-1:-1;;;;;24853:35:29;:6;-1:-1:-1;;;;;24853:35:29;;:64;;;-1:-1:-1;24902:15:29;;;;;;;;:::i;:::-;-1:-1:-1;;;;;24892:25:29;:6;-1:-1:-1;;;;;24892:25:29;;24846:71;;24735:189;;;;:::o;25031:1254::-;25120:17;25140:32;25153:2;25140:12;:32::i;:::-;25182:23;25208:19;;;:8;:19;;;;;25261:15;;25208:19;;-1:-1:-1;25208:19:29;-1:-1:-1;;;25261:15:29;;-1:-1:-1;;;;;25261:15:29;25242;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25242:34:29;;25238:47;;25278:7;;25031:1254;:::o;25238:47::-;25316:29;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25298:47:29;:15;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25298:47:29;;25294:106;;;25368:21;;-1:-1:-1;;;25368:21:29;;;;;;;;;;;25294:106;25431:10;;-1:-1:-1;;;;;25431:10:29;25413:15;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25413:28:29;;25409:62;;;25450:21;;-1:-1:-1;;;25450:21:29;;;;;;;;;;;25409:62;25482:14;25499:58;25516:9;25527:29;;;;;;;;:::i;25499:58::-;25482:75;-1:-1:-1;25568:17:29;25588:34;;;;;;;;:::i;:::-;25568:54;-1:-1:-1;;;;;;25636:23:29;;;25632:363;;25675:17;25695:43;25717:6;25725:12;;;;:2;:12;:::i;:::-;25695:21;:43::i;:::-;25675:63;;25769:9;-1:-1:-1;;;;;25756:22:29;:9;-1:-1:-1;;;;;25756:22:29;;25752:53;;25787:18;;-1:-1:-1;;;25787:18:29;;;;;;;;;;;25752:53;25661:155;25632:363;;;25841:84;25878:24;;;;:2;:24;:::i;:::-;25904:6;25912:12;;;;:2;:12;:::i;:::-;25841:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25841:36:29;;-1:-1:-1;;;25841:84:29:i;:::-;25836:149;;25952:18;;-1:-1:-1;;;25952:18:29;;;;;;;;;;;25836:149;26044:15;;26005:18;;-1:-1:-1;;;26044:15:29;;-1:-1:-1;;;;;26044:15:29;26026;;;;;;;;:::i;:::-;:33;;;;:::i;:::-;26005:54;-1:-1:-1;26087:15:29;;;;;;;;:::i;:::-;26069:33;;-1:-1:-1;;;;;26069:33:29;;;-1:-1:-1;;;26069:33:29;;;;;;26193:10;26112:9;26069:15;26122:27;;;;;;;;:::i;:::-;-1:-1:-1;;;;;26112:38:29;;;;;;;;;;;;-1:-1:-1;26112:38:29;;;;26151:24;;;;;;;;:::i;:::-;-1:-1:-1;;;;;26112:64:29;;;;;;;;;;;;-1:-1:-1;26112:64:29;;;:91;;:64;;-1:-1:-1;26112:91:29;;;;-1:-1:-1;;;;;26112:91:29;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;26112:91:29;;;;;-1:-1:-1;;;;;26112:91:29;;;;;;26238:10;-1:-1:-1;;;;;26219:59:29;26227:9;26219:59;26250:10;26262:2;:15;;;;;;;;;;:::i;:::-;26219:59;;;-1:-1:-1;;;;;2547:47:30;;;2529:66;;2631:47;;;;2626:2;2611:18;;2604:75;2502:18;26219:59:29;;;;;;;25110:1175;;;;;25031:1254;:::o;5017:176:21:-;5094:7;5120:66;5153:20;:18;:20::i;:::-;5175:10;4049:4:22;4043:11;-1:-1:-1;;;4067:23:22;;4119:4;4110:14;;4103:39;;;;4171:4;4162:14;;4155:34;4227:4;4212:20;;;3874:374;6105:126:21;6151:13;6183:41;:5;6210:13;6183:26;:41::i;:::-;6176:48;;6105:126;:::o;6557:135::-;6606:13;6638:47;:8;6668:16;6638:29;:47::i;1219:204:7:-;1306:37;1320:5;1327:2;1331:5;1338:4;1306:13;:37::i;:::-;1301:116;;1366:40;;-1:-1:-1;;;1366:40:7;;-1:-1:-1;;;;;11296:32:30;;1366:40:7;;;11278:51:30;11251:18;;1366:40:7;;;;;;;;1301:116;1219:204;;;:::o;4691:549:8:-;4774:12;4798;4813:47;4847:6;4855:4;4813:33;:47::i;:::-;4798:62;;4874:7;:72;;;;-1:-1:-1;4918:1:8;4583:16:12;4886:33:8;:59;;;;4944:1;4923:6;-1:-1:-1;;;;;4923:18:8;;:22;4886:59;4870:364;;;4969:25;:23;:25::i;:::-;4962:32;;;;;4870:364;5015:7;5011:223;;;5045:24;;-1:-1:-1;;;5045:24:8;;-1:-1:-1;;;;;11296:32:30;;5045:24:8;;;11278:51:30;11251:18;;5045:24:8;11132:203:30;5011:223:8;4583:16:12;5090:33:8;5086:148;;5139:27;:25;:27::i;:::-;5086:148;;;5204:19;;-1:-1:-1;;;5204:19:8;;;;;;;;;;;5086:148;4788:452;4691:549;;;;:::o;1485:429:23:-;1591:4;1611:6;-1:-1:-1;;;;;1611:18:23;;1633:1;1611:23;1607:301;;1651:17;1670:22;1698:33;1715:4;1721:9;1698:16;:33::i;:::-;-1:-1:-1;1650:81:23;;-1:-1:-1;1650:81:23;-1:-1:-1;1759:26:23;1752:3;:33;;;;;;;;:::i;:::-;;:56;;;;;1802:6;-1:-1:-1;;;;;1789:19:23;:9;-1:-1:-1;;;;;1789:19:23;;1752:56;1745:63;;;;;;1607:301;1846:51;1873:6;1881:4;1887:9;1846:26;:51::i;:::-;1839:58;;;;26945:1074:29;27039:6;-1:-1:-1;;;;;27039:11:29;27049:1;27039:11;27035:36;;27059:12;;-1:-1:-1;;;27059:12:29;;;;;;;;;;;27035:36;27082:17;27102:20;27115:6;27102:12;:20::i;:::-;27156:22;;;;:11;:22;;;;;;;;:24;;;;;;27227:8;:19;;;;;27289:15;;27082:40;;-1:-1:-1;27227:19:29;27276:28;;-1:-1:-1;;;;;;;;27289:15:29;;;;;27276:10;:28;:::i;:::-;27256:48;;27314:20;27346:9;-1:-1:-1;;;;;27337:18:29;:6;-1:-1:-1;;;;;27337:18:29;;:39;;27370:6;27337:39;;;27358:9;27337:39;27314:62;;27390:12;-1:-1:-1;;;;;27390:17:29;27406:1;27390:17;27386:30;;27409:7;;;;26945:1074;;:::o;27386:30::-;27426:26;;27440:12;;27426:2;;:10;;:26;;27440:12;;-1:-1:-1;;;;;27426:26:29;;:::i;:::-;;;-1:-1:-1;;;;;27426:26:29;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;27493:29:29;;;:18;:29;;;;;27536:15;;;-1:-1:-1;;;27536:15:29;;;;:20;27532:231;;27592:10;;-1:-1:-1;;;;;27592:10:29;;;27576:26;;;;27572:181;;27622:14;;-1:-1:-1;;;;;;27654:19:29;;;27572:181;;;27712:26;;27726:12;;27712:3;;:10;;:26;;27726:12;;-1:-1:-1;;;;;27712:26:29;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;27712:26:29;;;;;-1:-1:-1;;;;;27712:26:29;;;;;;27572:181;27778:45;;-1:-1:-1;;;;;16415:47:30;;16397:66;;27798:10:29;;27787:9;;27778:45;;16385:2:30;16370:18;27778:45:29;;;;;;;27838:10;;-1:-1:-1;;;;;27838:10:29;:15;:39;;;;-1:-1:-1;27857:15:29;;-1:-1:-1;;;27857:15:29;;-1:-1:-1;;;;;27857:15:29;:20;27838:39;27834:107;;;27912:9;27898:32;27923:6;27898:32;;;;;;:::i;:::-;;;;;;;;27834:107;27951:61;27985:12;;;;:6;:12;:::i;:::-;-1:-1:-1;;;;;27951:61:29;;27958:12;;;;;;;;:::i;27951:61::-;27025:994;;;;;26945:1074;;:::o;1802:157:15:-;661:66;3375:11:19;1860:93:15;;;1912:30;;-1:-1:-1;;;1912:30:15;;;;;;;;;;;3491:139:19;3608:5;3602:4;3595:19;3491:139;;:::o;5635:273:20:-;5723:7;5743:17;5762:18;5782:16;5802:35;5821:4;5827:9;;5802:18;:35::i;:::-;5742:95;;;;;;5847:28;5859:5;5866:8;5847:11;:28::i;:::-;-1:-1:-1;5892:9:20;;5635:273;-1:-1:-1;;;;;5635:273:20:o;3945:262:21:-;3998:7;4029:4;-1:-1:-1;;;;;4038:11:21;4021:28;;:63;;;;;4070:14;4053:13;:31;4021:63;4017:184;;;-1:-1:-1;4107:22:21;;3945:262::o;4017:184::-;4167:23;4304:80;;;2079:95;4304:80;;;19319:25:30;4326:11:21;19360:18:30;;;19353:34;;;;4339:14:21;19403:18:30;;;19396:34;4355:13:21;19446:18:30;;;19439:34;4378:4:21;19489:19:30;;;19482:61;4268:7:21;;19291:19:30;;4304:80:21;;;;;;;;;;;;4294:91;;;;;;4287:98;;4213:179;;3376:267:16;3470:13;1390:66;3499:46;;3495:142;;3568:15;3577:5;3568:8;:15::i;:::-;3561:22;;;;3495:142;3621:5;3614:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8373:1244:7;8600:4;8594:11;-1:-1:-1;;;8467:12:7;8618:22;;;-1:-1:-1;;;;;8666:24:7;;8660:4;8653:38;8711:4;8704:19;;;8467:12;8787:4;8467:12;8775:4;8467:12;;8759:5;8752;8747:45;8736:56;;9004:1;8997:4;8991:11;8988:18;8979:7;8975:32;8965:606;;9136:6;9126:7;9119:15;9115:28;9112:165;;;9192:16;9186:4;9181:3;9166:43;9242:16;9237:3;9230:29;9112:165;9553:1;9545:5;9533:18;9530:25;9511:16;9504:24;9500:56;9491:7;9487:70;9476:81;;8965:606;9591:4;9584:17;-1:-1:-1;8373:1244:7;;-1:-1:-1;;;;8373:1244:7:o;3383:242:12:-;3466:12;3604:4;3598;3591;3585:11;3578:4;3572;3568:15;3560:6;3553:5;3540:69;3529:80;3383:242;-1:-1:-1;;;3383:242:12:o;4698:334::-;4829:4;4823:11;4862:16;4847:32;;4932:16;4926:4;4919;4907:17;;4892:57;4997:16;4991:4;4987:27;4979:6;4975:40;4969:4;4962:54;4698:334;:::o;5099:223::-;5203:4;5197:11;5247:16;5241:4;5236:3;5221:43;5289:16;5284:3;5277:29;2433:778:20;2536:17;2555:16;2573:14;2603:9;:16;2623:2;2603:22;2599:606;;2908:4;2893:20;;2887:27;2957:4;2942:20;;2936:27;3014:4;2999:20;;2993:27;2641:9;2985:36;3055:25;3066:4;2985:36;2887:27;2936;3055:10;:25::i;:::-;3048:32;;;;;;;;;;;2599:606;-1:-1:-1;;3176:16:20;;3127:1;;-1:-1:-1;3131:35:20;;2599:606;2433:778;;;;;:::o;2900:986:23:-;3145:16;;3500:4;3494:11;;-1:-1:-1;;;3518:21:23;;;3568:4;3559:14;;3552:28;;;3609:4;3600:14;;3593:28;;;;3043:11;;3145:16;3679:4;3667:17;;3145:9;3649:4;3640:14;;3634:51;3770:4;3764;3757;3749:6;3745:17;3740:3;3732:6;3725:5;3714:61;3699:76;;3859:8;3852:4;3846:11;3843:25;3836:4;3818:16;3815:26;3811:58;3802:7;3798:72;3788:82;;;3197:683;;2900:986;;;;;:::o;3304:882:20:-;3417:17;;;3504:2;3484:22;;;3480:700;;3831:30;;3918:4;3896:27;;3883:41;3989:4;3967:27;;3954:41;3522:9;3946:50;4030:25;4041:4;3946:50;3831:30;3883:41;4030:10;:25::i;:::-;4023:32;;;;;;;;;;;3480:700;-1:-1:-1;4102:1:20;;-1:-1:-1;4106:35:20;;-1:-1:-1;4151:9:20;3480:700;3304:882;;;;;;;:::o;11630:532::-;11725:20;11716:5;:29;;;;;;;;:::i;:::-;;11712:444;;11630:532;;:::o;11712:444::-;11821:29;11812:5;:38;;;;;;;;:::i;:::-;;11808:348;;11873:23;;-1:-1:-1;;;11873:23:20;;;;;;;;;;;11808:348;11926:35;11917:5;:44;;;;;;;;:::i;:::-;;11913:243;;11984:46;;-1:-1:-1;;;11984:46:20;;;;;1754:25:30;;;1727:18;;11984:46:20;1608:177:30;11913:243:20;12060:30;12051:5;:39;;;;;;;;:::i;:::-;;12047:109;;12113:32;;-1:-1:-1;;;12113:32:20;;;;;1754:25:30;;;1727:18;;12113:32:20;1608:177:30;2080:380:16;2139:13;2164:11;2178:16;2189:4;2178:10;:16::i;:::-;2302;;;2313:4;2302:16;;;;;;;;;2164:30;;-1:-1:-1;2282:17:16;;2302:16;;;;;;;;;-1:-1:-1;;;2367:16:16;;;-1:-1:-1;2412:4:16;2403:14;;2396:28;;;;-1:-1:-1;2367:16:16;2080:380::o;7142:1551:20:-;7268:17;;;8222:66;8209:79;;8205:164;;;-1:-1:-1;8320:1:20;;-1:-1:-1;8324:30:20;;-1:-1:-1;8356:1:20;8304:54;;8205:164;8480:24;;;8463:14;8480:24;;;;;;;;;19781:25:30;;;19854:4;19842:17;;19822:18;;;19815:45;;;;19876:18;;;19869:34;;;19919:18;;;19912:34;;;8480:24:20;;19753:19:30;;8480:24:20;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;8480:24:20;;-1:-1:-1;;8480:24:20;;;-1:-1:-1;;;;;;;8518:20:20;;8514:113;;-1:-1:-1;8570:1:20;;-1:-1:-1;8574:29:20;;-1:-1:-1;8570:1:20;;-1:-1:-1;8554:62:20;;8514:113;8645:6;-1:-1:-1;8653:20:20;;-1:-1:-1;8653:20:20;;-1:-1:-1;7142:1551:20;;;;;;;;;:::o;2532:247:16:-;2593:7;2665:4;2629:40;;2692:4;2683:13;;2679:71;;;2719:20;;-1:-1:-1;;;2719:20:16;;;;;;;;;;;14:162:30;80:5;125:3;116:6;111:3;107:16;103:26;100:46;;;142:1;139;132:12;100:46;-1:-1:-1;164:6:30;14:162;-1:-1:-1;14:162:30:o;181:188::-;249:20;;-1:-1:-1;;;;;298:46:30;;288:57;;278:85;;359:1;356;349:12;278:85;181:188;;;:::o;374:173::-;442:20;;-1:-1:-1;;;;;491:31:30;;481:42;;471:70;;537:1;534;527:12;552:347;603:8;613:6;667:3;660:4;652:6;648:17;644:27;634:55;;685:1;682;675:12;634:55;-1:-1:-1;708:20:30;;751:18;740:30;;737:50;;;783:1;780;773:12;737:50;820:4;812:6;808:17;796:29;;872:3;865:4;856:6;848;844:19;840:30;837:39;834:59;;;889:1;886;879:12;834:59;552:347;;;;;:::o;904:699::-;1034:6;1042;1050;1058;1066;1119:3;1107:9;1098:7;1094:23;1090:33;1087:53;;;1136:1;1133;1126:12;1087:53;1159:60;1211:7;1200:9;1159:60;:::i;:::-;1149:70;;1238:39;1272:3;1261:9;1257:19;1238:39;:::i;:::-;1228:49;;1296:39;1330:3;1319:9;1315:19;1296:39;:::i;:::-;1286:49;;1386:3;1375:9;1371:19;1358:33;1414:18;1406:6;1403:30;1400:50;;;1446:1;1443;1436:12;1400:50;1485:58;1535:7;1526:6;1515:9;1511:22;1485:58;:::i;:::-;904:699;;;;-1:-1:-1;904:699:30;;-1:-1:-1;1562:8:30;;1459:84;904:699;-1:-1:-1;;;904:699:30:o;2090:260::-;2158:6;2166;2219:2;2207:9;2198:7;2194:23;2190:32;2187:52;;;2235:1;2232;2225:12;2187:52;2258:29;2277:9;2258:29;:::i;:::-;2248:39;;2306:38;2340:2;2329:9;2325:18;2306:38;:::i;:::-;2296:48;;2090:260;;;;;:::o;2690:388::-;2774:8;2784:6;2838:3;2831:4;2823:6;2819:17;2815:27;2805:55;;2856:1;2853;2846:12;2805:55;-1:-1:-1;2879:20:30;;2922:18;2911:30;;2908:50;;;2954:1;2951;2944:12;2908:50;2991:4;2983:6;2979:17;2967:29;;3051:3;3044:4;3034:6;3031:1;3027:14;3019:6;3015:27;3011:38;3008:47;3005:67;;;3068:1;3065;3058:12;3083:490;3201:6;3209;3262:2;3250:9;3241:7;3237:23;3233:32;3230:52;;;3278:1;3275;3268:12;3230:52;3318:9;3305:23;3351:18;3343:6;3340:30;3337:50;;;3383:1;3380;3373:12;3337:50;3422:91;3505:7;3496:6;3485:9;3481:22;3422:91;:::i;:::-;3532:8;;3396:117;;-1:-1:-1;3083:490:30;-1:-1:-1;;;;3083:490:30:o;3578:251::-;3670:6;3723:3;3711:9;3702:7;3698:23;3694:33;3691:53;;;3740:1;3737;3730:12;3691:53;3763:60;3815:7;3804:9;3763:60;:::i;3834:226::-;3893:6;3946:2;3934:9;3925:7;3921:23;3917:32;3914:52;;;3962:1;3959;3952:12;3914:52;-1:-1:-1;4007:23:30;;3834:226;-1:-1:-1;3834:226:30:o;4065:289::-;4107:3;4145:5;4139:12;4172:6;4167:3;4160:19;4228:6;4221:4;4214:5;4210:16;4203:4;4198:3;4194:14;4188:47;4280:1;4273:4;4264:6;4259:3;4255:16;4251:27;4244:38;4343:4;4336:2;4332:7;4327:2;4319:6;4315:15;4311:29;4306:3;4302:39;4298:50;4291:57;;;4065:289;;;;:::o;4359:1238::-;4765:3;4760;4756:13;4748:6;4744:26;4733:9;4726:45;4807:3;4802:2;4791:9;4787:18;4780:31;4707:4;4834:46;4875:3;4864:9;4860:19;4852:6;4834:46;:::i;:::-;4928:9;4920:6;4916:22;4911:2;4900:9;4896:18;4889:50;4962:33;4988:6;4980;4962:33;:::i;:::-;5026:2;5011:18;;5004:34;;;-1:-1:-1;;;;;5075:32:30;;5069:3;5054:19;;5047:61;5095:3;5124:19;;5117:35;;;5189:22;;;5183:3;5168:19;;5161:51;5261:13;;5283:22;;;5333:2;5359:15;;;;-1:-1:-1;5321:15:30;;;;-1:-1:-1;5402:169:30;5416:6;5413:1;5410:13;5402:169;;;5477:13;;5465:26;;5520:2;5546:15;;;;5511:12;;;;5438:1;5431:9;5402:169;;;-1:-1:-1;5588:3:30;;4359:1238;-1:-1:-1;;;;;;;;;;;4359:1238:30:o;5602:300::-;5670:6;5678;5731:2;5719:9;5710:7;5706:23;5702:32;5699:52;;;5747:1;5744;5737:12;5699:52;5792:23;;;-1:-1:-1;5858:38:30;5892:2;5877:18;;5858:38;:::i;6381:780::-;6541:4;6589:2;6578:9;6574:18;6619:2;6608:9;6601:21;6642:6;6677;6671:13;6708:6;6700;6693:22;6746:2;6735:9;6731:18;6724:25;;6808:2;6798:6;6795:1;6791:14;6780:9;6776:30;6772:39;6758:53;;6846:2;6838:6;6834:15;6867:1;6877:255;6891:6;6888:1;6885:13;6877:255;;;6984:2;6980:7;6968:9;6960:6;6956:22;6952:36;6947:3;6940:49;7012:40;7045:6;7036;7030:13;7012:40;:::i;:::-;7002:50;-1:-1:-1;7087:2:30;7110:12;;;;7075:15;;;;;6913:1;6906:9;6877:255;;;-1:-1:-1;7149:6:30;;6381:780;-1:-1:-1;;;;;;6381:780:30:o;7166:739::-;7296:6;7304;7312;7320;7328;7381:3;7369:9;7360:7;7356:23;7352:33;7349:53;;;7398:1;7395;7388:12;7349:53;7421:60;7473:7;7462:9;7421:60;:::i;:::-;7411:70;;7500:39;7534:3;7523:9;7519:19;7500:39;:::i;:::-;7490:49;-1:-1:-1;7608:3:30;7593:19;;7580:33;;-1:-1:-1;7688:3:30;7673:19;;7660:33;7716:18;7705:30;;7702:50;;;7748:1;7745;7738:12;8221:326;8322:6;8330;8383:3;8371:9;8362:7;8358:23;8354:33;8351:53;;;8400:1;8397;8390:12;8351:53;8423:60;8475:7;8464:9;8423:60;:::i;:::-;8413:70;;8502:39;8536:3;8525:9;8521:19;8502:39;:::i;8552:420::-;8629:6;8637;8645;8698:2;8686:9;8677:7;8673:23;8669:32;8666:52;;;8714:1;8711;8704:12;8666:52;8759:23;;;-1:-1:-1;8879:2:30;8864:18;;8851:32;;-1:-1:-1;8928:38:30;8962:2;8947:18;;8928:38;:::i;:::-;8918:48;;8552:420;;;;;:::o;8977:793::-;9115:6;9123;9131;9139;9192:2;9180:9;9171:7;9167:23;9163:32;9160:52;;;9208:1;9205;9198:12;9160:52;9248:9;9235:23;9281:18;9273:6;9270:30;9267:50;;;9313:1;9310;9303:12;9267:50;9352:91;9435:7;9426:6;9415:9;9411:22;9352:91;:::i;:::-;9462:8;;-1:-1:-1;9326:117:30;-1:-1:-1;;9550:2:30;9535:18;;9522:32;9579:18;9566:32;;9563:52;;;9611:1;9608;9601:12;9563:52;9650:60;9702:7;9691:8;9680:9;9676:24;9650:60;:::i;:::-;8977:793;;;;-1:-1:-1;9729:8:30;-1:-1:-1;;;;8977:793:30:o;9957:186::-;10016:6;10069:2;10057:9;10048:7;10044:23;10040:32;10037:52;;;10085:1;10082;10075:12;10037:52;10108:29;10127:9;10108:29;:::i;10148:165::-;10215:20;;10275:12;10264:24;;10254:35;;10244:63;;10303:1;10300;10293:12;10318:184;10376:6;10429:2;10417:9;10408:7;10404:23;10400:32;10397:52;;;10445:1;10442;10435:12;10397:52;10468:28;10486:9;10468:28;:::i;10507:127::-;10568:10;10563:3;10559:20;10556:1;10549:31;10599:4;10596:1;10589:15;10623:4;10620:1;10613:15;10639:243;-1:-1:-1;;;;;10754:42:30;;;10710;;;10706:91;;10809:44;;10806:70;;;10856:18;;:::i;10887:240::-;-1:-1:-1;;;;;10956:42:30;;;11000;;;10952:91;;11055:43;;11052:69;;;11101:18;;:::i;11340:184::-;11410:6;11463:2;11451:9;11442:7;11438:23;11434:32;11431:52;;;11479:1;11476;11469:12;11431:52;-1:-1:-1;11502:16:30;;11340:184;-1:-1:-1;11340:184:30:o;11529:771::-;-1:-1:-1;;;;;11798:32:30;;;11780:51;;11867:32;;11862:2;11847:18;;11840:60;-1:-1:-1;;;;;11936:47:30;;11931:2;11916:18;;11909:75;12015:2;12000:18;;11993:34;;;11818:3;12058;12043:19;;12036:32;;;12084:19;;12077:35;;;12105:6;12155;12149:3;12134:19;;12121:49;12220:1;12190:22;;;12214:3;12186:32;;;12179:43;;;;12283:2;12262:15;;;-1:-1:-1;;12258:29:30;12243:45;12239:55;;11529:771;-1:-1:-1;;;;;11529:771:30:o;12305:125::-;12370:9;;;12391:10;;;12388:36;;;12404:18;;:::i;12435:761::-;-1:-1:-1;;;;;12527:25:30;12546:5;12527:25;:::i;:::-;12523:51;12511:64;;-1:-1:-1;;;;;12611:36:30;12641:4;12630:16;;12611:36;:::i;:::-;12607:62;12600:4;12591:14;;12584:86;-1:-1:-1;;;;;12706:36:30;12736:4;12725:16;;12706:36;:::i;:::-;12702:62;12695:4;12686:14;;12679:86;-1:-1:-1;;;;;12801:36:30;12831:4;12820:16;;12801:36;:::i;:::-;12797:62;12790:4;12781:14;;12774:86;-1:-1:-1;;;;;12896:36:30;12926:4;12915:16;;12896:36;:::i;:::-;12892:62;12885:4;12880:3;12876:14;12869:86;12984:35;13013:4;13006:5;13002:16;12984:35;:::i;:::-;1866:12;1855:24;13069:4;13060:14;;1843:37;13144:4;13133:16;;;13120:30;13166:14;;13159:31;12435:761::o;13201:276::-;13399:3;13384:19;;13412:59;13388:9;13453:6;13412:59;:::i;13482:127::-;13543:10;13538:3;13534:20;13531:1;13524:31;13574:4;13571:1;13564:15;13598:4;13595:1;13588:15;13614:330;13712:4;13770:11;13757:25;13864:3;13860:8;13849;13833:14;13829:29;13825:44;13805:18;13801:69;13791:97;;13884:1;13881;13874:12;13791:97;13905:33;;;;;13614:330;-1:-1:-1;;13614:330:30:o;13949:127::-;14010:10;14005:3;14001:20;13998:1;13991:31;14041:4;14038:1;14031:15;14065:4;14062:1;14055:15;14081:186;14140:6;14193:2;14181:9;14172:7;14168:23;14164:32;14161:52;;;14209:1;14206;14199:12;14161:52;14232:29;14251:9;14232:29;:::i;14750:526::-;14968:13;;14911:3;;14942;;15037:4;15025:17;;14911:3;15070:179;15084:6;15081:1;15078:13;15070:179;;;15147:13;;15133:28;;15194:4;15183:16;;;;15222:17;;;;15106:1;15099:9;15070:179;;;-1:-1:-1;15265:5:30;;14750:526;-1:-1:-1;;;;;14750:526:30:o;15534:347::-;15773:25;;;15760:3;15745:19;;15807:68;15871:2;15856:18;;15848:6;15807:68;:::i;16943:521::-;17020:4;17026:6;17086:11;17073:25;17180:2;17176:7;17165:8;17149:14;17145:29;17141:43;17121:18;17117:68;17107:96;;17199:1;17196;17189:12;17107:96;17226:33;;17278:20;;;-1:-1:-1;17321:18:30;17310:30;;17307:50;;;17353:1;17350;17343:12;17307:50;17386:4;17374:17;;-1:-1:-1;17417:14:30;17413:27;;;17403:38;;17400:58;;;17454:1;17451;17444:12;17469:454;17698:6;17690;17685:3;17672:33;17654:3;17733:6;17728:3;17724:16;17760:1;17756:2;17749:13;17791:6;17785:13;17836:6;17829:4;17821:6;17817:17;17813:2;17807:36;17897:1;17862:15;;17886:13;;;17862:15;17469:454;-1:-1:-1;;;;;17469:454:30:o;17928:173::-;18025:12;17996:20;;;18018;;;17992:47;;18051:21;;18048:47;;;18075:18;;:::i;18543:127::-;18604:10;18599:3;18595:20;18592:1;18585:31;18635:4;18632:1;18625:15;18659:4;18656:1;18649:15;18675:380;18754:1;18750:12;;;;18797;;;18818:61;;18872:4;18864:6;18860:17;18850:27;;18818:61;18925:2;18917:6;18914:14;18894:18;18891:38;18888:161;;18971:10;18966:3;18962:20;18959:1;18952:31;19006:4;19003:1;18996:15;19034:4;19031:1;19024:15","linkReferences":{},"cborAuxdata":{},"immutableReferences":{"4723":[{"start":8017,"length":32}],"4725":[{"start":7975,"length":32}],"4727":[{"start":7933,"length":32}],"4729":[{"start":8098,"length":32}],"4731":[{"start":8138,"length":32}],"4734":[{"start":6790,"length":32}],"4737":[{"start":6839,"length":32}]},"transformations":[{"id":"4723","type":"replace","offset":8017,"reason":"immutable"},{"id":"4725","type":"replace","offset":7975,"reason":"immutable"},{"id":"4727","type":"replace","offset":7933,"reason":"immutable"},{"id":"4729","type":"replace","offset":8098,"reason":"immutable"},{"id":"4731","type":"replace","offset":8138,"reason":"immutable"},{"id":"4734","type":"replace","offset":6790,"reason":"immutable"},{"id":"4737","type":"replace","offset":6839,"reason":"immutable"}],"transformationValues":{"immutables":{"4723":"0xd8d982716899b0e20cf2c1e706a37b8a892c83fdd4ac9b540cfeec11f9c73a39","4725":"0x0000000000000000000000000000000000000000000000000000000000002105","4727":"0x0000000000000000000000004020074e9df2ce1dee5a9c1b5c3f541d02a10003","4729":"0xe03c502b9066cc6f23a8f0f48ed32cb7d506f9f0a2d0055449f256846a770e9a","4731":"0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6","4734":"0x7834303220426174636820536574746c656d656e740000000000000000000015","4737":"0x3100000000000000000000000000000000000000000000000000000000000001"}}},"deployment":{"transactionHash":null,"blockNumber":null,"transactionIndex":null,"deployer":null},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1271.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @dev Interface of the ERC-1271 standard signature validation method for\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\n */\ninterface IERC1271 {\n    /**\n     * @dev Should return whether the signature provided is valid for the provided data\n     * @param hash      Hash of the data to be signed\n     * @param signature Signature byte array associated with `hash`\n     */\n    function isValidSignature(bytes32 hash, bytes calldata signature) external view returns (bytes4 magicValue);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC5267.sol)\n\npragma solidity >=0.4.16;\n\ninterface IERC5267 {\n    /**\n     * @dev MAY be emitted to signal that the domain could have changed.\n     */\n    event EIP712DomainChanged();\n\n    /**\n     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712\n     * signature.\n     */\n    function eip712Domain()\n        external\n        view\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        );\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC7913.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC7913.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @dev Signature verifier interface.\n */\ninterface IERC7913SignatureVerifier {\n    /**\n     * @dev Verifies `signature` as a valid signature of `hash` by `key`.\n     *\n     * MUST return the bytes4 magic value IERC7913SignatureVerifier.verify.selector if the signature is valid.\n     * SHOULD return 0xffffffff or revert if the signature is not valid.\n     * SHOULD return 0xffffffff or revert if the key is empty\n     */\n    function verify(bytes calldata key, bytes32 hash, bytes calldata signature) external view returns (bytes4);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\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"},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\nimport {LowLevelCall} from \"./LowLevelCall.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n        if (LowLevelCall.callNoReturn(recipient, amount, \"\")) {\n            // call successful, nothing to do\n            return;\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {Errors.FailedCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        bool success = LowLevelCall.callNoReturn(target, value, data);\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\n            return LowLevelCall.returnData();\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        bool success = LowLevelCall.staticcallNoReturn(target, data);\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\n            return LowLevelCall.returnData();\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        bool success = LowLevelCall.delegatecallNoReturn(target, data);\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\n            return LowLevelCall.returnData();\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\n     * of an unsuccessful call.\n     *\n     * NOTE: This function is DEPRECATED and may be removed in the next major release.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        // only check if target is a contract if the call was successful and the return data is empty\n        // otherwise we already know that it was a contract\n        if (success && (returndata.length > 0 || target.code.length > 0)) {\n            return returndata;\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (returndata.length > 0) {\n            LowLevelCall.bubbleRevert(returndata);\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {Errors.FailedCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else if (returndata.length > 0) {\n            LowLevelCall.bubbleRevert(returndata);\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Bytes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Bytes.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\n\n/**\n * @dev Bytes operations.\n */\nlibrary Bytes {\n    /**\n     * @dev Forward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the first instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return indexOf(buffer, s, 0);\n    }\n\n    /**\n     * @dev Forward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or after `pos`), returns the index of the next instance\n     * * If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        uint256 length = buffer.length;\n        for (uint256 i = pos; i < length; ++i) {\n            if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) {\n                return i;\n            }\n        }\n        return type(uint256).max;\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the last instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return lastIndexOf(buffer, s, type(uint256).max);\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance\n     * * If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        unchecked {\n            uint256 length = buffer.length;\n            for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) {\n                if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) {\n                    return i - 1;\n                }\n            }\n            return type(uint256).max;\n        }\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in\n     * memory.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return slice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in\n     * memory. The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        bytes memory result = new bytes(end - start);\n        assembly (\"memory-safe\") {\n            mcopy(add(result, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]\n     */\n    function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return splice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to end (excluded) to the start of that buffer. The\n     * `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]\n     */\n    function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        assembly (\"memory-safe\") {\n            mcopy(add(buffer, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n            mstore(buffer, sub(end, start))\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Concatenate an array of bytes into a single bytes object.\n     *\n     * For fixed bytes types, we recommend using the solidity built-in `bytes.concat` or (equivalent)\n     * `abi.encodePacked`.\n     *\n     * NOTE: this could be done in assembly with a single loop that expands starting at the FMP, but that would be\n     * significantly less readable. It might be worth benchmarking the savings of the full-assembly approach.\n     */\n    function concat(bytes[] memory buffers) internal pure returns (bytes memory) {\n        uint256 length = 0;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            length += buffers[i].length;\n        }\n\n        bytes memory result = new bytes(length);\n\n        uint256 offset = 0x20;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            bytes memory input = buffers[i];\n            assembly (\"memory-safe\") {\n                mcopy(add(result, offset), add(input, 0x20), mload(input))\n            }\n            unchecked {\n                offset += input.length;\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Returns true if the two byte buffers are equal.\n     */\n    function equal(bytes memory a, bytes memory b) internal pure returns (bool) {\n        return a.length == b.length && keccak256(a) == keccak256(b);\n    }\n\n    /**\n     * @dev Reverses the byte order of a bytes32 value, converting between little-endian and big-endian.\n     * Inspired by https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel[Reverse Parallel]\n     */\n    function reverseBytes32(bytes32 value) internal pure returns (bytes32) {\n        value = // swap bytes\n            ((value >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        value = // swap 8-byte long pairs\n            ((value >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |\n            ((value & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);\n        return (value >> 128) | (value << 128); // swap 16-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 128-bit values.\n    function reverseBytes16(bytes16 value) internal pure returns (bytes16) {\n        value = // swap bytes\n            ((value & 0xFF00FF00FF00FF00FF00FF00FF00FF00) >> 8) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value & 0xFFFF0000FFFF0000FFFF0000FFFF0000) >> 16) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value & 0xFFFFFFFF00000000FFFFFFFF00000000) >> 32) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        return (value >> 64) | (value << 64); // swap 8-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 64-bit values.\n    function reverseBytes8(bytes8 value) internal pure returns (bytes8) {\n        value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8); // swap bytes\n        value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16); // swap 2-byte long pairs\n        return (value >> 32) | (value << 32); // swap 4-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 32-bit values.\n    function reverseBytes4(bytes4 value) internal pure returns (bytes4) {\n        value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); // swap bytes\n        return (value >> 16) | (value << 16); // swap 2-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 16-bit values.\n    function reverseBytes2(bytes2 value) internal pure returns (bytes2) {\n        return (value >> 8) | (value << 8);\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits a bytes array. Returns `8 * buffer.length`\n     * if the buffer is all zeros.\n     */\n    function clz(bytes memory buffer) internal pure returns (uint256) {\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            bytes32 chunk = _unsafeReadBytesOffset(buffer, i);\n            if (chunk != bytes32(0)) {\n                return Math.min(8 * i + Math.clz(uint256(chunk)), 8 * buffer.length);\n            }\n        }\n        return 8 * buffer.length;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Errors.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/LowLevelCall.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library of low level call functions that implement different calling strategies to deal with the return data.\n *\n * WARNING: Using this library requires an advanced understanding of Solidity and how the EVM works. It is recommended\n * to use the {Address} library instead.\n */\nlibrary LowLevelCall {\n    /// @dev Performs a Solidity function call using a low level `call` and ignoring the return data.\n    function callNoReturn(address target, bytes memory data) internal returns (bool success) {\n        return callNoReturn(target, 0, data);\n    }\n\n    /// @dev Same as {callNoReturn}, but allows to specify the value to be sent in the call.\n    function callNoReturn(address target, uint256 value, bytes memory data) internal returns (bool success) {\n        assembly (\"memory-safe\") {\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x00)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `call` and returns the first 64 bytes of the result\n    /// in the scratch space of memory. Useful for functions that return a tuple of single-word values.\n    ///\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\n    /// and this function doesn't zero it out.\n    function callReturn64Bytes(\n        address target,\n        bytes memory data\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\n        return callReturn64Bytes(target, 0, data);\n    }\n\n    /// @dev Same as {callReturnBytes32Pair}, but allows to specify the value to be sent in the call.\n    function callReturn64Bytes(\n        address target,\n        uint256 value,\n        bytes memory data\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\n        assembly (\"memory-safe\") {\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x40)\n            result1 := mload(0x00)\n            result2 := mload(0x20)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `staticcall` and ignoring the return data.\n    function staticcallNoReturn(address target, bytes memory data) internal view returns (bool success) {\n        assembly (\"memory-safe\") {\n            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `staticcall` and returns the first 64 bytes of the result\n    /// in the scratch space of memory. Useful for functions that return a tuple of single-word values.\n    ///\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\n    /// and this function doesn't zero it out.\n    function staticcallReturn64Bytes(\n        address target,\n        bytes memory data\n    ) internal view returns (bool success, bytes32 result1, bytes32 result2) {\n        assembly (\"memory-safe\") {\n            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)\n            result1 := mload(0x00)\n            result2 := mload(0x20)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `delegatecall` and ignoring the return data.\n    function delegatecallNoReturn(address target, bytes memory data) internal returns (bool success) {\n        assembly (\"memory-safe\") {\n            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `delegatecall` and returns the first 64 bytes of the result\n    /// in the scratch space of memory. Useful for functions that return a tuple of single-word values.\n    ///\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\n    /// and this function doesn't zero it out.\n    function delegatecallReturn64Bytes(\n        address target,\n        bytes memory data\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\n        assembly (\"memory-safe\") {\n            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)\n            result1 := mload(0x00)\n            result2 := mload(0x20)\n        }\n    }\n\n    /// @dev Returns the size of the return data buffer.\n    function returnDataSize() internal pure returns (uint256 size) {\n        assembly (\"memory-safe\") {\n            size := returndatasize()\n        }\n    }\n\n    /// @dev Returns a buffer containing the return data from the last call.\n    function returnData() internal pure returns (bytes memory result) {\n        assembly (\"memory-safe\") {\n            result := mload(0x40)\n            mstore(result, returndatasize())\n            returndatacopy(add(result, 0x20), 0x00, returndatasize())\n            mstore(0x40, add(result, add(0x20, returndatasize())))\n        }\n    }\n\n    /// @dev Revert with the return data from the last call.\n    function bubbleRevert() internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            returndatacopy(fmp, 0x00, returndatasize())\n            revert(fmp, returndatasize())\n        }\n    }\n\n    function bubbleRevert(bytes memory returndata) internal pure {\n        assembly (\"memory-safe\") {\n            revert(add(returndata, 0x20), mload(returndata))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Multicall.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Multicall.sol)\n\npragma solidity ^0.8.20;\n\nimport {Address} from \"./Address.sol\";\nimport {Context} from \"./Context.sol\";\n\n/**\n * @dev Provides a function to batch together multiple calls in a single external call.\n *\n * Consider any assumption about calldata validation performed by the sender may be violated if it's not especially\n * careful about sending transactions invoking {multicall}. For example, a relay address that filters function\n * selectors won't filter calls nested within a {multicall} operation.\n *\n * NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {Context-_msgSender}).\n * If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data`\n * to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of\n * {Context-_msgSender} are not propagated to subcalls.\n */\nabstract contract Multicall is Context {\n    /**\n     * @dev Receives and executes a batch of function calls on this contract.\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n     */\n    function multicall(bytes[] calldata data) public virtual returns (bytes[] memory results) {\n        bytes memory context = msg.sender == _msgSender()\n            ? new bytes(0)\n            : msg.data[msg.data.length - _contextSuffixLength():];\n\n        results = new bytes[](data.length);\n        for (uint256 i = 0; i < data.length; i++) {\n            results[i] = Address.functionDelegateCall(address(this), bytes.concat(data[i], context));\n        }\n        return results;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuardTransient.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuardTransient.sol)\n\npragma solidity ^0.8.24;\n\nimport {TransientSlot} from \"./TransientSlot.sol\";\n\n/**\n * @dev Variant of {ReentrancyGuard} that uses transient storage.\n *\n * NOTE: This variant only works on networks where EIP-1153 is available.\n *\n * _Available since v5.1._\n *\n * @custom:stateless\n */\nabstract contract ReentrancyGuardTransient {\n    using TransientSlot for *;\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.ReentrancyGuard\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant REENTRANCY_GUARD_STORAGE =\n        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    /**\n     * @dev A `view` only version of {nonReentrant}. Use to block view functions\n     * from being called, preventing reading from inconsistent contract state.\n     *\n     * CAUTION: This is a \"view\" modifier and does not change the reentrancy\n     * status. Use it only on view functions. For payable or non-payable functions,\n     * use the standard {nonReentrant} modifier instead.\n     */\n    modifier nonReentrantView() {\n        _nonReentrantBeforeView();\n        _;\n    }\n\n    function _nonReentrantBeforeView() private view {\n        if (_reentrancyGuardEntered()) {\n            revert ReentrancyGuardReentrantCall();\n        }\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, REENTRANCY_GUARD_STORAGE.asBoolean().tload() will be false\n        _nonReentrantBeforeView();\n\n        // Any calls to nonReentrant after this point will fail\n        _reentrancyGuardStorageSlot().asBoolean().tstore(true);\n    }\n\n    function _nonReentrantAfter() private {\n        _reentrancyGuardStorageSlot().asBoolean().tstore(false);\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _reentrancyGuardStorageSlot().asBoolean().tload();\n    }\n\n    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {\n        return REENTRANCY_GUARD_STORAGE;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ShortStrings.sol)\n\npragma solidity ^0.8.20;\n\nimport {StorageSlot} from \"./StorageSlot.sol\";\n\n// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |\n// | length  | 0x                                                              BB |\ntype ShortString is bytes32;\n\n/**\n * @dev This library provides functions to convert short memory strings\n * into a `ShortString` type that can be used as an immutable variable.\n *\n * Strings of arbitrary length can be optimized using this library if\n * they are short enough (up to 31 bytes) by packing them with their\n * length (1 byte) in a single EVM word (32 bytes). Additionally, a\n * fallback mechanism can be used for every other case.\n *\n * Usage example:\n *\n * ```solidity\n * contract Named {\n *     using ShortStrings for *;\n *\n *     ShortString private immutable _name;\n *     string private _nameFallback;\n *\n *     constructor(string memory contractName) {\n *         _name = contractName.toShortStringWithFallback(_nameFallback);\n *     }\n *\n *     function name() external view returns (string memory) {\n *         return _name.toStringWithFallback(_nameFallback);\n *     }\n * }\n * ```\n */\nlibrary ShortStrings {\n    // Used as an identifier for strings longer than 31 bytes.\n    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;\n\n    error StringTooLong(string str);\n    error InvalidShortString();\n\n    /**\n     * @dev Encode a string of at most 31 chars into a `ShortString`.\n     *\n     * This will trigger a `StringTooLong` error is the input string is too long.\n     */\n    function toShortString(string memory str) internal pure returns (ShortString) {\n        bytes memory bstr = bytes(str);\n        if (bstr.length > 0x1f) {\n            revert StringTooLong(str);\n        }\n        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));\n    }\n\n    /**\n     * @dev Decode a `ShortString` back to a \"normal\" string.\n     */\n    function toString(ShortString sstr) internal pure returns (string memory) {\n        uint256 len = byteLength(sstr);\n        // using `new string(len)` would work locally but is not memory safe.\n        string memory str = new string(0x20);\n        assembly (\"memory-safe\") {\n            mstore(str, len)\n            mstore(add(str, 0x20), sstr)\n        }\n        return str;\n    }\n\n    /**\n     * @dev Return the length of a `ShortString`.\n     */\n    function byteLength(ShortString sstr) internal pure returns (uint256) {\n        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;\n        if (result > 0x1f) {\n            revert InvalidShortString();\n        }\n        return result;\n    }\n\n    /**\n     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.\n     */\n    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {\n        if (bytes(value).length < 0x20) {\n            return toShortString(value);\n        } else {\n            StorageSlot.getStringSlot(store).value = value;\n            return ShortString.wrap(FALLBACK_SENTINEL);\n        }\n    }\n\n    /**\n     * @dev Decode a string that was encoded to `ShortString` or written to storage using {toShortStringWithFallback}.\n     */\n    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return toString(value);\n        } else {\n            return store;\n        }\n    }\n\n    /**\n     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using\n     * {toShortStringWithFallback}.\n     *\n     * WARNING: This will return the \"byte length\" of the string. This may not reflect the actual length in terms of\n     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.\n     */\n    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return byteLength(value);\n        } else {\n            return bytes(store).length;\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct Int256Slot {\n        int256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Strings.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\nimport {Bytes} from \"./Bytes.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n    uint256 private constant SPECIAL_CHARS_LOOKUP =\n        (1 << 0x08) | // backspace\n            (1 << 0x09) | // tab\n            (1 << 0x0a) | // newline\n            (1 << 0x0c) | // form feed\n            (1 << 0x0d) | // carriage return\n            (1 << 0x22) | // double quote\n            (1 << 0x5c); // backslash\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(add(buffer, 0x20), length)\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(bytes memory input) internal pure returns (string memory) {\n        unchecked {\n            bytes memory buffer = new bytes(2 * input.length + 2);\n            buffer[0] = \"0\";\n            buffer[1] = \"x\";\n            for (uint256 i = 0; i < input.length; ++i) {\n                uint8 v = uint8(input[i]);\n                buffer[2 * i + 2] = HEX_DIGITS[v >> 4];\n                buffer[2 * i + 3] = HEX_DIGITS[v & 0xf];\n            }\n            return string(buffer);\n        }\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return Bytes.equal(bytes(a), bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress-string} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress-string-uint256-uint256} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.\n     *\n     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.\n     *\n     * NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of\n     * RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's `JSON.parse` does recover escaped unicode\n     * characters that are not in this range, but other tooling may provide different results.\n     */\n    function escapeJSON(string memory input) internal pure returns (string memory) {\n        bytes memory buffer = bytes(input);\n        bytes memory output = new bytes(2 * buffer.length); // worst case scenario\n        uint256 outputLength = 0;\n\n        for (uint256 i = 0; i < buffer.length; ++i) {\n            bytes1 char = bytes1(_unsafeReadBytesOffset(buffer, i));\n            if (((SPECIAL_CHARS_LOOKUP & (1 << uint8(char))) != 0)) {\n                output[outputLength++] = \"\\\\\";\n                if (char == 0x08) output[outputLength++] = \"b\";\n                else if (char == 0x09) output[outputLength++] = \"t\";\n                else if (char == 0x0a) output[outputLength++] = \"n\";\n                else if (char == 0x0c) output[outputLength++] = \"f\";\n                else if (char == 0x0d) output[outputLength++] = \"r\";\n                else if (char == 0x5c) output[outputLength++] = \"\\\\\";\n                else if (char == 0x22) {\n                    // solhint-disable-next-line quotes\n                    output[outputLength++] = '\"';\n                }\n            } else {\n                output[outputLength++] = char;\n            }\n        }\n        // write the actual length and deallocate unused memory\n        assembly (\"memory-safe\") {\n            mstore(output, outputLength)\n            mstore(0x40, add(output, shl(5, shr(5, add(outputLength, 63)))))\n        }\n\n        return string(output);\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/TransientSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/TransientSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/TransientSlot.js.\n\npragma solidity ^0.8.24;\n\n/**\n * @dev Library for reading and writing value-types to specific transient storage slots.\n *\n * Transient slots are often used to store temporary values that are removed after the current transaction.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n *  * Example reading and writing values using transient storage:\n * ```solidity\n * contract Lock {\n *     using TransientSlot for *;\n *\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _LOCK_SLOT = 0xf4678858b2b588224636b8522b729e7722d32fc491da849ed75b3fdf3c84f542;\n *\n *     modifier locked() {\n *         require(!_LOCK_SLOT.asBoolean().tload());\n *\n *         _LOCK_SLOT.asBoolean().tstore(true);\n *         _;\n *         _LOCK_SLOT.asBoolean().tstore(false);\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary TransientSlot {\n    /**\n     * @dev UDVT that represents a slot holding an address.\n     */\n    type AddressSlot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a AddressSlot.\n     */\n    function asAddress(bytes32 slot) internal pure returns (AddressSlot) {\n        return AddressSlot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a bool.\n     */\n    type BooleanSlot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a BooleanSlot.\n     */\n    function asBoolean(bytes32 slot) internal pure returns (BooleanSlot) {\n        return BooleanSlot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a bytes32.\n     */\n    type Bytes32Slot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a Bytes32Slot.\n     */\n    function asBytes32(bytes32 slot) internal pure returns (Bytes32Slot) {\n        return Bytes32Slot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a uint256.\n     */\n    type Uint256Slot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a Uint256Slot.\n     */\n    function asUint256(bytes32 slot) internal pure returns (Uint256Slot) {\n        return Uint256Slot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a int256.\n     */\n    type Int256Slot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a Int256Slot.\n     */\n    function asInt256(bytes32 slot) internal pure returns (Int256Slot) {\n        return Int256Slot.wrap(slot);\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(AddressSlot slot) internal view returns (address value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(AddressSlot slot, address value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(BooleanSlot slot) internal view returns (bool value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(BooleanSlot slot, bool value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(Bytes32Slot slot) internal view returns (bytes32 value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(Bytes32Slot slot, bytes32 value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(Uint256Slot slot) internal view returns (uint256 value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(Uint256Slot slot, uint256 value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(Int256Slot slot) internal view returns (int256 value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(Int256Slot slot, int256 value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n     * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n     * invalidation or nonces for replay protection.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     *\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Variant of {tryRecover} that takes a signature in calldata\n     */\n    function tryRecoverCalldata(\n        bytes32 hash,\n        bytes calldata signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, calldata slices would work here, but are\n            // significantly more expensive (length check) than using calldataload in assembly.\n            assembly (\"memory-safe\") {\n                r := calldataload(signature.offset)\n                s := calldataload(add(signature.offset, 0x20))\n                v := byte(0, calldataload(add(signature.offset, 0x40)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n     * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n     * invalidation or nonces for replay protection.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Variant of {recover} that takes a signature in calldata\n     */\n    function recoverCalldata(bytes32 hash, bytes calldata signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecoverCalldata(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Parse a signature into its `v`, `r` and `s` components. Supports 65-byte and 64-byte (ERC-2098)\n     * formats. Returns (0,0,0) for invalid signatures.\n     *\n     * For 64-byte signatures, `v` is automatically normalized to 27 or 28.\n     * For 65-byte signatures, `v` is returned as-is and MUST already be 27 or 28 for use with ecrecover.\n     *\n     * Consider validating the result before use, or use {tryRecover}/{recover} which perform full validation.\n     */\n    function parse(bytes memory signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n        assembly (\"memory-safe\") {\n            // Check the signature length\n            switch mload(signature)\n            // - case 65: r,s,v signature (standard)\n            case 65 {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n            case 64 {\n                let vs := mload(add(signature, 0x40))\n                r := mload(add(signature, 0x20))\n                s := and(vs, shr(1, not(0)))\n                v := add(shr(255, vs), 27)\n            }\n            default {\n                r := 0\n                s := 0\n                v := 0\n            }\n        }\n    }\n\n    /**\n     * @dev Variant of {parse} that takes a signature in calldata\n     */\n    function parseCalldata(bytes calldata signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n        assembly (\"memory-safe\") {\n            // Check the signature length\n            switch signature.length\n            // - case 65: r,s,v signature (standard)\n            case 65 {\n                r := calldataload(signature.offset)\n                s := calldataload(add(signature.offset, 0x20))\n                v := byte(0, calldataload(add(signature.offset, 0x40)))\n            }\n            // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n            case 64 {\n                let vs := calldataload(add(signature.offset, 0x20))\n                r := calldataload(signature.offset)\n                s := and(vs, shr(1, not(0)))\n                v := add(shr(255, vs), 27)\n            }\n            default {\n                r := 0\n                s := 0\n                v := 0\n            }\n        }\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/EIP712.sol)\n\npragma solidity ^0.8.24;\n\nimport {MessageHashUtils} from \"./MessageHashUtils.sol\";\nimport {ShortStrings, ShortString} from \"../ShortStrings.sol\";\nimport {IERC5267} from \"../../interfaces/IERC5267.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose\n * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract\n * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to\n * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain\n * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the\n * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.\n *\n * @custom:oz-upgrades-unsafe-allow state-variable-immutable\n */\nabstract contract EIP712 is IERC5267 {\n    using ShortStrings for *;\n\n    bytes32 private constant TYPE_HASH =\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n    // invalidate the cached domain separator if the chain id changes.\n    bytes32 private immutable _cachedDomainSeparator;\n    uint256 private immutable _cachedChainId;\n    address private immutable _cachedThis;\n\n    bytes32 private immutable _hashedName;\n    bytes32 private immutable _hashedVersion;\n\n    ShortString private immutable _name;\n    ShortString private immutable _version;\n    // slither-disable-next-line constable-states\n    string private _nameFallback;\n    // slither-disable-next-line constable-states\n    string private _versionFallback;\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        _name = name.toShortStringWithFallback(_nameFallback);\n        _version = version.toShortStringWithFallback(_versionFallback);\n        _hashedName = keccak256(bytes(name));\n        _hashedVersion = keccak256(bytes(version));\n\n        _cachedChainId = block.chainid;\n        _cachedDomainSeparator = _buildDomainSeparator();\n        _cachedThis = address(this);\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {\n            return _cachedDomainSeparator;\n        } else {\n            return _buildDomainSeparator();\n        }\n    }\n\n    function _buildDomainSeparator() private view returns (bytes32) {\n        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n\n    /// @inheritdoc IERC5267\n    function eip712Domain()\n        public\n        view\n        virtual\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        )\n    {\n        return (\n            hex\"0f\", // 01111\n            _EIP712Name(),\n            _EIP712Version(),\n            block.chainid,\n            address(this),\n            bytes32(0),\n            new uint256[](0)\n        );\n    }\n\n    /**\n     * @dev The name parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _name which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Name() internal view returns (string memory) {\n        return _name.toStringWithFallback(_nameFallback);\n    }\n\n    /**\n     * @dev The version parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _version which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Version() internal view returns (string memory) {\n        return _version.toStringWithFallback(_versionFallback);\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.24;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing a bytes32 `messageHash` with\n     * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n     * keccak256, although any bytes32 value can be safely used because the final digest will\n     * be re-hashed.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing an arbitrary `message` with\n     * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n        return\n            keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x00` (data with intended validator).\n     *\n     * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n     * `validator` address. Then hashing the result.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n    }\n\n    /**\n     * @dev Variant of {toDataWithIntendedValidatorHash-address-bytes} optimized for cases where `data` is a bytes32.\n     */\n    function toDataWithIntendedValidatorHash(\n        address validator,\n        bytes32 messageHash\n    ) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            mstore(0x00, hex\"19_00\")\n            mstore(0x02, shl(96, validator))\n            mstore(0x16, messageHash)\n            digest := keccak256(0x00, 0x36)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\n     *\n     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n     * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            mstore(ptr, hex\"19_01\")\n            mstore(add(ptr, 0x02), domainSeparator)\n            mstore(add(ptr, 0x22), structHash)\n            digest := keccak256(ptr, 0x42)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/SignatureChecker.sol)\n\npragma solidity ^0.8.24;\n\nimport {ECDSA} from \"./ECDSA.sol\";\nimport {IERC1271} from \"../../interfaces/IERC1271.sol\";\nimport {IERC7913SignatureVerifier} from \"../../interfaces/IERC7913.sol\";\nimport {Bytes} from \"../Bytes.sol\";\n\n/**\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support:\n *\n * * ECDSA signatures from externally owned accounts (EOAs)\n * * ERC-1271 signatures from smart contract wallets like Argent and Safe Wallet (previously Gnosis Safe)\n * * ERC-7913 signatures from keys that do not have an Ethereum address of their own\n *\n * See https://eips.ethereum.org/EIPS/eip-1271[ERC-1271] and https://eips.ethereum.org/EIPS/eip-7913[ERC-7913].\n */\nlibrary SignatureChecker {\n    using Bytes for bytes;\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. If the signer has code, the\n     * signature is validated against it using ERC-1271, otherwise it's validated using `ECDSA.recover`.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     *\n     * NOTE: For an extended version of this function that supports ERC-7913 signatures, see {isValidSignatureNow-bytes-bytes32-bytes-}.\n     */\n    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\n        if (signer.code.length == 0) {\n            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);\n            return err == ECDSA.RecoverError.NoError && recovered == signer;\n        } else {\n            return isValidERC1271SignatureNow(signer, hash, signature);\n        }\n    }\n\n    /**\n     * @dev Variant of {isValidSignatureNow} that takes a signature in calldata\n     */\n    function isValidSignatureNowCalldata(\n        address signer,\n        bytes32 hash,\n        bytes calldata signature\n    ) internal view returns (bool) {\n        if (signer.code.length == 0) {\n            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecoverCalldata(hash, signature);\n            return err == ECDSA.RecoverError.NoError && recovered == signer;\n        } else {\n            return isValidERC1271SignatureNow(signer, hash, signature);\n        }\n    }\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\n     * against the signer smart contract using ERC-1271.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidERC1271SignatureNow(\n        address signer,\n        bytes32 hash,\n        bytes memory signature\n    ) internal view returns (bool result) {\n        bytes4 selector = IERC1271.isValidSignature.selector;\n        uint256 length = signature.length;\n\n        assembly (\"memory-safe\") {\n            // Encoded calldata is :\n            // [ 0x00 - 0x03 ] <selector>\n            // [ 0x04 - 0x23 ] <hash>\n            // [ 0x24 - 0x44 ] <signature offset> (0x40)\n            // [ 0x44 - 0x64 ] <signature length>\n            // [ 0x64 - ...  ] <signature data>\n            let ptr := mload(0x40)\n            mstore(ptr, selector)\n            mstore(add(ptr, 0x04), hash)\n            mstore(add(ptr, 0x24), 0x40)\n            mcopy(add(ptr, 0x44), signature, add(length, 0x20))\n\n            let success := staticcall(gas(), signer, ptr, add(length, 0x64), 0x00, 0x20)\n            result := and(success, and(gt(returndatasize(), 0x1f), eq(mload(0x00), selector)))\n        }\n    }\n\n    /**\n     * @dev Verifies a signature for a given ERC-7913 signer and hash.\n     *\n     * The signer is a `bytes` object that is the concatenation of an address and optionally a key:\n     * `verifier || key`. A signer must be at least 20 bytes long.\n     *\n     * Verification is done as follows:\n     *\n     * * If `signer.length < 20`: verification fails\n     * * If `signer.length == 20`: verification is done using {isValidSignatureNow}\n     * * Otherwise: verification is done using {IERC7913SignatureVerifier}\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidSignatureNow(\n        bytes memory signer,\n        bytes32 hash,\n        bytes memory signature\n    ) internal view returns (bool) {\n        if (signer.length < 20) {\n            return false;\n        } else if (signer.length == 20) {\n            return isValidSignatureNow(address(bytes20(signer)), hash, signature);\n        } else {\n            (bool success, bytes memory result) = address(bytes20(signer)).staticcall(\n                abi.encodeCall(IERC7913SignatureVerifier.verify, (signer.slice(20), hash, signature))\n            );\n            return (success &&\n                result.length >= 32 &&\n                abi.decode(result, (bytes32)) == bytes32(IERC7913SignatureVerifier.verify.selector));\n        }\n    }\n\n    /**\n     * @dev Verifies multiple ERC-7913 `signatures` for a given `hash` using a set of `signers`.\n     * Returns `false` if the number of signers and signatures is not the same.\n     *\n     * The signers should be ordered by their `keccak256` hash to ensure efficient duplication check. Unordered\n     * signers are supported, but the uniqueness check will be more expensive.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function areValidSignaturesNow(\n        bytes32 hash,\n        bytes[] memory signers,\n        bytes[] memory signatures\n    ) internal view returns (bool) {\n        if (signers.length != signatures.length) return false;\n\n        bytes32 lastId = bytes32(0);\n\n        for (uint256 i = 0; i < signers.length; ++i) {\n            bytes memory signer = signers[i];\n\n            // If one of the signatures is invalid, reject the batch\n            if (!isValidSignatureNow(signer, hash, signatures[i])) return false;\n\n            bytes32 id = keccak256(signer);\n            // If the current signer ID is greater than all previous IDs, then this is a new signer.\n            if (lastId < id) {\n                lastId = id;\n            } else {\n                // If this signer id is not greater than all the previous ones, verify that it is not a duplicate of a previous one\n                // This loop is never executed if the signers are ordered by id.\n                for (uint256 j = 0; j < i; ++j) {\n                    if (id == keccak256(signers[j])) return false;\n                }\n            }\n        }\n\n        return true;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\n        for (uint256 i = 0; i < byteArray.length; ++i) {\n            if (byteArray[i] != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev An uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"src/interfaces/IDepositCollector.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\n/// @title IDepositCollector\n/// @notice Interface for pluggable deposit collectors used by x402BatchSettlement.\n/// @dev Collectors handle the token transfer mechanics (ERC-3009, Permit2, etc.)\n///      while `x402BatchSettlement` verifies actual token receipt via balance checks.\n///      Collectors MUST transfer tokens to `msg.sender` (the calling `x402BatchSettlement`).\ninterface IDepositCollector {\n    /// @notice Pull tokens from payer to the calling `x402BatchSettlement` contract.\n    /// @param payer The address that owns the tokens being deposited\n    /// @param token The ERC-20 token address\n    /// @param amount The exact amount of tokens to transfer\n    /// @param channelId The channel identifier (used by Permit2 collectors for witness binding)\n    /// @param collectorData Opaque bytes containing collector-specific parameters (signatures, nonces, etc.)\n    function collect(\n        address payer,\n        address token,\n        uint256 amount,\n        bytes32 channelId,\n        bytes calldata collectorData\n    ) external;\n}\n"},"src/x402BatchSettlement.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {ECDSA} from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport {EIP712} from \"@openzeppelin/contracts/utils/cryptography/EIP712.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {Multicall} from \"@openzeppelin/contracts/utils/Multicall.sol\";\nimport {ReentrancyGuardTransient} from \"@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {SignatureChecker} from \"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol\";\n\nimport {IDepositCollector} from \"./interfaces/IDepositCollector.sol\";\n\n/// @title x402BatchSettlement\n/// @notice Stateless unidirectional payment channel contract for the x402 `batch-settlement` scheme on EVM.\n///\n/// @dev Channel identity is derived from an immutable `ChannelConfig`:\n///      `channelId = keccak256(abi.encode(channelConfig))`.\n///      Deploy at the same address on every chain via CREATE2.\n///      Uses `ReentrancyGuardTransient` (EIP-1153); deploy only where transient storage is supported.\n///      Fee-on-transfer and rebasing tokens are not recommended and are not guaranteed to behave like standard ERC-20s.\n///\n/// @author Coinbase\ncontract x402BatchSettlement is EIP712, Multicall, ReentrancyGuardTransient {\n    using SafeERC20 for IERC20;\n\n    // =========================================================================\n    // Structs\n    // =========================================================================\n\n    /// @notice Immutable channel parameters; hashed to form `channelId`.\n    ///\n    /// @dev `withdrawDelay` must be between `MIN_WITHDRAW_DELAY` and `MAX_WITHDRAW_DELAY` (inclusive) at deposit time.\n    ///      The floor is a protocol minimum; high-value channels often use **longer** delays so receiver-side `claim`\n    ///      transactions have time to land before a payer can finalize a timed withdrawal (an integrator policy choice).\n    struct ChannelConfig {\n        address payer;\n        address payerAuthorizer;\n        address receiver;\n        address receiverAuthorizer;\n        address token;\n        uint40 withdrawDelay;\n        bytes32 salt;\n    }\n\n    /// @notice Per-channel escrow and claim totals.\n    struct ChannelState {\n        uint128 balance;\n        uint128 totalClaimed;\n    }\n\n    /// @notice In-flight timed withdrawal for a channel.\n    struct WithdrawalState {\n        uint128 amount;\n        /// @dev Timestamp (seconds) when the withdrawal was started; zero if none pending.\n        uint40 initiatedAt;\n    }\n\n    /// @notice Per-receiver, per-token aggregates for settlement sweeps.\n    struct ReceiverState {\n        uint128 totalClaimed;\n        uint128 totalSettled;\n    }\n\n    /// @notice Payer-signed authorization data (no signature field here; that lives on `VoucherClaim`).\n    struct Voucher {\n        ChannelConfig channel;\n        uint128 maxClaimableAmount;\n    }\n\n    /// @notice One signed voucher row plus the cumulative amount the receiver side is claiming.\n    ///\n    /// @dev Cumulative `totalClaimed` (not a delta) gives replay protection: replaying an old voucher after it\n    ///      was applied is a no-op.\n    struct VoucherClaim {\n        Voucher voucher;\n        bytes signature;\n        uint128 totalClaimed;\n    }\n\n    // =========================================================================\n    // Constants\n    // =========================================================================\n\n    uint40 public constant MIN_WITHDRAW_DELAY = 15 minutes;\n    uint40 public constant MAX_WITHDRAW_DELAY = 30 days;\n\n    // =========================================================================\n    // Constants — EIP-712 Type Hashes\n    // =========================================================================\n\n    bytes32 public constant CHANNEL_CONFIG_TYPEHASH = keccak256(\n        \"ChannelConfig(address payer,address payerAuthorizer,address receiver,address receiverAuthorizer,address token,uint40 withdrawDelay,bytes32 salt)\"\n    );\n\n    bytes32 public constant VOUCHER_TYPEHASH = keccak256(\"Voucher(bytes32 channelId,uint128 maxClaimableAmount)\");\n\n    bytes32 public constant REFUND_TYPEHASH = keccak256(\"Refund(bytes32 channelId,uint256 nonce,uint128 amount)\");\n\n    /// @dev EIP-712 entry for one row in a signed claim batch (mirrors on-chain `VoucherClaim` fields used for authorization).\n    bytes32 public constant CLAIM_ENTRY_TYPEHASH =\n        keccak256(\"ClaimEntry(bytes32 channelId,uint128 maxClaimableAmount,uint128 totalClaimed)\");\n\n    /// @dev Full nested EIP-712 type so wallets can render `ClaimEntry[]` for user review.\n    bytes32 public constant CLAIM_BATCH_TYPEHASH = keccak256(\n        \"ClaimBatch(ClaimEntry[] claims)ClaimEntry(bytes32 channelId,uint128 maxClaimableAmount,uint128 totalClaimed)\"\n    );\n\n    // =========================================================================\n    // Storage\n    // =========================================================================\n\n    mapping(bytes32 channelId => ChannelState) public channels;\n\n    /// @dev Monotonic sequence per `channelId` for EIP-712 `Refund` replay protection. Incremented inside\n    ///      `_executeRefund` **before** the capped refund amount is applied, for **both** `refund` and\n    ///      `refundWithSignature`, including when the capped amount is zero (no transfer, no `Refunded` event).\n    ///      A direct `refund` therefore advances the nonce and invalidates any presigned `refundWithSignature`\n    ///      digest that was bound to the previous nonce; coordinate receiver vs relayer flows off-chain.\n    mapping(bytes32 channelId => uint256) public refundNonce;\n    mapping(bytes32 channelId => WithdrawalState) public pendingWithdrawals;\n    mapping(address receiver => mapping(address token => ReceiverState)) public receivers;\n\n    // =========================================================================\n    // Events\n    // =========================================================================\n\n    /// @notice Emitted the first time a channel receives escrowed balance.\n    event ChannelCreated(bytes32 indexed channelId, ChannelConfig config);\n\n    /// @notice Emitted when unclaimed escrow returns to zero and no claims were recorded.\n    event ChannelClosed(bytes32 indexed channelId, ChannelConfig config);\n\n    /// @notice Emitted after a successful deposit into a channel.\n    event Deposited(bytes32 indexed channelId, address indexed sender, uint128 amount, uint128 newBalance);\n\n    /// @notice Emitted when the receiver side increases the cumulative claimed amount for a channel.\n    event Claimed(bytes32 indexed channelId, address indexed sender, uint128 claimAmount, uint128 newTotalClaimed);\n\n    /// @notice Emitted when claimed funds are transferred to the receiver during settlement.\n    event Settled(address indexed receiver, address indexed token, address indexed sender, uint128 amount);\n\n    /// @notice Emitted when escrowed funds are refunded to the payer.\n    event Refunded(bytes32 indexed channelId, address indexed sender, uint128 amount);\n\n    /// @notice Emitted when a timed withdrawal is started.\n    event WithdrawInitiated(bytes32 indexed channelId, uint128 amount, uint40 finalizeAfter);\n\n    /// @notice Emitted when a timed withdrawal completes and funds move to the payer.\n    event WithdrawFinalized(bytes32 indexed channelId, address indexed sender, uint128 amount);\n\n    // =========================================================================\n    // Errors\n    // =========================================================================\n\n    /// @dev Errors use CapWords naming.\n\n    error InvalidChannel();\n    error ZeroDeposit();\n    error DepositOverflow();\n    error InvalidSignature();\n    error NotReceiverAuthorizer();\n    error NotAuthorizedToClaim();\n    error NotAuthorizedToRefund();\n    error ClaimExceedsCeiling();\n    error ClaimExceedsBalance();\n    error WithdrawalAlreadyPending();\n    error WithdrawalNotPending();\n    error NotAuthorizedToFinalizeWithdraw();\n    error WithdrawDelayNotElapsed();\n    error NothingToWithdraw();\n    error WithdrawAmountExceedsAvailable();\n    error WithdrawDelayOutOfRange();\n    error EmptyBatch();\n    error DepositCollectionFailed();\n    error InvalidCollector();\n    error InvalidRefundNonce();\n    error ZeroRefund();\n\n    // =========================================================================\n    // Constructor\n    // =========================================================================\n\n    /// @notice Sets the EIP-712 domain for vouchers, refunds, and claim batches.\n    constructor() EIP712(\"x402 Batch Settlement\", \"1\") {}\n\n    // =========================================================================\n    // Deposits\n    // =========================================================================\n\n    /// @notice Deposits tokens into a channel using a pluggable collector.\n    ///\n    /// @dev The collector executes the pull; this function checks the contract's token balance increased\n    ///      by `amount` after the call (post-condition) to detect fee-on-transfer or failed pulls.\n    ///\n    /// @param config The immutable channel configuration.\n    /// @param amount The exact amount of tokens to deposit.\n    /// @param collector The deposit collector contract address.\n    /// @param collectorData Opaque bytes forwarded to the collector (signatures, nonces, etc.).\n    function deposit(\n        ChannelConfig calldata config,\n        uint128 amount,\n        address collector,\n        bytes calldata collectorData\n    ) external nonReentrant {\n        if (config.payer == address(0)) revert InvalidChannel();\n        if (config.receiver == address(0)) revert InvalidChannel();\n        if (config.receiverAuthorizer == address(0)) revert InvalidChannel();\n        if (config.token == address(0)) revert InvalidChannel();\n        if (config.withdrawDelay < MIN_WITHDRAW_DELAY || config.withdrawDelay > MAX_WITHDRAW_DELAY) {\n            revert WithdrawDelayOutOfRange();\n        }\n        if (amount == 0) revert ZeroDeposit();\n        if (collector == address(0)) revert InvalidCollector();\n\n        bytes32 channelId = getChannelId(config);\n        ChannelState storage ch = channels[channelId];\n\n        if (amount > type(uint128).max - ch.balance) revert DepositOverflow();\n        ch.balance += amount;\n\n        uint256 balBefore = IERC20(config.token).balanceOf(address(this));\n        IDepositCollector(collector).collect(config.payer, config.token, amount, channelId, collectorData);\n        uint256 balAfter = IERC20(config.token).balanceOf(address(this));\n        if (balAfter != balBefore + amount) revert DepositCollectionFailed();\n\n        // First deposit on this channel (escrow was empty before this deposit)\n        if (ch.balance == amount && ch.totalClaimed == 0) {\n            emit ChannelCreated(channelId, config);\n        }\n        emit Deposited(channelId, msg.sender, amount, ch.balance);\n    }\n\n    // =========================================================================\n    // Claim & Settle\n    // =========================================================================\n\n    /// @notice Applies a batch of voucher claims and updates channel accounting.\n    ///\n    /// @param voucherClaims Signed voucher rows with cumulative claim totals.\n    ///\n    /// @dev For each row, `msg.sender` must be `receiverAuthorizer` or `receiver` for that row's channel.\n    ///\n    ///      Receiver-side integrators should submit `claim` **promptly** once a payer-signed voucher should bind on-chain\n    ///      entitlement: only **recorded** claims (`totalClaimed`) reduce what the payer can withdraw. If the payer\n    ///      finalizes a timed withdrawal before this call executes, later `claim` can revert with `ClaimExceedsBalance`.\n    function claim(\n        VoucherClaim[] calldata voucherClaims\n    ) external nonReentrant {\n        if (voucherClaims.length == 0) revert EmptyBatch();\n\n        for (uint256 i = 0; i < voucherClaims.length; ++i) {\n            ChannelConfig calldata c = voucherClaims[i].voucher.channel;\n            if (!_isReceiverSide(msg.sender, c)) {\n                revert NotAuthorizedToClaim();\n            }\n            _processVoucherClaim(voucherClaims[i]);\n        }\n    }\n\n    /// @notice Applies voucher claims authorized by a `receiverAuthorizer` EIP-712 signature over the batch.\n    ///\n    /// @param voucherClaims Claim rows for channels sharing the same `receiverAuthorizer`.\n    /// @param authorizerSignature Signature from `receiverAuthorizer` over `getClaimBatchDigest(voucherClaims)`.\n    ///\n    /// @dev Callable by anyone (relay-friendly). All rows must match the same `receiverAuthorizer`.\n    ///\n    ///      Same liveness consideration as `claim`: relays should submit before payer timed withdrawal drains escrow\n    ///      (see `finalizeWithdraw` / `initiateWithdraw`).\n    function claimWithSignature(\n        VoucherClaim[] calldata voucherClaims,\n        bytes calldata authorizerSignature\n    ) external nonReentrant {\n        if (voucherClaims.length == 0) revert EmptyBatch();\n\n        address authorizer = voucherClaims[0].voucher.channel.receiverAuthorizer;\n\n        bytes32 digest = getClaimBatchDigest(voucherClaims);\n        if (!SignatureChecker.isValidSignatureNow(authorizer, digest, authorizerSignature)) {\n            revert InvalidSignature();\n        }\n\n        for (uint256 i = 0; i < voucherClaims.length; ++i) {\n            if (voucherClaims[i].voucher.channel.receiverAuthorizer != authorizer) {\n                revert NotReceiverAuthorizer();\n            }\n            _processVoucherClaim(voucherClaims[i]);\n        }\n    }\n\n    /// @notice Transfers claimed-but-not-yet-settled tokens to the receiver for a `(receiver, token)` pair.\n    ///\n    /// @param receiver The receiver address whose pending settlement is swept.\n    /// @param token The ERC-20 token to transfer.\n    ///\n    /// @dev Permissionless: typically called by the receiver or a facilitator.\n    function settle(address receiver, address token) external nonReentrant {\n        ReceiverState storage rs = receivers[receiver][token];\n        uint128 amount = rs.totalClaimed - rs.totalSettled;\n        if (amount == 0) return;\n\n        rs.totalSettled = rs.totalClaimed;\n\n        IERC20(token).safeTransfer(receiver, amount);\n\n        emit Settled(receiver, token, msg.sender, amount);\n    }\n\n    // =========================================================================\n    // Withdrawal Flow\n    // =========================================================================\n\n    /// @notice Starts the payer-side timed withdrawal window for unclaimed escrow.\n    ///\n    /// @param config The channel configuration.\n    /// @param amount The gross amount requested; may be capped on finalization.\n    ///\n    /// @dev Only `config.payer` or `config.payerAuthorizer` may call. Reverts if a withdrawal is already pending.\n    ///\n    ///      Available liquidity is `ch.balance - ch.totalClaimed` using **only** on-chain `totalClaimed`. Payer-signed\n    ///      vouchers that are not yet claimed do **not** reserve funds; receivers relying on voucher value must treat\n    ///      inclusion of `claim` during the withdrawal window as an operational requirement (RPC outages, censorship,\n    ///      or relay failure can interact badly with `finalizeWithdraw`).\n    function initiateWithdraw(ChannelConfig calldata config, uint128 amount) external nonReentrant {\n        if (msg.sender != config.payer && msg.sender != config.payerAuthorizer) {\n            revert InvalidChannel();\n        }\n        if (amount == 0) revert NothingToWithdraw();\n\n        bytes32 channelId = getChannelId(config);\n\n        WithdrawalState storage ws = pendingWithdrawals[channelId];\n        if (ws.initiatedAt != 0) revert WithdrawalAlreadyPending();\n\n        ChannelState storage ch = channels[channelId];\n        uint128 available = ch.balance - ch.totalClaimed;\n        if (amount > available) revert WithdrawAmountExceedsAvailable();\n\n        ws.amount = amount;\n        ws.initiatedAt = uint40(block.timestamp);\n\n        uint40 finalizeAfter = uint40(block.timestamp) + config.withdrawDelay;\n        emit WithdrawInitiated(channelId, amount, finalizeAfter);\n    }\n\n    /// @notice Finalizes a pending withdrawal after `withdrawDelay` and sends tokens to the payer.\n    ///\n    /// @param config The channel configuration.\n    ///\n    /// @dev Only `config.payer` or `config.payerAuthorizer` may call. Amount may be capped by available escrow.\n    ///\n    ///      Uses **current** `ch.balance` and `ch.totalClaimed` at execution time. If this transaction executes before a\n    ///      competing `claim`, it can reduce escrow such that the claim later reverts with `ClaimExceedsBalance`.\n    function finalizeWithdraw(\n        ChannelConfig calldata config\n    ) external nonReentrant {\n        if (msg.sender != config.payer && msg.sender != config.payerAuthorizer) {\n            revert NotAuthorizedToFinalizeWithdraw();\n        }\n\n        bytes32 channelId = getChannelId(config);\n        WithdrawalState storage ws = pendingWithdrawals[channelId];\n\n        if (ws.initiatedAt == 0) revert WithdrawalNotPending();\n        if (block.timestamp < uint256(ws.initiatedAt) + uint256(config.withdrawDelay)) {\n            revert WithdrawDelayNotElapsed();\n        }\n\n        ChannelState storage ch = channels[channelId];\n        uint128 available = ch.balance - ch.totalClaimed;\n        uint128 withdrawAmount = ws.amount > available ? available : ws.amount;\n\n        ws.amount = 0;\n        ws.initiatedAt = 0;\n        ch.balance -= withdrawAmount;\n\n        emit WithdrawFinalized(channelId, msg.sender, withdrawAmount);\n\n        if (ch.balance == 0 && ch.totalClaimed == 0) {\n            emit ChannelClosed(channelId, config);\n        }\n\n        if (withdrawAmount > 0) {\n            IERC20(config.token).safeTransfer(config.payer, withdrawAmount);\n        }\n    }\n\n    /// @notice Cooperative refund of unclaimed escrow to the payer.\n    ///\n    /// @param config The channel configuration.\n    /// @param amount Requested refund; capped to `balance - totalClaimed`. Reverts with `ZeroRefund` if `amount == 0`.\n    ///               If the capped amount is zero but `amount > 0`, no token transfer occurs (no `Refunded` event)\n    ///               yet `refundNonce` still advances (see `_executeRefund`).\n    ///\n    /// @dev Only `receiverAuthorizer` or `receiver` may call. Shares `_executeRefund` with `refundWithSignature`, so\n    ///      every successful call advances `refundNonce` for the channel. Any in-flight EIP-712 `Refund` signature\n    ///      produced for the previous nonce becomes unusable; relayers and authorizers should expect re-signing if\n    ///      direct refunds race ahead of relayed `refundWithSignature` submissions.\n    function refund(ChannelConfig calldata config, uint128 amount) external nonReentrant {\n        if (!_isReceiverSide(msg.sender, config)) {\n            revert NotAuthorizedToRefund();\n        }\n        _executeRefund(config, amount);\n    }\n\n    /// @notice Refunds unclaimed escrow to the payer using an EIP-712 `Refund` signature from `receiverAuthorizer`.\n    ///\n    /// @param config The channel configuration.\n    /// @param amount The amount in the signature; capped like `refund`. If the capped amount is zero, no transfer\n    ///               and no `Refunded` event, but `refundNonce` still advances once `_executeRefund` runs.\n    /// @param nonce Must equal `refundNonce(channelId)` at entry; `_executeRefund` increments it (same as `refund`).\n    /// @param receiverAuthorizerSignature EIP-712 signature from `receiverAuthorizer` over the refund digest.\n    ///\n    /// @dev Callable by anyone (relay-friendly). A prior direct `refund` on the same channel can advance the nonce\n    ///      and cause `InvalidRefundNonce` here until the authorizer signs at the new nonce.\n    function refundWithSignature(\n        ChannelConfig calldata config,\n        uint128 amount,\n        uint256 nonce,\n        bytes calldata receiverAuthorizerSignature\n    ) external nonReentrant {\n        bytes32 channelId = getChannelId(config);\n        if (nonce != refundNonce[channelId]) revert InvalidRefundNonce();\n        bytes32 digest = getRefundDigest(channelId, nonce, amount);\n        if (!SignatureChecker.isValidSignatureNow(config.receiverAuthorizer, digest, receiverAuthorizerSignature)) {\n            revert InvalidSignature();\n        }\n        _executeRefund(config, amount);\n    }\n\n    // =========================================================================\n    // View Functions\n    // =========================================================================\n\n    /// @notice Returns the canonical `channelId` for a channel configuration.\n    ///\n    /// @param config The channel configuration to hash.\n    ///\n    /// @return The EIP-712 typed-data hash of `ChannelConfig`, bound to this contract's domain\n    ///         (chainId + verifyingContract). Identical configs on different chains or different\n    ///         deployments produce different ids, preventing cross-chain channel-state collision.\n    function getChannelId(\n        ChannelConfig calldata config\n    ) public view returns (bytes32) {\n        return _hashTypedDataV4(keccak256(abi.encode(CHANNEL_CONFIG_TYPEHASH, config)));\n    }\n\n    /// @notice EIP-712 digest for a `Voucher` with the given `channelId` and `maxClaimableAmount`.\n    ///\n    /// @param channelId The channel identifier.\n    /// @param maxClaimableAmount The ceiling encoded in the voucher.\n    ///\n    /// @return The typed data hash signers use for payer authorization.\n    function getVoucherDigest(bytes32 channelId, uint128 maxClaimableAmount) public view returns (bytes32) {\n        return _hashTypedDataV4(keccak256(abi.encode(VOUCHER_TYPEHASH, channelId, maxClaimableAmount)));\n    }\n\n    /// @notice EIP-712 digest for a cooperative `Refund` authorization.\n    ///\n    /// @param channelId The channel identifier.\n    /// @param nonce The refund nonce; must equal on-chain `refundNonce(channelId)` when `refundWithSignature` runs.\n    /// @param amount The signed refund amount.\n    ///\n    /// @return The typed data hash for `receiverAuthorizer` to sign.\n    ///\n    /// @dev Off-chain signers should use the current `refundNonce(channelId)` as `nonce`. A successful direct `refund`\n    ///      on the same channel advances that nonce and invalidates digests signed for the old value until re-signed.\n    function getRefundDigest(bytes32 channelId, uint256 nonce, uint128 amount) public view returns (bytes32) {\n        return _hashTypedDataV4(keccak256(abi.encode(REFUND_TYPEHASH, channelId, nonce, amount)));\n    }\n\n    /// @notice EIP-712 digest for the signed `ClaimBatch` (used by `claimWithSignature` and off-chain signing).\n    ///\n    /// @param voucherClaims The claim rows hashed into the batch.\n    ///\n    /// @return The typed data hash `receiverAuthorizer` signs for the batch.\n    ///\n    /// @dev `claim` and `claimWithSignature` revert with `EmptyBatch()` when `voucherClaims.length == 0`, so they\n    ///      never call this with an empty array. The digest for `length == 0` is still defined (`entriesRoot = keccak256(\"\")`)\n    ///      for `eth_call` and off-chain tools to match this contract’s EIP-712 encoding without duplicating hashing logic.\n    function getClaimBatchDigest(\n        VoucherClaim[] calldata voucherClaims\n    ) public view returns (bytes32) {\n        uint256 n = voucherClaims.length;\n        bytes32 entriesRoot;\n        if (n == 0) {\n            entriesRoot = keccak256(\"\");\n        } else {\n            bytes32[] memory entryHashes = new bytes32[](n);\n            for (uint256 i = 0; i < n; ++i) {\n                bytes32 cid = getChannelId(voucherClaims[i].voucher.channel);\n                entryHashes[i] = keccak256(\n                    abi.encode(\n                        CLAIM_ENTRY_TYPEHASH,\n                        cid,\n                        voucherClaims[i].voucher.maxClaimableAmount,\n                        voucherClaims[i].totalClaimed\n                    )\n                );\n            }\n            entriesRoot = keccak256(abi.encodePacked(entryHashes));\n        }\n        return _hashTypedDataV4(keccak256(abi.encode(CLAIM_BATCH_TYPEHASH, entriesRoot)));\n    }\n\n    // =========================================================================\n    // Internal Helpers\n    // =========================================================================\n\n    /// @dev True if `sender` may submit a claim for this channel (`receiver` or `receiverAuthorizer`).\n    function _isReceiverSide(address sender, ChannelConfig calldata config) internal pure returns (bool) {\n        return sender == config.receiverAuthorizer || sender == config.receiver;\n    }\n\n    /// @dev Validates the payer signature, updates `channels` and `receivers`, and emits `Claimed`.\n    function _processVoucherClaim(\n        VoucherClaim calldata vc\n    ) internal {\n        bytes32 channelId = getChannelId(vc.voucher.channel);\n        ChannelState storage ch = channels[channelId];\n\n        if (vc.totalClaimed <= ch.totalClaimed) return;\n        if (vc.totalClaimed > vc.voucher.maxClaimableAmount) {\n            revert ClaimExceedsCeiling();\n        }\n        if (vc.totalClaimed > ch.balance) revert ClaimExceedsBalance();\n\n        bytes32 digest = getVoucherDigest(channelId, vc.voucher.maxClaimableAmount);\n\n        address payerAuth = vc.voucher.channel.payerAuthorizer;\n        if (payerAuth != address(0)) {\n            address recovered = ECDSA.recoverCalldata(digest, vc.signature);\n            if (recovered != payerAuth) revert InvalidSignature();\n        } else {\n            if (!SignatureChecker.isValidSignatureNow(vc.voucher.channel.payer, digest, vc.signature)) {\n                revert InvalidSignature();\n            }\n        }\n\n        uint128 claimDelta = vc.totalClaimed - ch.totalClaimed;\n        ch.totalClaimed = vc.totalClaimed;\n        receivers[vc.voucher.channel.receiver][vc.voucher.channel.token].totalClaimed += claimDelta;\n\n        emit Claimed(channelId, msg.sender, claimDelta, vc.totalClaimed);\n    }\n\n    /// @dev Caps refund to available unclaimed escrow, reduces or clears any pending withdrawal, transfers to payer.\n    ///\n    /// @dev Increments `refundNonce[channelId]` **first** (before computing the capped refund). That applies to both\n    ///      `refund` and `refundWithSignature`, including when `amount > 0` but available unclaimed escrow is zero\n    ///      (no transfer, no `Refunded` event). This ties replay protection for signed refunds to the same counter\n    ///      used whenever the receiver side executes a cooperative refund through this helper. `amount == 0` reverts\n    ///      with `ZeroRefund` and does not bump the nonce.\n    function _executeRefund(ChannelConfig calldata config, uint128 amount) internal {\n        if (amount == 0) revert ZeroRefund();\n\n        bytes32 channelId = getChannelId(config);\n        unchecked {\n            refundNonce[channelId]++;\n        }\n\n        ChannelState storage ch = channels[channelId];\n        uint128 available = ch.balance - ch.totalClaimed;\n        uint128 refundAmount = amount > available ? available : amount;\n        if (refundAmount == 0) return;\n\n        ch.balance -= refundAmount;\n\n        WithdrawalState storage pws = pendingWithdrawals[channelId];\n        if (pws.initiatedAt != 0) {\n            if (refundAmount >= pws.amount) {\n                pws.amount = 0;\n                pws.initiatedAt = 0;\n            } else {\n                pws.amount -= refundAmount;\n            }\n        }\n\n        emit Refunded(channelId, msg.sender, refundAmount);\n\n        if (ch.balance == 0 && ch.totalClaimed == 0) {\n            emit ChannelClosed(channelId, config);\n        }\n\n        IERC20(config.token).safeTransfer(config.payer, refundAmount);\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":[":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":ds-test/=lib/permit2/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":permit2/=lib/permit2/src/",":solmate/=lib/permit2/lib/solmate/"]},"name":"x402BatchSettlement","fullyQualifiedName":"src/x402BatchSettlement.sol:x402BatchSettlement"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AddressEmptyCode","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"ClaimExceedsBalance","type":"error","inputs":[]},{"name":"ClaimExceedsCeiling","type":"error","inputs":[]},{"name":"DepositCollectionFailed","type":"error","inputs":[]},{"name":"DepositOverflow","type":"error","inputs":[]},{"name":"ECDSAInvalidSignature","type":"error","inputs":[]},{"name":"ECDSAInvalidSignatureLength","type":"error","inputs":[{"name":"length","type":"uint256","internalType":"uint256"}]},{"name":"ECDSAInvalidSignatureS","type":"error","inputs":[{"name":"s","type":"bytes32","internalType":"bytes32"}]},{"name":"EmptyBatch","type":"error","inputs":[]},{"name":"FailedCall","type":"error","inputs":[]},{"name":"InvalidChannel","type":"error","inputs":[]},{"name":"InvalidCollector","type":"error","inputs":[]},{"name":"InvalidRefundNonce","type":"error","inputs":[]},{"name":"InvalidShortString","type":"error","inputs":[]},{"name":"InvalidSignature","type":"error","inputs":[]},{"name":"NotAuthorizedToClaim","type":"error","inputs":[]},{"name":"NotAuthorizedToFinalizeWithdraw","type":"error","inputs":[]},{"name":"NotAuthorizedToRefund","type":"error","inputs":[]},{"name":"NotReceiverAuthorizer","type":"error","inputs":[]},{"name":"NothingToWithdraw","type":"error","inputs":[]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"StringTooLong","type":"error","inputs":[{"name":"str","type":"string","internalType":"string"}]},{"name":"WithdrawAmountExceedsAvailable","type":"error","inputs":[]},{"name":"WithdrawDelayNotElapsed","type":"error","inputs":[]},{"name":"WithdrawDelayOutOfRange","type":"error","inputs":[]},{"name":"WithdrawalAlreadyPending","type":"error","inputs":[]},{"name":"WithdrawalNotPending","type":"error","inputs":[]},{"name":"ZeroDeposit","type":"error","inputs":[]},{"name":"ZeroRefund","type":"error","inputs":[]},{"name":"ChannelClosed","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"config","type":"tuple","indexed":false,"components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"anonymous":false},{"name":"ChannelCreated","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"config","type":"tuple","indexed":false,"components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"anonymous":false},{"name":"Claimed","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"claimAmount","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"newTotalClaimed","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"Deposited","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"newBalance","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"EIP712DomainChanged","type":"event","inputs":[],"anonymous":false},{"name":"Refunded","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"Settled","type":"event","inputs":[{"name":"receiver","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"WithdrawFinalized","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"WithdrawInitiated","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"finalizeAfter","type":"uint40","indexed":false,"internalType":"uint40"}],"anonymous":false},{"name":"CHANNEL_CONFIG_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"CLAIM_BATCH_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"CLAIM_ENTRY_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"MAX_WITHDRAW_DELAY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"MIN_WITHDRAW_DELAY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"REFUND_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"VOUCHER_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"channels","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"balance","type":"uint128","internalType":"uint128"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"voucherClaims","type":"tuple[]","components":[{"name":"voucher","type":"tuple","components":[{"name":"channel","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimWithSignature","type":"function","inputs":[{"name":"voucherClaims","type":"tuple[]","components":[{"name":"voucher","type":"tuple","components":[{"name":"channel","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]"},{"name":"authorizerSignature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"deposit","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"},{"name":"collector","type":"address","internalType":"address"},{"name":"collectorData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"eip712Domain","type":"function","inputs":[],"outputs":[{"name":"fields","type":"bytes1","internalType":"bytes1"},{"name":"name","type":"string","internalType":"string"},{"name":"version","type":"string","internalType":"string"},{"name":"chainId","type":"uint256","internalType":"uint256"},{"name":"verifyingContract","type":"address","internalType":"address"},{"name":"salt","type":"bytes32","internalType":"bytes32"},{"name":"extensions","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"name":"finalizeWithdraw","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"getChannelId","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getClaimBatchDigest","type":"function","inputs":[{"name":"voucherClaims","type":"tuple[]","components":[{"name":"voucher","type":"tuple","components":[{"name":"channel","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getRefundDigest","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"amount","type":"uint128","internalType":"uint128"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getVoucherDigest","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"initiateWithdraw","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"multicall","type":"function","inputs":[{"name":"data","type":"bytes[]","internalType":"bytes[]"}],"outputs":[{"name":"results","type":"bytes[]","internalType":"bytes[]"}],"stateMutability":"nonpayable"},{"name":"pendingWithdrawals","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"amount","type":"uint128","internalType":"uint128"},{"name":"initiatedAt","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"receivers","type":"function","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"}],"outputs":[{"name":"totalClaimed","type":"uint128","internalType":"uint128"},{"name":"totalSettled","type":"uint128","internalType":"uint128"}],"stateMutability":"view"},{"name":"refund","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"refundNonce","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"refundWithSignature","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"receiverAuthorizerSignature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"settle","type":"function","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[],"name":"ClaimExceedsBalance","type":"error"},{"inputs":[],"name":"ClaimExceedsCeiling","type":"error"},{"inputs":[],"name":"DepositCollectionFailed","type":"error"},{"inputs":[],"name":"DepositOverflow","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[],"name":"EmptyBatch","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"InvalidChannel","type":"error"},{"inputs":[],"name":"InvalidCollector","type":"error"},{"inputs":[],"name":"InvalidRefundNonce","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"NotAuthorizedToClaim","type":"error"},{"inputs":[],"name":"NotAuthorizedToFinalizeWithdraw","type":"error"},{"inputs":[],"name":"NotAuthorizedToRefund","type":"error"},{"inputs":[],"name":"NotReceiverAuthorizer","type":"error"},{"inputs":[],"name":"NothingToWithdraw","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"inputs":[],"name":"WithdrawAmountExceedsAvailable","type":"error"},{"inputs":[],"name":"WithdrawDelayNotElapsed","type":"error"},{"inputs":[],"name":"WithdrawDelayOutOfRange","type":"error"},{"inputs":[],"name":"WithdrawalAlreadyPending","type":"error"},{"inputs":[],"name":"WithdrawalNotPending","type":"error"},{"inputs":[],"name":"ZeroDeposit","type":"error"},{"inputs":[],"name":"ZeroRefund","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"channelId","type":"bytes32"},{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"indexed":false,"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"}],"name":"ChannelClosed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"channelId","type":"bytes32"},{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"indexed":false,"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"}],"name":"ChannelCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"channelId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint128","name":"claimAmount","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"newTotalClaimed","type":"uint128"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"channelId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint128","name":"amount","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"newBalance","type":"uint128"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"channelId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint128","name":"amount","type":"uint128"}],"name":"Refunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint128","name":"amount","type":"uint128"}],"name":"Settled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"channelId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint128","name":"amount","type":"uint128"}],"name":"WithdrawFinalized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"channelId","type":"bytes32"},{"indexed":false,"internalType":"uint128","name":"amount","type":"uint128"},{"indexed":false,"internalType":"uint40","name":"finalizeAfter","type":"uint40"}],"name":"WithdrawInitiated","type":"event"},{"inputs":[],"name":"CHANNEL_CONFIG_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CLAIM_BATCH_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CLAIM_ENTRY_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_WITHDRAW_DELAY","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_WITHDRAW_DELAY","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REFUND_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VOUCHER_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"channelId","type":"bytes32"}],"name":"channels","outputs":[{"internalType":"uint128","name":"balance","type":"uint128"},{"internalType":"uint128","name":"totalClaimed","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"channel","type":"tuple"},{"internalType":"uint128","name":"maxClaimableAmount","type":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher","name":"voucher","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint128","name":"totalClaimed","type":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]","name":"voucherClaims","type":"tuple[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"components":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"channel","type":"tuple"},{"internalType":"uint128","name":"maxClaimableAmount","type":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher","name":"voucher","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint128","name":"totalClaimed","type":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]","name":"voucherClaims","type":"tuple[]"},{"internalType":"bytes","name":"authorizerSignature","type":"bytes"}],"name":"claimWithSignature","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"address","name":"collector","type":"address"},{"internalType":"bytes","name":"collectorData","type":"bytes"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"}],"name":"finalizeWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"}],"name":"getChannelId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"channel","type":"tuple"},{"internalType":"uint128","name":"maxClaimableAmount","type":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher","name":"voucher","type":"tuple"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint128","name":"totalClaimed","type":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]","name":"voucherClaims","type":"tuple[]"}],"name":"getClaimBatchDigest","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"channelId","type":"bytes32"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"getRefundDigest","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"channelId","type":"bytes32"},{"internalType":"uint128","name":"maxClaimableAmount","type":"uint128"}],"name":"getVoucherDigest","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"initiateWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"channelId","type":"bytes32"}],"name":"pendingWithdrawals","outputs":[{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint40","name":"initiatedAt","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"}],"name":"receivers","outputs":[{"internalType":"uint128","name":"totalClaimed","type":"uint128"},{"internalType":"uint128","name":"totalSettled","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"refund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"channelId","type":"bytes32"}],"name":"refundNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"payerAuthorizer","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"receiverAuthorizer","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint40","name":"withdrawDelay","type":"uint40"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig","name":"config","type":"tuple"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"receiverAuthorizerSignature","type":"bytes"}],"name":"refundWithSignature","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"}],"name":"settle","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"author":"Coinbase","details":"Channel identity is derived from an immutable `ChannelConfig`:      `channelId = keccak256(abi.encode(channelConfig))`.      Deploy at the same address on every chain via CREATE2.      Uses `ReentrancyGuardTransient` (EIP-1153); deploy only where transient storage is supported.      Fee-on-transfer and rebasing tokens are not recommended and are not guaranteed to behave like standard ERC-20s.","errors":{"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"ECDSAInvalidSignature()":[{"details":"The signature derives the `address(0)`."}],"ECDSAInvalidSignatureLength(uint256)":[{"details":"The signature has an invalid length."}],"ECDSAInvalidSignatureS(bytes32)":[{"details":"The signature has an S value that is in the upper half order."}],"FailedCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"InvalidChannel()":[{"details":"Errors use CapWords naming."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"events":{"EIP712DomainChanged()":{"details":"MAY be emitted to signal that the domain could have changed."}},"kind":"dev","methods":{"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"details":"For each row, `msg.sender` must be `receiverAuthorizer` or `receiver` for that row's channel.      Receiver-side integrators should submit `claim` **promptly** once a payer-signed voucher should bind on-chain      entitlement: only **recorded** claims (`totalClaimed`) reduce what the payer can withdraw. If the payer      finalizes a timed withdrawal before this call executes, later `claim` can revert with `ClaimExceedsBalance`.","params":{"voucherClaims":"Signed voucher rows with cumulative claim totals."}},"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)":{"details":"Callable by anyone (relay-friendly). All rows must match the same `receiverAuthorizer`.      Same liveness consideration as `claim`: relays should submit before payer timed withdrawal drains escrow      (see `finalizeWithdraw` / `initiateWithdraw`).","params":{"authorizerSignature":"Signature from `receiverAuthorizer` over `getClaimBatchDigest(voucherClaims)`.","voucherClaims":"Claim rows for channels sharing the same `receiverAuthorizer`."}},"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)":{"details":"The collector executes the pull; this function checks the contract's token balance increased      by `amount` after the call (post-condition) to detect fee-on-transfer or failed pulls.","params":{"amount":"The exact amount of tokens to deposit.","collector":"The deposit collector contract address.","collectorData":"Opaque bytes forwarded to the collector (signatures, nonces, etc.).","config":"The immutable channel configuration."}},"eip712Domain()":{"details":"returns the fields and values that describe the domain separator used by this contract for EIP-712 signature."},"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))":{"details":"Only `config.payer` or `config.payerAuthorizer` may call. Amount may be capped by available escrow.      Uses **current** `ch.balance` and `ch.totalClaimed` at execution time. If this transaction executes before a      competing `claim`, it can reduce escrow such that the claim later reverts with `ClaimExceedsBalance`.","params":{"config":"The channel configuration."}},"getChannelId((address,address,address,address,address,uint40,bytes32))":{"params":{"config":"The channel configuration to hash."},"returns":{"_0":"The EIP-712 typed-data hash of `ChannelConfig`, bound to this contract's domain         (chainId + verifyingContract). Identical configs on different chains or different         deployments produce different ids, preventing cross-chain channel-state collision."}},"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"details":"`claim` and `claimWithSignature` revert with `EmptyBatch()` when `voucherClaims.length == 0`, so they      never call this with an empty array. The digest for `length == 0` is still defined (`entriesRoot = keccak256(\"\")`)      for `eth_call` and off-chain tools to match this contract’s EIP-712 encoding without duplicating hashing logic.","params":{"voucherClaims":"The claim rows hashed into the batch."},"returns":{"_0":"The typed data hash `receiverAuthorizer` signs for the batch."}},"getRefundDigest(bytes32,uint256,uint128)":{"details":"Off-chain signers should use the current `refundNonce(channelId)` as `nonce`. A successful direct `refund`      on the same channel advances that nonce and invalidates digests signed for the old value until re-signed.","params":{"amount":"The signed refund amount.","channelId":"The channel identifier.","nonce":"The refund nonce; must equal on-chain `refundNonce(channelId)` when `refundWithSignature` runs."},"returns":{"_0":"The typed data hash for `receiverAuthorizer` to sign."}},"getVoucherDigest(bytes32,uint128)":{"params":{"channelId":"The channel identifier.","maxClaimableAmount":"The ceiling encoded in the voucher."},"returns":{"_0":"The typed data hash signers use for payer authorization."}},"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)":{"details":"Only `config.payer` or `config.payerAuthorizer` may call. Reverts if a withdrawal is already pending.      Available liquidity is `ch.balance - ch.totalClaimed` using **only** on-chain `totalClaimed`. Payer-signed      vouchers that are not yet claimed do **not** reserve funds; receivers relying on voucher value must treat      inclusion of `claim` during the withdrawal window as an operational requirement (RPC outages, censorship,      or relay failure can interact badly with `finalizeWithdraw`).","params":{"amount":"The gross amount requested; may be capped on finalization.","config":"The channel configuration."}},"multicall(bytes[])":{"custom:oz-upgrades-unsafe-allow-reachable":"delegatecall","details":"Receives and executes a batch of function calls on this contract."},"refund((address,address,address,address,address,uint40,bytes32),uint128)":{"details":"Only `receiverAuthorizer` or `receiver` may call. Shares `_executeRefund` with `refundWithSignature`, so      every successful call advances `refundNonce` for the channel. Any in-flight EIP-712 `Refund` signature      produced for the previous nonce becomes unusable; relayers and authorizers should expect re-signing if      direct refunds race ahead of relayed `refundWithSignature` submissions.","params":{"amount":"Requested refund; capped to `balance - totalClaimed`. Reverts with `ZeroRefund` if `amount == 0`.               If the capped amount is zero but `amount > 0`, no token transfer occurs (no `Refunded` event)               yet `refundNonce` still advances (see `_executeRefund`).","config":"The channel configuration."}},"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)":{"details":"Callable by anyone (relay-friendly). A prior direct `refund` on the same channel can advance the nonce      and cause `InvalidRefundNonce` here until the authorizer signs at the new nonce.","params":{"amount":"The amount in the signature; capped like `refund`. If the capped amount is zero, no transfer               and no `Refunded` event, but `refundNonce` still advances once `_executeRefund` runs.","config":"The channel configuration.","nonce":"Must equal `refundNonce(channelId)` at entry; `_executeRefund` increments it (same as `refund`).","receiverAuthorizerSignature":"EIP-712 signature from `receiverAuthorizer` over the refund digest."}},"settle(address,address)":{"details":"Permissionless: typically called by the receiver or a facilitator.","params":{"receiver":"The receiver address whose pending settlement is swept.","token":"The ERC-20 token to transfer."}}},"stateVariables":{"CLAIM_BATCH_TYPEHASH":{"details":"Full nested EIP-712 type so wallets can render `ClaimEntry[]` for user review."},"CLAIM_ENTRY_TYPEHASH":{"details":"EIP-712 entry for one row in a signed claim batch (mirrors on-chain `VoucherClaim` fields used for authorization)."},"refundNonce":{"details":"Monotonic sequence per `channelId` for EIP-712 `Refund` replay protection. Incremented inside      `_executeRefund` **before** the capped refund amount is applied, for **both** `refund` and      `refundWithSignature`, including when the capped amount is zero (no transfer, no `Refunded` event).      A direct `refund` therefore advances the nonce and invalidates any presigned `refundWithSignature`      digest that was bound to the previous nonce; coordinate receiver vs relayer flows off-chain."}},"title":"x402BatchSettlement","version":1},"userdoc":{"events":{"ChannelClosed(bytes32,(address,address,address,address,address,uint40,bytes32))":{"notice":"Emitted when unclaimed escrow returns to zero and no claims were recorded."},"ChannelCreated(bytes32,(address,address,address,address,address,uint40,bytes32))":{"notice":"Emitted the first time a channel receives escrowed balance."},"Claimed(bytes32,address,uint128,uint128)":{"notice":"Emitted when the receiver side increases the cumulative claimed amount for a channel."},"Deposited(bytes32,address,uint128,uint128)":{"notice":"Emitted after a successful deposit into a channel."},"Refunded(bytes32,address,uint128)":{"notice":"Emitted when escrowed funds are refunded to the payer."},"Settled(address,address,address,uint128)":{"notice":"Emitted when claimed funds are transferred to the receiver during settlement."},"WithdrawFinalized(bytes32,address,uint128)":{"notice":"Emitted when a timed withdrawal completes and funds move to the payer."},"WithdrawInitiated(bytes32,uint128,uint40)":{"notice":"Emitted when a timed withdrawal is started."}},"kind":"user","methods":{"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"notice":"Applies a batch of voucher claims and updates channel accounting."},"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)":{"notice":"Applies voucher claims authorized by a `receiverAuthorizer` EIP-712 signature over the batch."},"constructor":{"notice":"Sets the EIP-712 domain for vouchers, refunds, and claim batches."},"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)":{"notice":"Deposits tokens into a channel using a pluggable collector."},"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))":{"notice":"Finalizes a pending withdrawal after `withdrawDelay` and sends tokens to the payer."},"getChannelId((address,address,address,address,address,uint40,bytes32))":{"notice":"Returns the canonical `channelId` for a channel configuration."},"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"notice":"EIP-712 digest for the signed `ClaimBatch` (used by `claimWithSignature` and off-chain signing)."},"getRefundDigest(bytes32,uint256,uint128)":{"notice":"EIP-712 digest for a cooperative `Refund` authorization."},"getVoucherDigest(bytes32,uint128)":{"notice":"EIP-712 digest for a `Voucher` with the given `channelId` and `maxClaimableAmount`."},"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)":{"notice":"Starts the payer-side timed withdrawal window for unclaimed escrow."},"refund((address,address,address,address,address,uint40,bytes32),uint128)":{"notice":"Cooperative refund of unclaimed escrow to the payer."},"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)":{"notice":"Refunds unclaimed escrow to the payer using an EIP-712 `Refund` signature from `receiverAuthorizer`."},"settle(address,address)":{"notice":"Transfers claimed-but-not-yet-settled tokens to the receiver for a `(receiver, token)` pair."}},"notice":"Stateless unidirectional payment channel contract for the x402 `batch-settlement` scheme on EVM.","version":1}},"settings":{"compilationTarget":{"src/x402BatchSettlement.sol":"x402BatchSettlement"},"evmVersion":"cancun","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":ds-test/=lib/permit2/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":permit2/=lib/permit2/src/",":solmate/=lib/permit2/lib/solmate/"]},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol":{"keccak256":"0x66c7ec42c6c43712be2107a50ab4529379bc76a632b425babec698d9da921ac6","license":"MIT","urls":["bzz-raw://dce2778f0b638adfc5ba29c2c618c855fe725fa74a16846386aa1d56a834aa04","dweb:/ipfs/QmPV9oWnzQdi58od266j62xvviavLNHqKLZfm6k2K1qy9E"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"keccak256":"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d","license":"MIT","urls":["bzz-raw://da5e832b40fc5c3145d3781e2e5fa60ac2052c9d08af7e300dc8ab80c4343100","dweb:/ipfs/QmTzf7N5ZUdh5raqtzbM11yexiUoLC9z3Ws632MCuycq1d"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"keccak256":"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc","license":"MIT","urls":["bzz-raw://1c299900ac4ec268d4570ecef0d697a3013cd11a6eb74e295ee3fbc945056037","dweb:/ipfs/Qmab9owJoxcA7vJT5XNayCMaUR1qxqj1NDzzisduwaJMcZ"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"keccak256":"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44","license":"MIT","urls":["bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d","dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol":{"keccak256":"0xfb223a85dd0b2175cfbbaa325a744e2cd74ecd17c3df2b77b0722f991d2725ee","license":"MIT","urls":["bzz-raw://84bf1dea0589ec49c8d15d559cc6d86ee493048a89b2d4adb60fbe705a3d89ae","dweb:/ipfs/Qmd56n556d529wk2pRMhYhm5nhMDhviwereodDikjs68w1"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC7913.sol":{"keccak256":"0xe5a126930df1d54e4a6dd5fea09010c4a7db0ea974c6c17a1e6082879f5a032b","license":"MIT","urls":["bzz-raw://2f58f5a90328536a6c68289916bfa4ed653d871319c7b2a416ab3f6263c4f2f5","dweb:/ipfs/Qmaa9DmgUA16Urz5fuF4RbFz2NaVpNLV41ddwykSdasFUd"]},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2","license":"MIT","urls":["bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303","dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV"]},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0x304d732678032a9781ae85c8f204c8fba3d3a5e31c02616964e75cfdc5049098","license":"MIT","urls":["bzz-raw://299ced486011781dc98f638059678323c03079fefae1482abaa2135b22fa92d0","dweb:/ipfs/QmbZNbcPTBxNvwChavN2kkZZs7xHhYL7mv51KrxMhsMs3j"]},"lib/openzeppelin-contracts/contracts/utils/Address.sol":{"keccak256":"0x0fa9e0d3a859900b5a46f70a03c73adf259603d5e05027a37fe0b45529d85346","license":"MIT","urls":["bzz-raw://c2add4da0240c9f2ce47649c8bb6b11b40e98cf6f88b8bdc76b2704e89391710","dweb:/ipfs/QmNQTwF2uVzu4CRtNxr8bxyP9XuW6VsZuo2Nr4KR2bZr3d"]},"lib/openzeppelin-contracts/contracts/utils/Bytes.sol":{"keccak256":"0x8140d608316521b1fd71167c3b708ebb8659da070723fc8807609553b296ee33","license":"MIT","urls":["bzz-raw://a7bf7db66869ba1e945a0390b85da2f6afc7e42a4735ca918d0d56ac90c50147","dweb:/ipfs/QmRmNyhpBpgzSdQqLtrQCYE7H7eLnVVxh2Yy4YMrySR8AR"]},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"lib/openzeppelin-contracts/contracts/utils/Errors.sol":{"keccak256":"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123","license":"MIT","urls":["bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf","dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB"]},"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":{"keccak256":"0x5b4802a4352474792df3107e961d1cc593e47b820c14f69d3505cb28f5a6a583","license":"MIT","urls":["bzz-raw://a6f86fd01f829499fe0545ff5dda07d4521988e88bfe0bf801fc15650921ed56","dweb:/ipfs/QmUUKu4ZDffHAmfkf3asuQfmLTyfpuy2Amdncc3SqfzKPG"]},"lib/openzeppelin-contracts/contracts/utils/Multicall.sol":{"keccak256":"0x72a5499dfae7676e4298a7299bccd3b27438ba1a4c72df5cd69c1c343c7ea20d","license":"MIT","urls":["bzz-raw://de0fb51ccae3a0ff377ed185d187440fc612a71bf8e42fdb0e032ce747fa3eef","dweb:/ipfs/QmPNBaiVsAiUhz8qfXcSy27S7CqBbtSd8rPqmaykKBhw7Q"]},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"keccak256":"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a","license":"MIT","urls":["bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a","dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG"]},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuardTransient.sol":{"keccak256":"0x8b95459390767d84c984d18faee298ce913e69cf0be8d2fe7785e2ad487ffed8","license":"MIT","urls":["bzz-raw://b5949065ea24feded902e4b0586f547ae6360b4eda7572419d72fe9d5714d1b9","dweb:/ipfs/Qme52ocDwVG8nt9Xvf3j4h9SU1WWk2PHSEk97nRD4sNvY4"]},"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol":{"keccak256":"0x0768b3bdb701fe4994b3be932ca8635551dfebe04c645f77500322741bebf57c","license":"MIT","urls":["bzz-raw://a2059f9ca8d3c11c49ca49fc9c5fb070f18cc85d12a7688e45322ed0e2a1cb99","dweb:/ipfs/QmS2gwX51RAvSw4tYbjHccY2CKbh2uvDzqHLAFXdsddgia"]},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"keccak256":"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97","license":"MIT","urls":["bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b","dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM"]},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"keccak256":"0x36d1750bf1aa5fee9c52adb2f7857ab652daca722fc05dff533b364f67a1139a","license":"MIT","urls":["bzz-raw://2e5e7052539b7849d02f3ce25acc1dce29373c11cfae9f0bc918c54b780c549a","dweb:/ipfs/QmRGE32xNkMTo6i4pHHMxjpiu77yPwnTA25SFngw2NXJys"]},"lib/openzeppelin-contracts/contracts/utils/TransientSlot.sol":{"keccak256":"0xac673fa1e374d9e6107504af363333e3e5f6344d2e83faf57d9bfd41d77cc946","license":"MIT","urls":["bzz-raw://5982478dbbb218e9dd5a6e83f5c0e8d1654ddf20178484b43ef21dd2246809de","dweb:/ipfs/QmaB1hS68n2kG8vTbt7EPEzmrGhkUbfiFyykGGLsAr9X22"]},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"keccak256":"0x360cf86214a764694dae1522a38200b1737fe90e46dcf56a0f89de143071cc20","license":"MIT","urls":["bzz-raw://2e393290a46ca6d1fa1addb40709d26e1d250638ab6acdd103b5af21768ebc7b","dweb:/ipfs/QmPwT3tXwQ9NbGtZ99XRq7sr8LCQP8XaCrzw49JdXGn7us"]},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"keccak256":"0x8440117ea216b97a7bad690a67449fd372c840d073c8375822667e14702782b4","license":"MIT","urls":["bzz-raw://ebb6645995b8290d0b9121825e2533e4e28977b2c6befee76e15e58f0feb61d4","dweb:/ipfs/QmVR72j6kL5R2txuihieDev1FeTi4KWJS1Z6ABbwL3Qtph"]},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"keccak256":"0x6abeed5940e1da7bb329e458db9a1c5c4ea6f86d651b952af99c6bddcd6bbb94","license":"MIT","urls":["bzz-raw://5fe75e9a6b759c5d7fd82fb59bd4f58c672b36f0a69b84f4789b7c7895d3e61c","dweb:/ipfs/QmX28wsir8w5sS3acfJMNHcBwoPsDpqCu7WDkPnUWLMNiZ"]},"lib/openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol":{"keccak256":"0x445455b8be33e09cf1db14e59c0d1c5aa5d312b5e754e8ae751e42313a0cae88","license":"MIT","urls":["bzz-raw://d6939df526d1c3f1d773448f6451eebb8de344113744e0da121b6349658b1298","dweb:/ipfs/QmPffovzJ8qGRuUh57qrnWajHqYPPrntb1EA1VRh8p5TLP"]},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c","license":"MIT","urls":["bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617","dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u"]},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"keccak256":"0x09e3f1c72d4c5cbe8e2644ab7313f8f7177533ae2f4c24cdcbbeaf520a73734c","license":"MIT","urls":["bzz-raw://93208401215d539fa2d81626b207c1f611def7883d0e447b3b5969ebaa7b3c2c","dweb:/ipfs/QmXPxDnQPx8LAweX5ZJqEcwkvs59kP4c64VVDG1Jjq1mef"]},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"keccak256":"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54","license":"MIT","urls":["bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8","dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy"]},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"keccak256":"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3","license":"MIT","urls":["bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03","dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ"]},"src/interfaces/IDepositCollector.sol":{"keccak256":"0xc11528f5c3b3b4392705df68c9b2925c90e768c3bf34d13c58a04bdcc156ebc1","license":"MIT","urls":["bzz-raw://7761b53affced8b18ddc6c5d56db5de7df33970833d6f4599d4cff91b62a2c69","dweb:/ipfs/QmTKSGnHM2CFCUVCndm48bAYTJ1X35RjcMVhLLHHQw3H8Q"]},"src/x402BatchSettlement.sol":{"keccak256":"0xa1d7b1c228f43964a6c299f5d4bceeca38f0e01870c6c6902fc5522b1955e7d3","license":"MIT","urls":["bzz-raw://9625e247ce2bf7179df106196cee1d853bcbd8ac30bb05dc62a2eb87c97b7361","dweb:/ipfs/QmRQkBDuJ28goiPCtgkDTLZfVJW1KyB6ZKVtMtpW1ndDQw"]}},"version":1},"storageLayout":{"types":{"t_uint40":{"label":"uint40","encoding":"inplace","numberOfBytes":"5"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint128":{"label":"uint128","encoding":"inplace","numberOfBytes":"16"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_bytes32,t_uint256)":{"key":"t_bytes32","label":"mapping(bytes32 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_struct(ChannelState)8972_storage":{"label":"struct x402BatchSettlement.ChannelState","members":[{"slot":"0","type":"t_uint128","astId":8969,"label":"balance","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"0","type":"t_uint128","astId":8971,"label":"totalClaimed","offset":16,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}],"encoding":"inplace","numberOfBytes":"32"},"t_struct(ReceiverState)8985_storage":{"label":"struct x402BatchSettlement.ReceiverState","members":[{"slot":"0","type":"t_uint128","astId":8982,"label":"totalClaimed","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"0","type":"t_uint128","astId":8984,"label":"totalSettled","offset":16,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}],"encoding":"inplace","numberOfBytes":"32"},"t_struct(WithdrawalState)8979_storage":{"label":"struct x402BatchSettlement.WithdrawalState","members":[{"slot":"0","type":"t_uint128","astId":8975,"label":"amount","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"0","type":"t_uint40","astId":8978,"label":"initiatedAt","offset":16,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(ChannelState)8972_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct x402BatchSettlement.ChannelState)","value":"t_struct(ChannelState)8972_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_struct(ReceiverState)8985_storage)":{"key":"t_address","label":"mapping(address => struct x402BatchSettlement.ReceiverState)","value":"t_struct(ReceiverState)8985_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(WithdrawalState)8979_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct x402BatchSettlement.WithdrawalState)","value":"t_struct(WithdrawalState)8979_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_struct(ReceiverState)8985_storage))":{"key":"t_address","label":"mapping(address => mapping(address => struct x402BatchSettlement.ReceiverState))","value":"t_mapping(t_address,t_struct(ReceiverState)8985_storage)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":4739,"label":"_nameFallback","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"1","type":"t_string_storage","astId":4741,"label":"_versionFallback","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"2","type":"t_mapping(t_bytes32,t_struct(ChannelState)8972_storage)","astId":9039,"label":"channels","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"3","type":"t_mapping(t_bytes32,t_uint256)","astId":9044,"label":"refundNonce","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"4","type":"t_mapping(t_bytes32,t_struct(WithdrawalState)8979_storage)","astId":9049,"label":"pendingWithdrawals","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_struct(ReceiverState)8985_storage))","astId":9056,"label":"receivers","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","events":{"Refunded(bytes32,address,uint128)":{"notice":"Emitted when escrowed funds are refunded to the payer."},"Claimed(bytes32,address,uint128,uint128)":{"notice":"Emitted when the receiver side increases the cumulative claimed amount for a channel."},"Settled(address,address,address,uint128)":{"notice":"Emitted when claimed funds are transferred to the receiver during settlement."},"WithdrawInitiated(bytes32,uint128,uint40)":{"notice":"Emitted when a timed withdrawal is started."},"Deposited(bytes32,address,uint128,uint128)":{"notice":"Emitted after a successful deposit into a channel."},"WithdrawFinalized(bytes32,address,uint128)":{"notice":"Emitted when a timed withdrawal completes and funds move to the payer."},"ChannelClosed(bytes32,(address,address,address,address,address,uint40,bytes32))":{"notice":"Emitted when unclaimed escrow returns to zero and no claims were recorded."},"ChannelCreated(bytes32,(address,address,address,address,address,uint40,bytes32))":{"notice":"Emitted the first time a channel receives escrowed balance."}},"notice":"Stateless unidirectional payment channel contract for the x402 `batch-settlement` scheme on EVM.","methods":{"constructor":{"notice":"Sets the EIP-712 domain for vouchers, refunds, and claim batches."},"settle(address,address)":{"notice":"Transfers claimed-but-not-yet-settled tokens to the receiver for a `(receiver, token)` pair."},"getVoucherDigest(bytes32,uint128)":{"notice":"EIP-712 digest for a `Voucher` with the given `channelId` and `maxClaimableAmount`."},"getRefundDigest(bytes32,uint256,uint128)":{"notice":"EIP-712 digest for a cooperative `Refund` authorization."},"getChannelId((address,address,address,address,address,uint40,bytes32))":{"notice":"Returns the canonical `channelId` for a channel configuration."},"refund((address,address,address,address,address,uint40,bytes32),uint128)":{"notice":"Cooperative refund of unclaimed escrow to the payer."},"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))":{"notice":"Finalizes a pending withdrawal after `withdrawDelay` and sends tokens to the payer."},"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)":{"notice":"Starts the payer-side timed withdrawal window for unclaimed escrow."},"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)":{"notice":"Deposits tokens into a channel using a pluggable collector."},"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"notice":"Applies a batch of voucher claims and updates channel accounting."},"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)":{"notice":"Refunds unclaimed escrow to the payer using an EIP-712 `Refund` signature from `receiverAuthorizer`."},"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"notice":"EIP-712 digest for the signed `ClaimBatch` (used by `claimWithSignature` and off-chain signing)."},"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)":{"notice":"Applies voucher claims authorized by a `receiverAuthorizer` EIP-712 signature over the batch."}},"version":1},"devdoc":{"kind":"dev","title":"x402BatchSettlement","author":"Coinbase","errors":{"FailedCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"InvalidChannel()":[{"details":"Errors use CapWords naming."}],"ECDSAInvalidSignature()":[{"details":"The signature derives the `address(0)`."}],"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"ECDSAInvalidSignatureS(bytes32)":[{"details":"The signature has an S value that is in the upper half order."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}],"ECDSAInvalidSignatureLength(uint256)":[{"details":"The signature has an invalid length."}]},"events":{"EIP712DomainChanged()":{"details":"MAY be emitted to signal that the domain could have changed."}},"details":"Channel identity is derived from an immutable `ChannelConfig`:      `channelId = keccak256(abi.encode(channelConfig))`.      Deploy at the same address on every chain via CREATE2.      Uses `ReentrancyGuardTransient` (EIP-1153); deploy only where transient storage is supported.      Fee-on-transfer and rebasing tokens are not recommended and are not guaranteed to behave like standard ERC-20s.","methods":{"eip712Domain()":{"details":"returns the fields and values that describe the domain separator used by this contract for EIP-712 signature."},"multicall(bytes[])":{"details":"Receives and executes a batch of function calls on this contract.","custom:oz-upgrades-unsafe-allow-reachable":"delegatecall"},"settle(address,address)":{"params":{"token":"The ERC-20 token to transfer.","receiver":"The receiver address whose pending settlement is swept."},"details":"Permissionless: typically called by the receiver or a facilitator."},"getVoucherDigest(bytes32,uint128)":{"params":{"channelId":"The channel identifier.","maxClaimableAmount":"The ceiling encoded in the voucher."},"returns":{"_0":"The typed data hash signers use for payer authorization."}},"getRefundDigest(bytes32,uint256,uint128)":{"params":{"nonce":"The refund nonce; must equal on-chain `refundNonce(channelId)` when `refundWithSignature` runs.","amount":"The signed refund amount.","channelId":"The channel identifier."},"details":"Off-chain signers should use the current `refundNonce(channelId)` as `nonce`. A successful direct `refund`      on the same channel advances that nonce and invalidates digests signed for the old value until re-signed.","returns":{"_0":"The typed data hash for `receiverAuthorizer` to sign."}},"getChannelId((address,address,address,address,address,uint40,bytes32))":{"params":{"config":"The channel configuration to hash."},"returns":{"_0":"The EIP-712 typed-data hash of `ChannelConfig`, bound to this contract's domain         (chainId + verifyingContract). Identical configs on different chains or different         deployments produce different ids, preventing cross-chain channel-state collision."}},"refund((address,address,address,address,address,uint40,bytes32),uint128)":{"params":{"amount":"Requested refund; capped to `balance - totalClaimed`. Reverts with `ZeroRefund` if `amount == 0`.               If the capped amount is zero but `amount > 0`, no token transfer occurs (no `Refunded` event)               yet `refundNonce` still advances (see `_executeRefund`).","config":"The channel configuration."},"details":"Only `receiverAuthorizer` or `receiver` may call. Shares `_executeRefund` with `refundWithSignature`, so      every successful call advances `refundNonce` for the channel. Any in-flight EIP-712 `Refund` signature      produced for the previous nonce becomes unusable; relayers and authorizers should expect re-signing if      direct refunds race ahead of relayed `refundWithSignature` submissions."},"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))":{"params":{"config":"The channel configuration."},"details":"Only `config.payer` or `config.payerAuthorizer` may call. Amount may be capped by available escrow.      Uses **current** `ch.balance` and `ch.totalClaimed` at execution time. If this transaction executes before a      competing `claim`, it can reduce escrow such that the claim later reverts with `ClaimExceedsBalance`."},"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)":{"params":{"amount":"The gross amount requested; may be capped on finalization.","config":"The channel configuration."},"details":"Only `config.payer` or `config.payerAuthorizer` may call. Reverts if a withdrawal is already pending.      Available liquidity is `ch.balance - ch.totalClaimed` using **only** on-chain `totalClaimed`. Payer-signed      vouchers that are not yet claimed do **not** reserve funds; receivers relying on voucher value must treat      inclusion of `claim` during the withdrawal window as an operational requirement (RPC outages, censorship,      or relay failure can interact badly with `finalizeWithdraw`)."},"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)":{"params":{"amount":"The exact amount of tokens to deposit.","config":"The immutable channel configuration.","collector":"The deposit collector contract address.","collectorData":"Opaque bytes forwarded to the collector (signatures, nonces, etc.)."},"details":"The collector executes the pull; this function checks the contract's token balance increased      by `amount` after the call (post-condition) to detect fee-on-transfer or failed pulls."},"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"params":{"voucherClaims":"Signed voucher rows with cumulative claim totals."},"details":"For each row, `msg.sender` must be `receiverAuthorizer` or `receiver` for that row's channel.      Receiver-side integrators should submit `claim` **promptly** once a payer-signed voucher should bind on-chain      entitlement: only **recorded** claims (`totalClaimed`) reduce what the payer can withdraw. If the payer      finalizes a timed withdrawal before this call executes, later `claim` can revert with `ClaimExceedsBalance`."},"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)":{"params":{"nonce":"Must equal `refundNonce(channelId)` at entry; `_executeRefund` increments it (same as `refund`).","amount":"The amount in the signature; capped like `refund`. If the capped amount is zero, no transfer               and no `Refunded` event, but `refundNonce` still advances once `_executeRefund` runs.","config":"The channel configuration.","receiverAuthorizerSignature":"EIP-712 signature from `receiverAuthorizer` over the refund digest."},"details":"Callable by anyone (relay-friendly). A prior direct `refund` on the same channel can advance the nonce      and cause `InvalidRefundNonce` here until the authorizer signs at the new nonce."},"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"params":{"voucherClaims":"The claim rows hashed into the batch."},"details":"`claim` and `claimWithSignature` revert with `EmptyBatch()` when `voucherClaims.length == 0`, so they      never call this with an empty array. The digest for `length == 0` is still defined (`entriesRoot = keccak256(\"\")`)      for `eth_call` and off-chain tools to match this contract’s EIP-712 encoding without duplicating hashing logic.","returns":{"_0":"The typed data hash `receiverAuthorizer` signs for the batch."}},"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)":{"params":{"voucherClaims":"Claim rows for channels sharing the same `receiverAuthorizer`.","authorizerSignature":"Signature from `receiverAuthorizer` over `getClaimBatchDigest(voucherClaims)`."},"details":"Callable by anyone (relay-friendly). All rows must match the same `receiverAuthorizer`.      Same liveness consideration as `claim`: relays should submit before payer timed withdrawal drains escrow      (see `finalizeWithdraw` / `initiateWithdraw`)."}},"version":1,"stateVariables":{"refundNonce":{"details":"Monotonic sequence per `channelId` for EIP-712 `Refund` replay protection. Incremented inside      `_executeRefund` **before** the capped refund amount is applied, for **both** `refund` and      `refundWithSignature`, including when the capped amount is zero (no transfer, no `Refunded` event).      A direct `refund` therefore advances the nonce and invalidates any presigned `refundWithSignature`      digest that was bound to the previous nonce; coordinate receiver vs relayer flows off-chain."},"CLAIM_BATCH_TYPEHASH":{"details":"Full nested EIP-712 type so wallets can render `ClaimEntry[]` for user review."},"CLAIM_ENTRY_TYPEHASH":{"details":"EIP-712 entry for one row in a signed claim batch (mirrors on-chain `VoucherClaim` fields used for authorization)."}}},"sourceIds":{"src/x402BatchSettlement.sol":{"id":29},"src/interfaces/IDepositCollector.sol":{"id":28},"lib/openzeppelin-contracts/contracts/utils/Bytes.sol":{"id":9},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"id":14},"lib/openzeppelin-contracts/contracts/utils/Errors.sol":{"id":11},"lib/openzeppelin-contracts/contracts/utils/Address.sol":{"id":8},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"id":10},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"id":18},"lib/openzeppelin-contracts/contracts/utils/Multicall.sol":{"id":13},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"id":25},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"id":3},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"id":17},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":6},"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":{"id":12},"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol":{"id":16},"lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol":{"id":0},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"id":1},"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol":{"id":4},"lib/openzeppelin-contracts/contracts/interfaces/IERC7913.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/TransientSlot.sol":{"id":19},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"id":26},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"id":27},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"id":20},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"id":21},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"id":7},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":24},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuardTransient.sol":{"id":15},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"id":22},"lib/openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol":{"id":23}},"additionalInput":null,"stdJsonInput":{"sources":{"src/x402BatchSettlement.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\nimport {ECDSA} from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport {EIP712} from \"@openzeppelin/contracts/utils/cryptography/EIP712.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {Multicall} from \"@openzeppelin/contracts/utils/Multicall.sol\";\nimport {ReentrancyGuardTransient} from \"@openzeppelin/contracts/utils/ReentrancyGuardTransient.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {SignatureChecker} from \"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol\";\n\nimport {IDepositCollector} from \"./interfaces/IDepositCollector.sol\";\n\n/// @title x402BatchSettlement\n/// @notice Stateless unidirectional payment channel contract for the x402 `batch-settlement` scheme on EVM.\n///\n/// @dev Channel identity is derived from an immutable `ChannelConfig`:\n///      `channelId = keccak256(abi.encode(channelConfig))`.\n///      Deploy at the same address on every chain via CREATE2.\n///      Uses `ReentrancyGuardTransient` (EIP-1153); deploy only where transient storage is supported.\n///      Fee-on-transfer and rebasing tokens are not recommended and are not guaranteed to behave like standard ERC-20s.\n///\n/// @author Coinbase\ncontract x402BatchSettlement is EIP712, Multicall, ReentrancyGuardTransient {\n    using SafeERC20 for IERC20;\n\n    // =========================================================================\n    // Structs\n    // =========================================================================\n\n    /// @notice Immutable channel parameters; hashed to form `channelId`.\n    ///\n    /// @dev `withdrawDelay` must be between `MIN_WITHDRAW_DELAY` and `MAX_WITHDRAW_DELAY` (inclusive) at deposit time.\n    ///      The floor is a protocol minimum; high-value channels often use **longer** delays so receiver-side `claim`\n    ///      transactions have time to land before a payer can finalize a timed withdrawal (an integrator policy choice).\n    struct ChannelConfig {\n        address payer;\n        address payerAuthorizer;\n        address receiver;\n        address receiverAuthorizer;\n        address token;\n        uint40 withdrawDelay;\n        bytes32 salt;\n    }\n\n    /// @notice Per-channel escrow and claim totals.\n    struct ChannelState {\n        uint128 balance;\n        uint128 totalClaimed;\n    }\n\n    /// @notice In-flight timed withdrawal for a channel.\n    struct WithdrawalState {\n        uint128 amount;\n        /// @dev Timestamp (seconds) when the withdrawal was started; zero if none pending.\n        uint40 initiatedAt;\n    }\n\n    /// @notice Per-receiver, per-token aggregates for settlement sweeps.\n    struct ReceiverState {\n        uint128 totalClaimed;\n        uint128 totalSettled;\n    }\n\n    /// @notice Payer-signed authorization data (no signature field here; that lives on `VoucherClaim`).\n    struct Voucher {\n        ChannelConfig channel;\n        uint128 maxClaimableAmount;\n    }\n\n    /// @notice One signed voucher row plus the cumulative amount the receiver side is claiming.\n    ///\n    /// @dev Cumulative `totalClaimed` (not a delta) gives replay protection: replaying an old voucher after it\n    ///      was applied is a no-op.\n    struct VoucherClaim {\n        Voucher voucher;\n        bytes signature;\n        uint128 totalClaimed;\n    }\n\n    // =========================================================================\n    // Constants\n    // =========================================================================\n\n    uint40 public constant MIN_WITHDRAW_DELAY = 15 minutes;\n    uint40 public constant MAX_WITHDRAW_DELAY = 30 days;\n\n    // =========================================================================\n    // Constants — EIP-712 Type Hashes\n    // =========================================================================\n\n    bytes32 public constant CHANNEL_CONFIG_TYPEHASH = keccak256(\n        \"ChannelConfig(address payer,address payerAuthorizer,address receiver,address receiverAuthorizer,address token,uint40 withdrawDelay,bytes32 salt)\"\n    );\n\n    bytes32 public constant VOUCHER_TYPEHASH = keccak256(\"Voucher(bytes32 channelId,uint128 maxClaimableAmount)\");\n\n    bytes32 public constant REFUND_TYPEHASH = keccak256(\"Refund(bytes32 channelId,uint256 nonce,uint128 amount)\");\n\n    /// @dev EIP-712 entry for one row in a signed claim batch (mirrors on-chain `VoucherClaim` fields used for authorization).\n    bytes32 public constant CLAIM_ENTRY_TYPEHASH =\n        keccak256(\"ClaimEntry(bytes32 channelId,uint128 maxClaimableAmount,uint128 totalClaimed)\");\n\n    /// @dev Full nested EIP-712 type so wallets can render `ClaimEntry[]` for user review.\n    bytes32 public constant CLAIM_BATCH_TYPEHASH = keccak256(\n        \"ClaimBatch(ClaimEntry[] claims)ClaimEntry(bytes32 channelId,uint128 maxClaimableAmount,uint128 totalClaimed)\"\n    );\n\n    // =========================================================================\n    // Storage\n    // =========================================================================\n\n    mapping(bytes32 channelId => ChannelState) public channels;\n\n    /// @dev Monotonic sequence per `channelId` for EIP-712 `Refund` replay protection. Incremented inside\n    ///      `_executeRefund` **before** the capped refund amount is applied, for **both** `refund` and\n    ///      `refundWithSignature`, including when the capped amount is zero (no transfer, no `Refunded` event).\n    ///      A direct `refund` therefore advances the nonce and invalidates any presigned `refundWithSignature`\n    ///      digest that was bound to the previous nonce; coordinate receiver vs relayer flows off-chain.\n    mapping(bytes32 channelId => uint256) public refundNonce;\n    mapping(bytes32 channelId => WithdrawalState) public pendingWithdrawals;\n    mapping(address receiver => mapping(address token => ReceiverState)) public receivers;\n\n    // =========================================================================\n    // Events\n    // =========================================================================\n\n    /// @notice Emitted the first time a channel receives escrowed balance.\n    event ChannelCreated(bytes32 indexed channelId, ChannelConfig config);\n\n    /// @notice Emitted when unclaimed escrow returns to zero and no claims were recorded.\n    event ChannelClosed(bytes32 indexed channelId, ChannelConfig config);\n\n    /// @notice Emitted after a successful deposit into a channel.\n    event Deposited(bytes32 indexed channelId, address indexed sender, uint128 amount, uint128 newBalance);\n\n    /// @notice Emitted when the receiver side increases the cumulative claimed amount for a channel.\n    event Claimed(bytes32 indexed channelId, address indexed sender, uint128 claimAmount, uint128 newTotalClaimed);\n\n    /// @notice Emitted when claimed funds are transferred to the receiver during settlement.\n    event Settled(address indexed receiver, address indexed token, address indexed sender, uint128 amount);\n\n    /// @notice Emitted when escrowed funds are refunded to the payer.\n    event Refunded(bytes32 indexed channelId, address indexed sender, uint128 amount);\n\n    /// @notice Emitted when a timed withdrawal is started.\n    event WithdrawInitiated(bytes32 indexed channelId, uint128 amount, uint40 finalizeAfter);\n\n    /// @notice Emitted when a timed withdrawal completes and funds move to the payer.\n    event WithdrawFinalized(bytes32 indexed channelId, address indexed sender, uint128 amount);\n\n    // =========================================================================\n    // Errors\n    // =========================================================================\n\n    /// @dev Errors use CapWords naming.\n\n    error InvalidChannel();\n    error ZeroDeposit();\n    error DepositOverflow();\n    error InvalidSignature();\n    error NotReceiverAuthorizer();\n    error NotAuthorizedToClaim();\n    error NotAuthorizedToRefund();\n    error ClaimExceedsCeiling();\n    error ClaimExceedsBalance();\n    error WithdrawalAlreadyPending();\n    error WithdrawalNotPending();\n    error NotAuthorizedToFinalizeWithdraw();\n    error WithdrawDelayNotElapsed();\n    error NothingToWithdraw();\n    error WithdrawAmountExceedsAvailable();\n    error WithdrawDelayOutOfRange();\n    error EmptyBatch();\n    error DepositCollectionFailed();\n    error InvalidCollector();\n    error InvalidRefundNonce();\n    error ZeroRefund();\n\n    // =========================================================================\n    // Constructor\n    // =========================================================================\n\n    /// @notice Sets the EIP-712 domain for vouchers, refunds, and claim batches.\n    constructor() EIP712(\"x402 Batch Settlement\", \"1\") {}\n\n    // =========================================================================\n    // Deposits\n    // =========================================================================\n\n    /// @notice Deposits tokens into a channel using a pluggable collector.\n    ///\n    /// @dev The collector executes the pull; this function checks the contract's token balance increased\n    ///      by `amount` after the call (post-condition) to detect fee-on-transfer or failed pulls.\n    ///\n    /// @param config The immutable channel configuration.\n    /// @param amount The exact amount of tokens to deposit.\n    /// @param collector The deposit collector contract address.\n    /// @param collectorData Opaque bytes forwarded to the collector (signatures, nonces, etc.).\n    function deposit(\n        ChannelConfig calldata config,\n        uint128 amount,\n        address collector,\n        bytes calldata collectorData\n    ) external nonReentrant {\n        if (config.payer == address(0)) revert InvalidChannel();\n        if (config.receiver == address(0)) revert InvalidChannel();\n        if (config.receiverAuthorizer == address(0)) revert InvalidChannel();\n        if (config.token == address(0)) revert InvalidChannel();\n        if (config.withdrawDelay < MIN_WITHDRAW_DELAY || config.withdrawDelay > MAX_WITHDRAW_DELAY) {\n            revert WithdrawDelayOutOfRange();\n        }\n        if (amount == 0) revert ZeroDeposit();\n        if (collector == address(0)) revert InvalidCollector();\n\n        bytes32 channelId = getChannelId(config);\n        ChannelState storage ch = channels[channelId];\n\n        if (amount > type(uint128).max - ch.balance) revert DepositOverflow();\n        ch.balance += amount;\n\n        uint256 balBefore = IERC20(config.token).balanceOf(address(this));\n        IDepositCollector(collector).collect(config.payer, config.token, amount, channelId, collectorData);\n        uint256 balAfter = IERC20(config.token).balanceOf(address(this));\n        if (balAfter != balBefore + amount) revert DepositCollectionFailed();\n\n        // First deposit on this channel (escrow was empty before this deposit)\n        if (ch.balance == amount && ch.totalClaimed == 0) {\n            emit ChannelCreated(channelId, config);\n        }\n        emit Deposited(channelId, msg.sender, amount, ch.balance);\n    }\n\n    // =========================================================================\n    // Claim & Settle\n    // =========================================================================\n\n    /// @notice Applies a batch of voucher claims and updates channel accounting.\n    ///\n    /// @param voucherClaims Signed voucher rows with cumulative claim totals.\n    ///\n    /// @dev For each row, `msg.sender` must be `receiverAuthorizer` or `receiver` for that row's channel.\n    ///\n    ///      Receiver-side integrators should submit `claim` **promptly** once a payer-signed voucher should bind on-chain\n    ///      entitlement: only **recorded** claims (`totalClaimed`) reduce what the payer can withdraw. If the payer\n    ///      finalizes a timed withdrawal before this call executes, later `claim` can revert with `ClaimExceedsBalance`.\n    function claim(\n        VoucherClaim[] calldata voucherClaims\n    ) external nonReentrant {\n        if (voucherClaims.length == 0) revert EmptyBatch();\n\n        for (uint256 i = 0; i < voucherClaims.length; ++i) {\n            ChannelConfig calldata c = voucherClaims[i].voucher.channel;\n            if (!_isReceiverSide(msg.sender, c)) {\n                revert NotAuthorizedToClaim();\n            }\n            _processVoucherClaim(voucherClaims[i]);\n        }\n    }\n\n    /// @notice Applies voucher claims authorized by a `receiverAuthorizer` EIP-712 signature over the batch.\n    ///\n    /// @param voucherClaims Claim rows for channels sharing the same `receiverAuthorizer`.\n    /// @param authorizerSignature Signature from `receiverAuthorizer` over `getClaimBatchDigest(voucherClaims)`.\n    ///\n    /// @dev Callable by anyone (relay-friendly). All rows must match the same `receiverAuthorizer`.\n    ///\n    ///      Same liveness consideration as `claim`: relays should submit before payer timed withdrawal drains escrow\n    ///      (see `finalizeWithdraw` / `initiateWithdraw`).\n    function claimWithSignature(\n        VoucherClaim[] calldata voucherClaims,\n        bytes calldata authorizerSignature\n    ) external nonReentrant {\n        if (voucherClaims.length == 0) revert EmptyBatch();\n\n        address authorizer = voucherClaims[0].voucher.channel.receiverAuthorizer;\n\n        bytes32 digest = getClaimBatchDigest(voucherClaims);\n        if (!SignatureChecker.isValidSignatureNow(authorizer, digest, authorizerSignature)) {\n            revert InvalidSignature();\n        }\n\n        for (uint256 i = 0; i < voucherClaims.length; ++i) {\n            if (voucherClaims[i].voucher.channel.receiverAuthorizer != authorizer) {\n                revert NotReceiverAuthorizer();\n            }\n            _processVoucherClaim(voucherClaims[i]);\n        }\n    }\n\n    /// @notice Transfers claimed-but-not-yet-settled tokens to the receiver for a `(receiver, token)` pair.\n    ///\n    /// @param receiver The receiver address whose pending settlement is swept.\n    /// @param token The ERC-20 token to transfer.\n    ///\n    /// @dev Permissionless: typically called by the receiver or a facilitator.\n    function settle(address receiver, address token) external nonReentrant {\n        ReceiverState storage rs = receivers[receiver][token];\n        uint128 amount = rs.totalClaimed - rs.totalSettled;\n        if (amount == 0) return;\n\n        rs.totalSettled = rs.totalClaimed;\n\n        IERC20(token).safeTransfer(receiver, amount);\n\n        emit Settled(receiver, token, msg.sender, amount);\n    }\n\n    // =========================================================================\n    // Withdrawal Flow\n    // =========================================================================\n\n    /// @notice Starts the payer-side timed withdrawal window for unclaimed escrow.\n    ///\n    /// @param config The channel configuration.\n    /// @param amount The gross amount requested; may be capped on finalization.\n    ///\n    /// @dev Only `config.payer` or `config.payerAuthorizer` may call. Reverts if a withdrawal is already pending.\n    ///\n    ///      Available liquidity is `ch.balance - ch.totalClaimed` using **only** on-chain `totalClaimed`. Payer-signed\n    ///      vouchers that are not yet claimed do **not** reserve funds; receivers relying on voucher value must treat\n    ///      inclusion of `claim` during the withdrawal window as an operational requirement (RPC outages, censorship,\n    ///      or relay failure can interact badly with `finalizeWithdraw`).\n    function initiateWithdraw(ChannelConfig calldata config, uint128 amount) external nonReentrant {\n        if (msg.sender != config.payer && msg.sender != config.payerAuthorizer) {\n            revert InvalidChannel();\n        }\n        if (amount == 0) revert NothingToWithdraw();\n\n        bytes32 channelId = getChannelId(config);\n\n        WithdrawalState storage ws = pendingWithdrawals[channelId];\n        if (ws.initiatedAt != 0) revert WithdrawalAlreadyPending();\n\n        ChannelState storage ch = channels[channelId];\n        uint128 available = ch.balance - ch.totalClaimed;\n        if (amount > available) revert WithdrawAmountExceedsAvailable();\n\n        ws.amount = amount;\n        ws.initiatedAt = uint40(block.timestamp);\n\n        uint40 finalizeAfter = uint40(block.timestamp) + config.withdrawDelay;\n        emit WithdrawInitiated(channelId, amount, finalizeAfter);\n    }\n\n    /// @notice Finalizes a pending withdrawal after `withdrawDelay` and sends tokens to the payer.\n    ///\n    /// @param config The channel configuration.\n    ///\n    /// @dev Only `config.payer` or `config.payerAuthorizer` may call. Amount may be capped by available escrow.\n    ///\n    ///      Uses **current** `ch.balance` and `ch.totalClaimed` at execution time. If this transaction executes before a\n    ///      competing `claim`, it can reduce escrow such that the claim later reverts with `ClaimExceedsBalance`.\n    function finalizeWithdraw(\n        ChannelConfig calldata config\n    ) external nonReentrant {\n        if (msg.sender != config.payer && msg.sender != config.payerAuthorizer) {\n            revert NotAuthorizedToFinalizeWithdraw();\n        }\n\n        bytes32 channelId = getChannelId(config);\n        WithdrawalState storage ws = pendingWithdrawals[channelId];\n\n        if (ws.initiatedAt == 0) revert WithdrawalNotPending();\n        if (block.timestamp < uint256(ws.initiatedAt) + uint256(config.withdrawDelay)) {\n            revert WithdrawDelayNotElapsed();\n        }\n\n        ChannelState storage ch = channels[channelId];\n        uint128 available = ch.balance - ch.totalClaimed;\n        uint128 withdrawAmount = ws.amount > available ? available : ws.amount;\n\n        ws.amount = 0;\n        ws.initiatedAt = 0;\n        ch.balance -= withdrawAmount;\n\n        emit WithdrawFinalized(channelId, msg.sender, withdrawAmount);\n\n        if (ch.balance == 0 && ch.totalClaimed == 0) {\n            emit ChannelClosed(channelId, config);\n        }\n\n        if (withdrawAmount > 0) {\n            IERC20(config.token).safeTransfer(config.payer, withdrawAmount);\n        }\n    }\n\n    /// @notice Cooperative refund of unclaimed escrow to the payer.\n    ///\n    /// @param config The channel configuration.\n    /// @param amount Requested refund; capped to `balance - totalClaimed`. Reverts with `ZeroRefund` if `amount == 0`.\n    ///               If the capped amount is zero but `amount > 0`, no token transfer occurs (no `Refunded` event)\n    ///               yet `refundNonce` still advances (see `_executeRefund`).\n    ///\n    /// @dev Only `receiverAuthorizer` or `receiver` may call. Shares `_executeRefund` with `refundWithSignature`, so\n    ///      every successful call advances `refundNonce` for the channel. Any in-flight EIP-712 `Refund` signature\n    ///      produced for the previous nonce becomes unusable; relayers and authorizers should expect re-signing if\n    ///      direct refunds race ahead of relayed `refundWithSignature` submissions.\n    function refund(ChannelConfig calldata config, uint128 amount) external nonReentrant {\n        if (!_isReceiverSide(msg.sender, config)) {\n            revert NotAuthorizedToRefund();\n        }\n        _executeRefund(config, amount);\n    }\n\n    /// @notice Refunds unclaimed escrow to the payer using an EIP-712 `Refund` signature from `receiverAuthorizer`.\n    ///\n    /// @param config The channel configuration.\n    /// @param amount The amount in the signature; capped like `refund`. If the capped amount is zero, no transfer\n    ///               and no `Refunded` event, but `refundNonce` still advances once `_executeRefund` runs.\n    /// @param nonce Must equal `refundNonce(channelId)` at entry; `_executeRefund` increments it (same as `refund`).\n    /// @param receiverAuthorizerSignature EIP-712 signature from `receiverAuthorizer` over the refund digest.\n    ///\n    /// @dev Callable by anyone (relay-friendly). A prior direct `refund` on the same channel can advance the nonce\n    ///      and cause `InvalidRefundNonce` here until the authorizer signs at the new nonce.\n    function refundWithSignature(\n        ChannelConfig calldata config,\n        uint128 amount,\n        uint256 nonce,\n        bytes calldata receiverAuthorizerSignature\n    ) external nonReentrant {\n        bytes32 channelId = getChannelId(config);\n        if (nonce != refundNonce[channelId]) revert InvalidRefundNonce();\n        bytes32 digest = getRefundDigest(channelId, nonce, amount);\n        if (!SignatureChecker.isValidSignatureNow(config.receiverAuthorizer, digest, receiverAuthorizerSignature)) {\n            revert InvalidSignature();\n        }\n        _executeRefund(config, amount);\n    }\n\n    // =========================================================================\n    // View Functions\n    // =========================================================================\n\n    /// @notice Returns the canonical `channelId` for a channel configuration.\n    ///\n    /// @param config The channel configuration to hash.\n    ///\n    /// @return The EIP-712 typed-data hash of `ChannelConfig`, bound to this contract's domain\n    ///         (chainId + verifyingContract). Identical configs on different chains or different\n    ///         deployments produce different ids, preventing cross-chain channel-state collision.\n    function getChannelId(\n        ChannelConfig calldata config\n    ) public view returns (bytes32) {\n        return _hashTypedDataV4(keccak256(abi.encode(CHANNEL_CONFIG_TYPEHASH, config)));\n    }\n\n    /// @notice EIP-712 digest for a `Voucher` with the given `channelId` and `maxClaimableAmount`.\n    ///\n    /// @param channelId The channel identifier.\n    /// @param maxClaimableAmount The ceiling encoded in the voucher.\n    ///\n    /// @return The typed data hash signers use for payer authorization.\n    function getVoucherDigest(bytes32 channelId, uint128 maxClaimableAmount) public view returns (bytes32) {\n        return _hashTypedDataV4(keccak256(abi.encode(VOUCHER_TYPEHASH, channelId, maxClaimableAmount)));\n    }\n\n    /// @notice EIP-712 digest for a cooperative `Refund` authorization.\n    ///\n    /// @param channelId The channel identifier.\n    /// @param nonce The refund nonce; must equal on-chain `refundNonce(channelId)` when `refundWithSignature` runs.\n    /// @param amount The signed refund amount.\n    ///\n    /// @return The typed data hash for `receiverAuthorizer` to sign.\n    ///\n    /// @dev Off-chain signers should use the current `refundNonce(channelId)` as `nonce`. A successful direct `refund`\n    ///      on the same channel advances that nonce and invalidates digests signed for the old value until re-signed.\n    function getRefundDigest(bytes32 channelId, uint256 nonce, uint128 amount) public view returns (bytes32) {\n        return _hashTypedDataV4(keccak256(abi.encode(REFUND_TYPEHASH, channelId, nonce, amount)));\n    }\n\n    /// @notice EIP-712 digest for the signed `ClaimBatch` (used by `claimWithSignature` and off-chain signing).\n    ///\n    /// @param voucherClaims The claim rows hashed into the batch.\n    ///\n    /// @return The typed data hash `receiverAuthorizer` signs for the batch.\n    ///\n    /// @dev `claim` and `claimWithSignature` revert with `EmptyBatch()` when `voucherClaims.length == 0`, so they\n    ///      never call this with an empty array. The digest for `length == 0` is still defined (`entriesRoot = keccak256(\"\")`)\n    ///      for `eth_call` and off-chain tools to match this contract’s EIP-712 encoding without duplicating hashing logic.\n    function getClaimBatchDigest(\n        VoucherClaim[] calldata voucherClaims\n    ) public view returns (bytes32) {\n        uint256 n = voucherClaims.length;\n        bytes32 entriesRoot;\n        if (n == 0) {\n            entriesRoot = keccak256(\"\");\n        } else {\n            bytes32[] memory entryHashes = new bytes32[](n);\n            for (uint256 i = 0; i < n; ++i) {\n                bytes32 cid = getChannelId(voucherClaims[i].voucher.channel);\n                entryHashes[i] = keccak256(\n                    abi.encode(\n                        CLAIM_ENTRY_TYPEHASH,\n                        cid,\n                        voucherClaims[i].voucher.maxClaimableAmount,\n                        voucherClaims[i].totalClaimed\n                    )\n                );\n            }\n            entriesRoot = keccak256(abi.encodePacked(entryHashes));\n        }\n        return _hashTypedDataV4(keccak256(abi.encode(CLAIM_BATCH_TYPEHASH, entriesRoot)));\n    }\n\n    // =========================================================================\n    // Internal Helpers\n    // =========================================================================\n\n    /// @dev True if `sender` may submit a claim for this channel (`receiver` or `receiverAuthorizer`).\n    function _isReceiverSide(address sender, ChannelConfig calldata config) internal pure returns (bool) {\n        return sender == config.receiverAuthorizer || sender == config.receiver;\n    }\n\n    /// @dev Validates the payer signature, updates `channels` and `receivers`, and emits `Claimed`.\n    function _processVoucherClaim(\n        VoucherClaim calldata vc\n    ) internal {\n        bytes32 channelId = getChannelId(vc.voucher.channel);\n        ChannelState storage ch = channels[channelId];\n\n        if (vc.totalClaimed <= ch.totalClaimed) return;\n        if (vc.totalClaimed > vc.voucher.maxClaimableAmount) {\n            revert ClaimExceedsCeiling();\n        }\n        if (vc.totalClaimed > ch.balance) revert ClaimExceedsBalance();\n\n        bytes32 digest = getVoucherDigest(channelId, vc.voucher.maxClaimableAmount);\n\n        address payerAuth = vc.voucher.channel.payerAuthorizer;\n        if (payerAuth != address(0)) {\n            address recovered = ECDSA.recoverCalldata(digest, vc.signature);\n            if (recovered != payerAuth) revert InvalidSignature();\n        } else {\n            if (!SignatureChecker.isValidSignatureNow(vc.voucher.channel.payer, digest, vc.signature)) {\n                revert InvalidSignature();\n            }\n        }\n\n        uint128 claimDelta = vc.totalClaimed - ch.totalClaimed;\n        ch.totalClaimed = vc.totalClaimed;\n        receivers[vc.voucher.channel.receiver][vc.voucher.channel.token].totalClaimed += claimDelta;\n\n        emit Claimed(channelId, msg.sender, claimDelta, vc.totalClaimed);\n    }\n\n    /// @dev Caps refund to available unclaimed escrow, reduces or clears any pending withdrawal, transfers to payer.\n    ///\n    /// @dev Increments `refundNonce[channelId]` **first** (before computing the capped refund). That applies to both\n    ///      `refund` and `refundWithSignature`, including when `amount > 0` but available unclaimed escrow is zero\n    ///      (no transfer, no `Refunded` event). This ties replay protection for signed refunds to the same counter\n    ///      used whenever the receiver side executes a cooperative refund through this helper. `amount == 0` reverts\n    ///      with `ZeroRefund` and does not bump the nonce.\n    function _executeRefund(ChannelConfig calldata config, uint128 amount) internal {\n        if (amount == 0) revert ZeroRefund();\n\n        bytes32 channelId = getChannelId(config);\n        unchecked {\n            refundNonce[channelId]++;\n        }\n\n        ChannelState storage ch = channels[channelId];\n        uint128 available = ch.balance - ch.totalClaimed;\n        uint128 refundAmount = amount > available ? available : amount;\n        if (refundAmount == 0) return;\n\n        ch.balance -= refundAmount;\n\n        WithdrawalState storage pws = pendingWithdrawals[channelId];\n        if (pws.initiatedAt != 0) {\n            if (refundAmount >= pws.amount) {\n                pws.amount = 0;\n                pws.initiatedAt = 0;\n            } else {\n                pws.amount -= refundAmount;\n            }\n        }\n\n        emit Refunded(channelId, msg.sender, refundAmount);\n\n        if (ch.balance == 0 && ch.totalClaimed == 0) {\n            emit ChannelClosed(channelId, config);\n        }\n\n        IERC20(config.token).safeTransfer(config.payer, refundAmount);\n    }\n}\n"},"src/interfaces/IDepositCollector.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.20;\n\n/// @title IDepositCollector\n/// @notice Interface for pluggable deposit collectors used by x402BatchSettlement.\n/// @dev Collectors handle the token transfer mechanics (ERC-3009, Permit2, etc.)\n///      while `x402BatchSettlement` verifies actual token receipt via balance checks.\n///      Collectors MUST transfer tokens to `msg.sender` (the calling `x402BatchSettlement`).\ninterface IDepositCollector {\n    /// @notice Pull tokens from payer to the calling `x402BatchSettlement` contract.\n    /// @param payer The address that owns the tokens being deposited\n    /// @param token The ERC-20 token address\n    /// @param amount The exact amount of tokens to transfer\n    /// @param channelId The channel identifier (used by Permit2 collectors for witness binding)\n    /// @param collectorData Opaque bytes containing collector-specific parameters (signatures, nonces, etc.)\n    function collect(\n        address payer,\n        address token,\n        uint256 amount,\n        bytes32 channelId,\n        bytes calldata collectorData\n    ) external;\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Bytes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Bytes.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\n\n/**\n * @dev Bytes operations.\n */\nlibrary Bytes {\n    /**\n     * @dev Forward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the first instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return indexOf(buffer, s, 0);\n    }\n\n    /**\n     * @dev Forward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or after `pos`), returns the index of the next instance\n     * * If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`]\n     */\n    function indexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        uint256 length = buffer.length;\n        for (uint256 i = pos; i < length; ++i) {\n            if (bytes1(_unsafeReadBytesOffset(buffer, i)) == s) {\n                return i;\n            }\n        }\n        return type(uint256).max;\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer`\n     * * If `s` is present in the buffer, returns the index of the last instance\n     * * If `s` is not present in the buffer, returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s) internal pure returns (uint256) {\n        return lastIndexOf(buffer, s, type(uint256).max);\n    }\n\n    /**\n     * @dev Backward search for `s` in `buffer` starting at position `pos`\n     * * If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance\n     * * If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`]\n     */\n    function lastIndexOf(bytes memory buffer, bytes1 s, uint256 pos) internal pure returns (uint256) {\n        unchecked {\n            uint256 length = buffer.length;\n            for (uint256 i = Math.min(Math.saturatingAdd(pos, 1), length); i > 0; --i) {\n                if (bytes1(_unsafeReadBytesOffset(buffer, i - 1)) == s) {\n                    return i - 1;\n                }\n            }\n            return type(uint256).max;\n        }\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in\n     * memory.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return slice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in\n     * memory. The `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`]\n     */\n    function slice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        bytes memory result = new bytes(end - start);\n        assembly (\"memory-safe\") {\n            mcopy(add(result, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to the end of `buffer` to the start of that buffer.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]\n     */\n    function splice(bytes memory buffer, uint256 start) internal pure returns (bytes memory) {\n        return splice(buffer, start, buffer.length);\n    }\n\n    /**\n     * @dev Moves the content of `buffer`, from `start` (included) to end (excluded) to the start of that buffer. The\n     * `end` argument is truncated to the length of the `buffer`.\n     *\n     * NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use {slice} instead\n     * NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice[Javascript's `Array.splice`]\n     */\n    function splice(bytes memory buffer, uint256 start, uint256 end) internal pure returns (bytes memory) {\n        // sanitize\n        end = Math.min(end, buffer.length);\n        start = Math.min(start, end);\n\n        // allocate and copy\n        assembly (\"memory-safe\") {\n            mcopy(add(buffer, 0x20), add(add(buffer, 0x20), start), sub(end, start))\n            mstore(buffer, sub(end, start))\n        }\n\n        return buffer;\n    }\n\n    /**\n     * @dev Concatenate an array of bytes into a single bytes object.\n     *\n     * For fixed bytes types, we recommend using the solidity built-in `bytes.concat` or (equivalent)\n     * `abi.encodePacked`.\n     *\n     * NOTE: this could be done in assembly with a single loop that expands starting at the FMP, but that would be\n     * significantly less readable. It might be worth benchmarking the savings of the full-assembly approach.\n     */\n    function concat(bytes[] memory buffers) internal pure returns (bytes memory) {\n        uint256 length = 0;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            length += buffers[i].length;\n        }\n\n        bytes memory result = new bytes(length);\n\n        uint256 offset = 0x20;\n        for (uint256 i = 0; i < buffers.length; ++i) {\n            bytes memory input = buffers[i];\n            assembly (\"memory-safe\") {\n                mcopy(add(result, offset), add(input, 0x20), mload(input))\n            }\n            unchecked {\n                offset += input.length;\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * @dev Returns true if the two byte buffers are equal.\n     */\n    function equal(bytes memory a, bytes memory b) internal pure returns (bool) {\n        return a.length == b.length && keccak256(a) == keccak256(b);\n    }\n\n    /**\n     * @dev Reverses the byte order of a bytes32 value, converting between little-endian and big-endian.\n     * Inspired by https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel[Reverse Parallel]\n     */\n    function reverseBytes32(bytes32 value) internal pure returns (bytes32) {\n        value = // swap bytes\n            ((value >> 8) & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value >> 16) & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value >> 32) & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        value = // swap 8-byte long pairs\n            ((value >> 64) & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) |\n            ((value & 0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) << 64);\n        return (value >> 128) | (value << 128); // swap 16-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 128-bit values.\n    function reverseBytes16(bytes16 value) internal pure returns (bytes16) {\n        value = // swap bytes\n            ((value & 0xFF00FF00FF00FF00FF00FF00FF00FF00) >> 8) |\n            ((value & 0x00FF00FF00FF00FF00FF00FF00FF00FF) << 8);\n        value = // swap 2-byte long pairs\n            ((value & 0xFFFF0000FFFF0000FFFF0000FFFF0000) >> 16) |\n            ((value & 0x0000FFFF0000FFFF0000FFFF0000FFFF) << 16);\n        value = // swap 4-byte long pairs\n            ((value & 0xFFFFFFFF00000000FFFFFFFF00000000) >> 32) |\n            ((value & 0x00000000FFFFFFFF00000000FFFFFFFF) << 32);\n        return (value >> 64) | (value << 64); // swap 8-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 64-bit values.\n    function reverseBytes8(bytes8 value) internal pure returns (bytes8) {\n        value = ((value & 0xFF00FF00FF00FF00) >> 8) | ((value & 0x00FF00FF00FF00FF) << 8); // swap bytes\n        value = ((value & 0xFFFF0000FFFF0000) >> 16) | ((value & 0x0000FFFF0000FFFF) << 16); // swap 2-byte long pairs\n        return (value >> 32) | (value << 32); // swap 4-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 32-bit values.\n    function reverseBytes4(bytes4 value) internal pure returns (bytes4) {\n        value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8); // swap bytes\n        return (value >> 16) | (value << 16); // swap 2-byte long pairs\n    }\n\n    /// @dev Same as {reverseBytes32} but optimized for 16-bit values.\n    function reverseBytes2(bytes2 value) internal pure returns (bytes2) {\n        return (value >> 8) | (value << 8);\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits a bytes array. Returns `8 * buffer.length`\n     * if the buffer is all zeros.\n     */\n    function clz(bytes memory buffer) internal pure returns (uint256) {\n        for (uint256 i = 0; i < buffer.length; i += 0x20) {\n            bytes32 chunk = _unsafeReadBytesOffset(buffer, i);\n            if (chunk != bytes32(0)) {\n                return Math.min(8 * i + Math.clz(uint256(chunk)), 8 * buffer.length);\n            }\n        }\n        return 8 * buffer.length;\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Helper library for emitting standardized panic codes.\n *\n * ```solidity\n * contract Example {\n *      using Panic for uint256;\n *\n *      // Use any of the declared internal constants\n *      function foo() { Panic.GENERIC.panic(); }\n *\n *      // Alternatively\n *      function foo() { Panic.panic(Panic.GENERIC); }\n * }\n * ```\n *\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\n *\n * _Available since v5.1._\n */\n// slither-disable-next-line unused-state\nlibrary Panic {\n    /// @dev generic / unspecified error\n    uint256 internal constant GENERIC = 0x00;\n    /// @dev used by the assert() builtin\n    uint256 internal constant ASSERT = 0x01;\n    /// @dev arithmetic underflow or overflow\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\n    /// @dev division or modulo by zero\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\n    /// @dev enum conversion error\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\n    /// @dev invalid encoding in storage\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\n    /// @dev empty array pop\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\n    /// @dev array out of bounds access\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\n    /// @dev resource error (too large allocation or too large array)\n    uint256 internal constant RESOURCE_ERROR = 0x41;\n    /// @dev calling invalid internal function\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\n\n    /// @dev Reverts with a panic code. Recommended to use with\n    /// the internal constants with predefined codes.\n    function panic(uint256 code) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0x00, 0x4e487b71)\n            mstore(0x20, code)\n            revert(0x1c, 0x24)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Errors.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\nimport {LowLevelCall} from \"./LowLevelCall.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n        if (LowLevelCall.callNoReturn(recipient, amount, \"\")) {\n            // call successful, nothing to do\n            return;\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {Errors.FailedCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        bool success = LowLevelCall.callNoReturn(target, value, data);\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\n            return LowLevelCall.returnData();\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        bool success = LowLevelCall.staticcallNoReturn(target, data);\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\n            return LowLevelCall.returnData();\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        bool success = LowLevelCall.delegatecallNoReturn(target, data);\n        if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) {\n            return LowLevelCall.returnData();\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (LowLevelCall.returnDataSize() > 0) {\n            LowLevelCall.bubbleRevert();\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\n     * of an unsuccessful call.\n     *\n     * NOTE: This function is DEPRECATED and may be removed in the next major release.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        // only check if target is a contract if the call was successful and the return data is empty\n        // otherwise we already know that it was a contract\n        if (success && (returndata.length > 0 || target.code.length > 0)) {\n            return returndata;\n        } else if (success) {\n            revert AddressEmptyCode(target);\n        } else if (returndata.length > 0) {\n            LowLevelCall.bubbleRevert(returndata);\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {Errors.FailedCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else if (returndata.length > 0) {\n            LowLevelCall.bubbleRevert(returndata);\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Strings.sol)\n\npragma solidity ^0.8.24;\n\nimport {Math} from \"./math/Math.sol\";\nimport {SafeCast} from \"./math/SafeCast.sol\";\nimport {SignedMath} from \"./math/SignedMath.sol\";\nimport {Bytes} from \"./Bytes.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    using SafeCast for *;\n\n    bytes16 private constant HEX_DIGITS = \"0123456789abcdef\";\n    uint8 private constant ADDRESS_LENGTH = 20;\n    uint256 private constant SPECIAL_CHARS_LOOKUP =\n        (1 << 0x08) | // backspace\n            (1 << 0x09) | // tab\n            (1 << 0x0a) | // newline\n            (1 << 0x0c) | // form feed\n            (1 << 0x0d) | // carriage return\n            (1 << 0x22) | // double quote\n            (1 << 0x5c); // backslash\n\n    /**\n     * @dev The `value` string doesn't fit in the specified `length`.\n     */\n    error StringsInsufficientHexLength(uint256 value, uint256 length);\n\n    /**\n     * @dev The string being parsed contains characters that are not in scope of the given base.\n     */\n    error StringsInvalidChar();\n\n    /**\n     * @dev The string being parsed is not a properly formatted address.\n     */\n    error StringsInvalidAddressFormat();\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            assembly (\"memory-safe\") {\n                ptr := add(add(buffer, 0x20), length)\n            }\n            while (true) {\n                ptr--;\n                assembly (\"memory-safe\") {\n                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toStringSigned(int256 value) internal pure returns (string memory) {\n        return string.concat(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value)));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        uint256 localValue = value;\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = HEX_DIGITS[localValue & 0xf];\n            localValue >>= 4;\n        }\n        if (localValue != 0) {\n            revert StringsInsufficientHexLength(value, length);\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\n     * representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal\n     * representation, according to EIP-55.\n     */\n    function toChecksumHexString(address addr) internal pure returns (string memory) {\n        bytes memory buffer = bytes(toHexString(addr));\n\n        // hash the hex part of buffer (skip length + 2 bytes, length 40)\n        uint256 hashValue;\n        assembly (\"memory-safe\") {\n            hashValue := shr(96, keccak256(add(buffer, 0x22), 40))\n        }\n\n        for (uint256 i = 41; i > 1; --i) {\n            // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f)\n            if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) {\n                // case shift by xoring with 0x20\n                buffer[i] ^= 0x20;\n            }\n            hashValue >>= 4;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `bytes` buffer to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(bytes memory input) internal pure returns (string memory) {\n        unchecked {\n            bytes memory buffer = new bytes(2 * input.length + 2);\n            buffer[0] = \"0\";\n            buffer[1] = \"x\";\n            for (uint256 i = 0; i < input.length; ++i) {\n                uint8 v = uint8(input[i]);\n                buffer[2 * i + 2] = HEX_DIGITS[v >> 4];\n                buffer[2 * i + 3] = HEX_DIGITS[v & 0xf];\n            }\n            return string(buffer);\n        }\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return Bytes.equal(bytes(a), bytes(b));\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input) internal pure returns (uint256) {\n        return parseUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[0-9]*`\n     * - The result must fit into an `uint256` type\n     */\n    function parseUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseUint-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        uint256 result = 0;\n        for (uint256 i = begin; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 9) return (false, 0);\n            result *= 10;\n            result += chr;\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a decimal string and returns the value as a `int256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input) internal pure returns (int256) {\n        return parseInt(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `[-+]?[0-9]*`\n     * - The result must fit in an `int256` type.\n     */\n    function parseInt(string memory input, uint256 begin, uint256 end) internal pure returns (int256) {\n        (bool success, int256 value) = tryParseInt(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseInt-string} that returns false if the parsing fails because of an invalid character or if\n     * the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(string memory input) internal pure returns (bool success, int256 value) {\n        return _tryParseIntUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    uint256 private constant ABS_MIN_INT256 = 2 ** 255;\n\n    /**\n     * @dev Variant of {parseInt-string-uint256-uint256} that returns false if the parsing fails because of an invalid\n     * character or if the result does not fit in a `int256`.\n     *\n     * NOTE: This function will revert if the absolute value of the result does not fit in a `uint256`.\n     */\n    function tryParseInt(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, int256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseIntUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseIntUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, int256 value) {\n        bytes memory buffer = bytes(input);\n\n        // Check presence of a negative sign.\n        bytes1 sign = begin == end ? bytes1(0) : bytes1(_unsafeReadBytesOffset(buffer, begin)); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        bool positiveSign = sign == bytes1(\"+\");\n        bool negativeSign = sign == bytes1(\"-\");\n        uint256 offset = (positiveSign || negativeSign).toUint();\n\n        (bool absSuccess, uint256 absValue) = tryParseUint(input, begin + offset, end);\n\n        if (absSuccess && absValue < ABS_MIN_INT256) {\n            return (true, negativeSign ? -int256(absValue) : int256(absValue));\n        } else if (absSuccess && negativeSign && absValue == ABS_MIN_INT256) {\n            return (true, type(int256).min);\n        } else return (false, 0);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as a `uint256`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input) internal pure returns (uint256) {\n        return parseHexUint(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]*`\n     * - The result must fit in an `uint256` type.\n     */\n    function parseHexUint(string memory input, uint256 begin, uint256 end) internal pure returns (uint256) {\n        (bool success, uint256 value) = tryParseHexUint(input, begin, end);\n        if (!success) revert StringsInvalidChar();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string} that returns false if the parsing fails because of an invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(string memory input) internal pure returns (bool success, uint256 value) {\n        return _tryParseHexUintUncheckedBounds(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseHexUint-string-uint256-uint256} that returns false if the parsing fails because of an\n     * invalid character.\n     *\n     * NOTE: This function will revert if the result does not fit in a `uint256`.\n     */\n    function tryParseHexUint(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, uint256 value) {\n        if (end > bytes(input).length || begin > end) return (false, 0);\n        return _tryParseHexUintUncheckedBounds(input, begin, end);\n    }\n\n    /**\n     * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that\n     * `begin <= end <= input.length`. Other inputs would result in undefined behavior.\n     */\n    function _tryParseHexUintUncheckedBounds(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) private pure returns (bool success, uint256 value) {\n        bytes memory buffer = bytes(input);\n\n        // skip 0x prefix if present\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(buffer, begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 offset = hasPrefix.toUint() * 2;\n\n        uint256 result = 0;\n        for (uint256 i = begin + offset; i < end; ++i) {\n            uint8 chr = _tryParseChr(bytes1(_unsafeReadBytesOffset(buffer, i)));\n            if (chr > 15) return (false, 0);\n            result *= 16;\n            unchecked {\n                // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check).\n                // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked.\n                result += chr;\n            }\n        }\n        return (true, result);\n    }\n\n    /**\n     * @dev Parse a hexadecimal string (with or without \"0x\" prefix), and returns the value as an `address`.\n     *\n     * Requirements:\n     * - The string must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input) internal pure returns (address) {\n        return parseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and\n     * `end` (excluded).\n     *\n     * Requirements:\n     * - The substring must be formatted as `(0x)?[0-9a-fA-F]{40}`\n     */\n    function parseAddress(string memory input, uint256 begin, uint256 end) internal pure returns (address) {\n        (bool success, address value) = tryParseAddress(input, begin, end);\n        if (!success) revert StringsInvalidAddressFormat();\n        return value;\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly\n     * formatted address. See {parseAddress-string} requirements.\n     */\n    function tryParseAddress(string memory input) internal pure returns (bool success, address value) {\n        return tryParseAddress(input, 0, bytes(input).length);\n    }\n\n    /**\n     * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly\n     * formatted address. See {parseAddress-string-uint256-uint256} requirements.\n     */\n    function tryParseAddress(\n        string memory input,\n        uint256 begin,\n        uint256 end\n    ) internal pure returns (bool success, address value) {\n        if (end > bytes(input).length || begin > end) return (false, address(0));\n\n        bool hasPrefix = (end > begin + 1) && bytes2(_unsafeReadBytesOffset(bytes(input), begin)) == bytes2(\"0x\"); // don't do out-of-bound (possibly unsafe) read if sub-string is empty\n        uint256 expectedLength = 40 + hasPrefix.toUint() * 2;\n\n        // check that input is the correct length\n        if (end - begin == expectedLength) {\n            // length guarantees that this does not overflow, and value is at most type(uint160).max\n            (bool s, uint256 v) = _tryParseHexUintUncheckedBounds(input, begin, end);\n            return (s, address(uint160(v)));\n        } else {\n            return (false, address(0));\n        }\n    }\n\n    function _tryParseChr(bytes1 chr) private pure returns (uint8) {\n        uint8 value = uint8(chr);\n\n        // Try to parse `chr`:\n        // - Case 1: [0-9]\n        // - Case 2: [a-f]\n        // - Case 3: [A-F]\n        // - otherwise not supported\n        unchecked {\n            if (value > 47 && value < 58) value -= 48;\n            else if (value > 96 && value < 103) value -= 87;\n            else if (value > 64 && value < 71) value -= 55;\n            else return type(uint8).max;\n        }\n\n        return value;\n    }\n\n    /**\n     * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.\n     *\n     * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped.\n     *\n     * NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of\n     * RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's `JSON.parse` does recover escaped unicode\n     * characters that are not in this range, but other tooling may provide different results.\n     */\n    function escapeJSON(string memory input) internal pure returns (string memory) {\n        bytes memory buffer = bytes(input);\n        bytes memory output = new bytes(2 * buffer.length); // worst case scenario\n        uint256 outputLength = 0;\n\n        for (uint256 i = 0; i < buffer.length; ++i) {\n            bytes1 char = bytes1(_unsafeReadBytesOffset(buffer, i));\n            if (((SPECIAL_CHARS_LOOKUP & (1 << uint8(char))) != 0)) {\n                output[outputLength++] = \"\\\\\";\n                if (char == 0x08) output[outputLength++] = \"b\";\n                else if (char == 0x09) output[outputLength++] = \"t\";\n                else if (char == 0x0a) output[outputLength++] = \"n\";\n                else if (char == 0x0c) output[outputLength++] = \"f\";\n                else if (char == 0x0d) output[outputLength++] = \"r\";\n                else if (char == 0x5c) output[outputLength++] = \"\\\\\";\n                else if (char == 0x22) {\n                    // solhint-disable-next-line quotes\n                    output[outputLength++] = '\"';\n                }\n            } else {\n                output[outputLength++] = char;\n            }\n        }\n        // write the actual length and deallocate unused memory\n        assembly (\"memory-safe\") {\n            mstore(output, outputLength)\n            mstore(0x40, add(output, shl(5, shr(5, add(outputLength, 63)))))\n        }\n\n        return string(output);\n    }\n\n    /**\n     * @dev Reads a bytes32 from a bytes array without bounds checking.\n     *\n     * NOTE: making this function internal would mean it could be used with memory unsafe offset, and marking the\n     * assembly block as such would prevent some optimizations.\n     */\n    function _unsafeReadBytesOffset(bytes memory buffer, uint256 offset) private pure returns (bytes32 value) {\n        // This is not memory safe in the general case, but all calls to this private function are within bounds.\n        assembly (\"memory-safe\") {\n            value := mload(add(add(buffer, 0x20), offset))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Multicall.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/Multicall.sol)\n\npragma solidity ^0.8.20;\n\nimport {Address} from \"./Address.sol\";\nimport {Context} from \"./Context.sol\";\n\n/**\n * @dev Provides a function to batch together multiple calls in a single external call.\n *\n * Consider any assumption about calldata validation performed by the sender may be violated if it's not especially\n * careful about sending transactions invoking {multicall}. For example, a relay address that filters function\n * selectors won't filter calls nested within a {multicall} operation.\n *\n * NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {Context-_msgSender}).\n * If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data`\n * to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of\n * {Context-_msgSender} are not propagated to subcalls.\n */\nabstract contract Multicall is Context {\n    /**\n     * @dev Receives and executes a batch of function calls on this contract.\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n     */\n    function multicall(bytes[] calldata data) public virtual returns (bytes[] memory results) {\n        bytes memory context = msg.sender == _msgSender()\n            ? new bytes(0)\n            : msg.data[msg.data.length - _contextSuffixLength():];\n\n        results = new bytes[](data.length);\n        for (uint256 i = 0; i < data.length; i++) {\n            results[i] = Address.functionDelegateCall(address(this), bytes.concat(data[i], context));\n        }\n        return results;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.20;\n\nimport {Panic} from \"../Panic.sol\";\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Floor, // Toward negative infinity\n        Ceil, // Toward positive infinity\n        Trunc, // Toward zero\n        Expand // Away from zero\n    }\n\n    /**\n     * @dev Return the 512-bit addition of two uint256.\n     *\n     * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.\n     */\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        assembly (\"memory-safe\") {\n            low := add(a, b)\n            high := lt(low, a)\n        }\n    }\n\n    /**\n     * @dev Return the 512-bit multiplication of two uint256.\n     *\n     * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.\n     */\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n        // variables such that product = high * 2²⁵⁶ + low.\n        assembly (\"memory-safe\") {\n            let mm := mulmod(a, b, not(0))\n            low := mul(a, b)\n            high := sub(sub(mm, low), lt(mm, low))\n        }\n    }\n\n    /**\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a + b;\n            success = c >= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\n     */\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a - b;\n            success = c <= a;\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\n     */\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            uint256 c = a * b;\n            assembly (\"memory-safe\") {\n                // Only true when the multiplication doesn't overflow\n                // (c / a == b) || (a == 0)\n                success := or(eq(div(c, a), b), iszero(a))\n            }\n            // equivalent to: success ? c : 0\n            result = c * SafeCast.toUint(success);\n        }\n    }\n\n    /**\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `DIV` opcode returns zero when the denominator is 0.\n                result := div(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\n     */\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\n        unchecked {\n            success = b > 0;\n            assembly (\"memory-safe\") {\n                // The `MOD` opcode returns zero when the denominator is 0.\n                result := mod(a, b)\n            }\n        }\n    }\n\n    /**\n     * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryAdd(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\n     */\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\n        (, uint256 result) = trySub(a, b);\n        return result;\n    }\n\n    /**\n     * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.\n     */\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        (bool success, uint256 result) = tryMul(a, b);\n        return ternary(success, result, type(uint256).max);\n    }\n\n    /**\n     * @dev Branchless ternary evaluation for `condition ? a : b`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `condition ? a : b`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds towards infinity instead\n     * of rounding towards zero.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (b == 0) {\n            // Guarantee the same behavior as in a regular Solidity division.\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n\n        // The following calculation ensures accurate ceiling division without overflow.\n        // Since a is non-zero, (a - 1) / b will not overflow.\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\n        // when a = type(uint256).max and b = 1.\n        unchecked {\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\n        }\n    }\n\n    /**\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\n     * denominator == 0.\n     *\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\n     * Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (high == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return low / denominator;\n            }\n\n            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.\n            if (denominator <= high) {\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\n            }\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [high low].\n            uint256 remainder;\n            assembly (\"memory-safe\") {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                high := sub(high, gt(remainder, low))\n                low := sub(low, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\n\n            uint256 twos = denominator & (0 - denominator);\n            assembly (\"memory-safe\") {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [high low] by twos.\n                low := div(low, twos)\n\n                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from high into low.\n            low |= high * twos;\n\n            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such\n            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\n            // works in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶\n            inverse *= 2 - denominator * inverse; // inverse mod 2³²\n            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴\n            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸\n            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is\n            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high\n            // is no longer required.\n            result = low * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\n    }\n\n    /**\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\n        unchecked {\n            (uint256 high, uint256 low) = mul512(x, y);\n            if (high >= 1 << n) {\n                Panic.panic(Panic.UNDER_OVERFLOW);\n            }\n            return (high << (256 - n)) | (low >> n);\n        }\n    }\n\n    /**\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\n     */\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\n    }\n\n    /**\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\n     *\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\n     *\n     * If the input value is not inversible, 0 is returned.\n     *\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\n     */\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\n        unchecked {\n            if (n == 0) return 0;\n\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\n            // ax + ny = 1\n            // ax = 1 + (-y)n\n            // ax ≡ 1 (mod n) # x is the inverse of a modulo n\n\n            // If the remainder is 0 the gcd is n right away.\n            uint256 remainder = a % n;\n            uint256 gcd = n;\n\n            // Therefore the initial coefficients are:\n            // ax + ny = gcd(a, n) = n\n            // 0a + 1n = n\n            int256 x = 0;\n            int256 y = 1;\n\n            while (remainder != 0) {\n                uint256 quotient = gcd / remainder;\n\n                (gcd, remainder) = (\n                    // The old remainder is the next gcd to try.\n                    remainder,\n                    // Compute the next remainder.\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\n                    // where gcd is at most n (capped to type(uint256).max)\n                    gcd - remainder * quotient\n                );\n\n                (x, y) = (\n                    // Increment the coefficient of a.\n                    y,\n                    // Decrement the coefficient of n.\n                    // Can overflow, but the result is casted to uint256 so that the\n                    // next value of y is \"wrapped around\" to a value between 0 and n - 1.\n                    x - y * int256(quotient)\n                );\n            }\n\n            if (gcd != 1) return 0; // No inverse exists.\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\n        }\n    }\n\n    /**\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\n     *\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\n     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\n     *\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\n     */\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\n        unchecked {\n            return Math.modExp(a, p - 2, p);\n        }\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\n     *\n     * Requirements:\n     * - modulus can't be zero\n     * - underlying staticcall to precompile must succeed\n     *\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\n     * interpreted as 0.\n     */\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\n        (bool success, uint256 result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\n     * to operate modulo 0 or if the underlying precompile reverted.\n     *\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\n     * of a revert, but the result may be incorrectly interpreted as 0.\n     */\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\n        if (m == 0) return (false, 0);\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            // | Offset    | Content    | Content (Hex)                                                      |\n            // |-----------|------------|--------------------------------------------------------------------|\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\n            mstore(ptr, 0x20)\n            mstore(add(ptr, 0x20), 0x20)\n            mstore(add(ptr, 0x40), 0x20)\n            mstore(add(ptr, 0x60), b)\n            mstore(add(ptr, 0x80), e)\n            mstore(add(ptr, 0xa0), m)\n\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\n            // so we can use the memory scratch space located at offset 0.\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\n            result := mload(0x00)\n        }\n    }\n\n    /**\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\n     */\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\n        (bool success, bytes memory result) = tryModExp(b, e, m);\n        if (!success) {\n            Panic.panic(Panic.DIVISION_BY_ZERO);\n        }\n        return result;\n    }\n\n    /**\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\n     */\n    function tryModExp(\n        bytes memory b,\n        bytes memory e,\n        bytes memory m\n    ) internal view returns (bool success, bytes memory result) {\n        if (_zeroBytes(m)) return (false, new bytes(0));\n\n        uint256 mLen = m.length;\n\n        // Encode call args in result and move the free memory pointer\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\n\n        assembly (\"memory-safe\") {\n            let dataPtr := add(result, 0x20)\n            // Write result on top of args to avoid allocating extra memory.\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\n            // Overwrite the length.\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\n            mstore(result, mLen)\n            // Set the memory pointer after the returned data.\n            mstore(0x40, add(dataPtr, mLen))\n        }\n    }\n\n    /**\n     * @dev Returns whether the provided byte array is zero.\n     */\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\n        for (uint256 i = 0; i < byteArray.length; ++i) {\n            if (byteArray[i] != 0) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\n     * towards zero.\n     *\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\n     * using integer operations.\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        unchecked {\n            // Take care of easy edge cases when a == 0 or a == 1\n            if (a <= 1) {\n                return a;\n            }\n\n            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\n            // the current value as `ε_n = | x_n - sqrt(a) |`.\n            //\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\n            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is\n            // bigger than any uint256.\n            //\n            // By noticing that\n            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\n            // to the msb function.\n            uint256 aa = a;\n            uint256 xn = 1;\n\n            if (aa >= (1 << 128)) {\n                aa >>= 128;\n                xn <<= 64;\n            }\n            if (aa >= (1 << 64)) {\n                aa >>= 64;\n                xn <<= 32;\n            }\n            if (aa >= (1 << 32)) {\n                aa >>= 32;\n                xn <<= 16;\n            }\n            if (aa >= (1 << 16)) {\n                aa >>= 16;\n                xn <<= 8;\n            }\n            if (aa >= (1 << 8)) {\n                aa >>= 8;\n                xn <<= 4;\n            }\n            if (aa >= (1 << 4)) {\n                aa >>= 4;\n                xn <<= 2;\n            }\n            if (aa >= (1 << 2)) {\n                xn <<= 1;\n            }\n\n            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).\n            //\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).\n            // This is going to be our x_0 (and ε_0)\n            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)\n\n            // From here, Newton's method give us:\n            // x_{n+1} = (x_n + a / x_n) / 2\n            //\n            // One should note that:\n            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a\n            //              = ((x_n² + a) / (2 * x_n))² - a\n            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a\n            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)\n            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)\n            //              = (x_n² - a)² / (2 * x_n)²\n            //              = ((x_n² - a) / (2 * x_n))²\n            //              ≥ 0\n            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n\n            //\n            // This gives us the proof of quadratic convergence of the sequence:\n            // ε_{n+1} = | x_{n+1} - sqrt(a) |\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\n            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |\n            //         = | (x_n - sqrt(a))² / (2 * x_n) |\n            //         = | ε_n² / (2 * x_n) |\n            //         = ε_n² / | (2 * x_n) |\n            //\n            // For the first iteration, we have a special case where x_0 is known:\n            // ε_1 = ε_0² / | (2 * x_0) |\n            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))\n            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))\n            //     ≤ 2**(e-3) / 3\n            //     ≤ 2**(e-3-log2(3))\n            //     ≤ 2**(e-4.5)\n            //\n            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:\n            // ε_{n+1} = ε_n² / | (2 * x_n) |\n            //         ≤ (2**(e-k))² / (2 * 2**(e-1))\n            //         ≤ 2**(2*e-2*k) / 2**e\n            //         ≤ 2**(e-2*k)\n            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above\n            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5\n            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9\n            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18\n            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36\n            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72\n\n            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision\n            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\n            // sqrt(a) or sqrt(a) + 1.\n            return xn - SafeCast.toUint(xn > a / xn);\n        }\n    }\n\n    /**\n     * @dev Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // If upper 8 bits of 16-bit half set, add 8 to result\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\n        // If upper 4 bits of 8-bit half set, add 4 to result\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\n\n        // Shifts value right by the current result and use it as an index into this lookup table:\n        //\n        // | x (4 bits) |  index  | table[index] = MSB position |\n        // |------------|---------|-----------------------------|\n        // |    0000    |    0    |        table[0] = 0         |\n        // |    0001    |    1    |        table[1] = 0         |\n        // |    0010    |    2    |        table[2] = 1         |\n        // |    0011    |    3    |        table[3] = 1         |\n        // |    0100    |    4    |        table[4] = 2         |\n        // |    0101    |    5    |        table[5] = 2         |\n        // |    0110    |    6    |        table[6] = 2         |\n        // |    0111    |    7    |        table[7] = 2         |\n        // |    1000    |    8    |        table[8] = 3         |\n        // |    1001    |    9    |        table[9] = 3         |\n        // |    1010    |   10    |        table[10] = 3        |\n        // |    1011    |   11    |        table[11] = 3        |\n        // |    1100    |   12    |        table[12] = 3        |\n        // |    1101    |   13    |        table[13] = 3        |\n        // |    1110    |   14    |        table[14] = 3        |\n        // |    1111    |   15    |        table[15] = 3        |\n        //\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\n        assembly (\"memory-safe\") {\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 x) internal pure returns (uint256 r) {\n        // If value has upper 128 bits set, log2 result is at least 128\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\n        // If upper 64 bits of 128-bit half set, add 64 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\n        // If upper 32 bits of 64-bit half set, add 32 to result\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\n        // If upper 16 bits of 32-bit half set, add 16 to result\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\n        }\n    }\n\n    /**\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\n     */\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\n        return uint8(rounding) % 2 == 1;\n    }\n\n    /**\n     * @dev Counts the number of leading zero bits in a uint256.\n     */\n    function clz(uint256 x) internal pure returns (uint256) {\n        return ternary(x == 0, 256, 255 - log2(x));\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct Int256Slot {\n        int256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\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"},"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/LowLevelCall.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library of low level call functions that implement different calling strategies to deal with the return data.\n *\n * WARNING: Using this library requires an advanced understanding of Solidity and how the EVM works. It is recommended\n * to use the {Address} library instead.\n */\nlibrary LowLevelCall {\n    /// @dev Performs a Solidity function call using a low level `call` and ignoring the return data.\n    function callNoReturn(address target, bytes memory data) internal returns (bool success) {\n        return callNoReturn(target, 0, data);\n    }\n\n    /// @dev Same as {callNoReturn}, but allows to specify the value to be sent in the call.\n    function callNoReturn(address target, uint256 value, bytes memory data) internal returns (bool success) {\n        assembly (\"memory-safe\") {\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x00)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `call` and returns the first 64 bytes of the result\n    /// in the scratch space of memory. Useful for functions that return a tuple of single-word values.\n    ///\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\n    /// and this function doesn't zero it out.\n    function callReturn64Bytes(\n        address target,\n        bytes memory data\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\n        return callReturn64Bytes(target, 0, data);\n    }\n\n    /// @dev Same as {callReturnBytes32Pair}, but allows to specify the value to be sent in the call.\n    function callReturn64Bytes(\n        address target,\n        uint256 value,\n        bytes memory data\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\n        assembly (\"memory-safe\") {\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x40)\n            result1 := mload(0x00)\n            result2 := mload(0x20)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `staticcall` and ignoring the return data.\n    function staticcallNoReturn(address target, bytes memory data) internal view returns (bool success) {\n        assembly (\"memory-safe\") {\n            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `staticcall` and returns the first 64 bytes of the result\n    /// in the scratch space of memory. Useful for functions that return a tuple of single-word values.\n    ///\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\n    /// and this function doesn't zero it out.\n    function staticcallReturn64Bytes(\n        address target,\n        bytes memory data\n    ) internal view returns (bool success, bytes32 result1, bytes32 result2) {\n        assembly (\"memory-safe\") {\n            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)\n            result1 := mload(0x00)\n            result2 := mload(0x20)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `delegatecall` and ignoring the return data.\n    function delegatecallNoReturn(address target, bytes memory data) internal returns (bool success) {\n        assembly (\"memory-safe\") {\n            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)\n        }\n    }\n\n    /// @dev Performs a Solidity function call using a low level `delegatecall` and returns the first 64 bytes of the result\n    /// in the scratch space of memory. Useful for functions that return a tuple of single-word values.\n    ///\n    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated\n    /// and this function doesn't zero it out.\n    function delegatecallReturn64Bytes(\n        address target,\n        bytes memory data\n    ) internal returns (bool success, bytes32 result1, bytes32 result2) {\n        assembly (\"memory-safe\") {\n            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)\n            result1 := mload(0x00)\n            result2 := mload(0x20)\n        }\n    }\n\n    /// @dev Returns the size of the return data buffer.\n    function returnDataSize() internal pure returns (uint256 size) {\n        assembly (\"memory-safe\") {\n            size := returndatasize()\n        }\n    }\n\n    /// @dev Returns a buffer containing the return data from the last call.\n    function returnData() internal pure returns (bytes memory result) {\n        assembly (\"memory-safe\") {\n            result := mload(0x40)\n            mstore(result, returndatasize())\n            returndatacopy(add(result, 0x20), 0x00, returndatasize())\n            mstore(0x40, add(result, add(0x20, returndatasize())))\n        }\n    }\n\n    /// @dev Revert with the return data from the last call.\n    function bubbleRevert() internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            returndatacopy(fmp, 0x00, returndatasize())\n            revert(fmp, returndatasize())\n        }\n    }\n\n    function bubbleRevert(bytes memory returndata) internal pure {\n        assembly (\"memory-safe\") {\n            revert(add(returndata, 0x20), mload(returndata))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ShortStrings.sol)\n\npragma solidity ^0.8.20;\n\nimport {StorageSlot} from \"./StorageSlot.sol\";\n\n// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |\n// | length  | 0x                                                              BB |\ntype ShortString is bytes32;\n\n/**\n * @dev This library provides functions to convert short memory strings\n * into a `ShortString` type that can be used as an immutable variable.\n *\n * Strings of arbitrary length can be optimized using this library if\n * they are short enough (up to 31 bytes) by packing them with their\n * length (1 byte) in a single EVM word (32 bytes). Additionally, a\n * fallback mechanism can be used for every other case.\n *\n * Usage example:\n *\n * ```solidity\n * contract Named {\n *     using ShortStrings for *;\n *\n *     ShortString private immutable _name;\n *     string private _nameFallback;\n *\n *     constructor(string memory contractName) {\n *         _name = contractName.toShortStringWithFallback(_nameFallback);\n *     }\n *\n *     function name() external view returns (string memory) {\n *         return _name.toStringWithFallback(_nameFallback);\n *     }\n * }\n * ```\n */\nlibrary ShortStrings {\n    // Used as an identifier for strings longer than 31 bytes.\n    bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;\n\n    error StringTooLong(string str);\n    error InvalidShortString();\n\n    /**\n     * @dev Encode a string of at most 31 chars into a `ShortString`.\n     *\n     * This will trigger a `StringTooLong` error is the input string is too long.\n     */\n    function toShortString(string memory str) internal pure returns (ShortString) {\n        bytes memory bstr = bytes(str);\n        if (bstr.length > 0x1f) {\n            revert StringTooLong(str);\n        }\n        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));\n    }\n\n    /**\n     * @dev Decode a `ShortString` back to a \"normal\" string.\n     */\n    function toString(ShortString sstr) internal pure returns (string memory) {\n        uint256 len = byteLength(sstr);\n        // using `new string(len)` would work locally but is not memory safe.\n        string memory str = new string(0x20);\n        assembly (\"memory-safe\") {\n            mstore(str, len)\n            mstore(add(str, 0x20), sstr)\n        }\n        return str;\n    }\n\n    /**\n     * @dev Return the length of a `ShortString`.\n     */\n    function byteLength(ShortString sstr) internal pure returns (uint256) {\n        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;\n        if (result > 0x1f) {\n            revert InvalidShortString();\n        }\n        return result;\n    }\n\n    /**\n     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.\n     */\n    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {\n        if (bytes(value).length < 0x20) {\n            return toShortString(value);\n        } else {\n            StorageSlot.getStringSlot(store).value = value;\n            return ShortString.wrap(FALLBACK_SENTINEL);\n        }\n    }\n\n    /**\n     * @dev Decode a string that was encoded to `ShortString` or written to storage using {toShortStringWithFallback}.\n     */\n    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return toString(value);\n        } else {\n            return store;\n        }\n    }\n\n    /**\n     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using\n     * {toShortStringWithFallback}.\n     *\n     * WARNING: This will return the \"byte length\" of the string. This may not reflect the actual length in terms of\n     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.\n     */\n    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {\n        if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\n            return byteLength(value);\n        } else {\n            return bytes(store).length;\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1271.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @dev Interface of the ERC-1271 standard signature validation method for\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\n */\ninterface IERC1271 {\n    /**\n     * @dev Should return whether the signature provided is valid for the provided data\n     * @param hash      Hash of the data to be signed\n     * @param signature Signature byte array associated with `hash`\n     */\n    function isValidSignature(bytes32 hash, bytes calldata signature) external view returns (bytes4 magicValue);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC5267.sol)\n\npragma solidity >=0.4.16;\n\ninterface IERC5267 {\n    /**\n     * @dev MAY be emitted to signal that the domain could have changed.\n     */\n    event EIP712DomainChanged();\n\n    /**\n     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712\n     * signature.\n     */\n    function eip712Domain()\n        external\n        view\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        );\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC7913.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC7913.sol)\n\npragma solidity >=0.5.0;\n\n/**\n * @dev Signature verifier interface.\n */\ninterface IERC7913SignatureVerifier {\n    /**\n     * @dev Verifies `signature` as a valid signature of `hash` by `key`.\n     *\n     * MUST return the bytes4 magic value IERC7913SignatureVerifier.verify.selector if the signature is valid.\n     * SHOULD return 0xffffffff or revert if the signature is not valid.\n     * SHOULD return 0xffffffff or revert if the key is empty\n     */\n    function verify(bytes calldata key, bytes32 hash, bytes calldata signature) external view returns (bytes4);\n}\n"},"lib/openzeppelin-contracts/contracts/utils/TransientSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/TransientSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/TransientSlot.js.\n\npragma solidity ^0.8.24;\n\n/**\n * @dev Library for reading and writing value-types to specific transient storage slots.\n *\n * Transient slots are often used to store temporary values that are removed after the current transaction.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n *  * Example reading and writing values using transient storage:\n * ```solidity\n * contract Lock {\n *     using TransientSlot for *;\n *\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _LOCK_SLOT = 0xf4678858b2b588224636b8522b729e7722d32fc491da849ed75b3fdf3c84f542;\n *\n *     modifier locked() {\n *         require(!_LOCK_SLOT.asBoolean().tload());\n *\n *         _LOCK_SLOT.asBoolean().tstore(true);\n *         _;\n *         _LOCK_SLOT.asBoolean().tstore(false);\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary TransientSlot {\n    /**\n     * @dev UDVT that represents a slot holding an address.\n     */\n    type AddressSlot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a AddressSlot.\n     */\n    function asAddress(bytes32 slot) internal pure returns (AddressSlot) {\n        return AddressSlot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a bool.\n     */\n    type BooleanSlot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a BooleanSlot.\n     */\n    function asBoolean(bytes32 slot) internal pure returns (BooleanSlot) {\n        return BooleanSlot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a bytes32.\n     */\n    type Bytes32Slot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a Bytes32Slot.\n     */\n    function asBytes32(bytes32 slot) internal pure returns (Bytes32Slot) {\n        return Bytes32Slot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a uint256.\n     */\n    type Uint256Slot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a Uint256Slot.\n     */\n    function asUint256(bytes32 slot) internal pure returns (Uint256Slot) {\n        return Uint256Slot.wrap(slot);\n    }\n\n    /**\n     * @dev UDVT that represents a slot holding a int256.\n     */\n    type Int256Slot is bytes32;\n\n    /**\n     * @dev Cast an arbitrary slot to a Int256Slot.\n     */\n    function asInt256(bytes32 slot) internal pure returns (Int256Slot) {\n        return Int256Slot.wrap(slot);\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(AddressSlot slot) internal view returns (address value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(AddressSlot slot, address value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(BooleanSlot slot) internal view returns (bool value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(BooleanSlot slot, bool value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(Bytes32Slot slot) internal view returns (bytes32 value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(Bytes32Slot slot, bytes32 value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(Uint256Slot slot) internal view returns (uint256 value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(Uint256Slot slot, uint256 value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n\n    /**\n     * @dev Load the value held at location `slot` in transient storage.\n     */\n    function tload(Int256Slot slot) internal view returns (int256 value) {\n        assembly (\"memory-safe\") {\n            value := tload(slot)\n        }\n    }\n\n    /**\n     * @dev Store `value` at location `slot` in transient storage.\n     */\n    function tstore(Int256Slot slot, int256 value) internal {\n        assembly (\"memory-safe\") {\n            tstore(slot, value)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeCast {\n    /**\n     * @dev Value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\n\n    /**\n     * @dev An int value doesn't fit in an uint of `bits` size.\n     */\n    error SafeCastOverflowedIntToUint(int256 value);\n\n    /**\n     * @dev Value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\n\n    /**\n     * @dev An uint value doesn't fit in an int of `bits` size.\n     */\n    error SafeCastOverflowedUintToInt(uint256 value);\n\n    /**\n     * @dev Returns the downcasted uint248 from uint256, reverting on\n     * overflow (when the input is greater than largest uint248).\n     *\n     * Counterpart to Solidity's `uint248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toUint248(uint256 value) internal pure returns (uint248) {\n        if (value > type(uint248).max) {\n            revert SafeCastOverflowedUintDowncast(248, value);\n        }\n        return uint248(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint240 from uint256, reverting on\n     * overflow (when the input is greater than largest uint240).\n     *\n     * Counterpart to Solidity's `uint240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toUint240(uint256 value) internal pure returns (uint240) {\n        if (value > type(uint240).max) {\n            revert SafeCastOverflowedUintDowncast(240, value);\n        }\n        return uint240(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint232 from uint256, reverting on\n     * overflow (when the input is greater than largest uint232).\n     *\n     * Counterpart to Solidity's `uint232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toUint232(uint256 value) internal pure returns (uint232) {\n        if (value > type(uint232).max) {\n            revert SafeCastOverflowedUintDowncast(232, value);\n        }\n        return uint232(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint224 from uint256, reverting on\n     * overflow (when the input is greater than largest uint224).\n     *\n     * Counterpart to Solidity's `uint224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toUint224(uint256 value) internal pure returns (uint224) {\n        if (value > type(uint224).max) {\n            revert SafeCastOverflowedUintDowncast(224, value);\n        }\n        return uint224(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint216 from uint256, reverting on\n     * overflow (when the input is greater than largest uint216).\n     *\n     * Counterpart to Solidity's `uint216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toUint216(uint256 value) internal pure returns (uint216) {\n        if (value > type(uint216).max) {\n            revert SafeCastOverflowedUintDowncast(216, value);\n        }\n        return uint216(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint208 from uint256, reverting on\n     * overflow (when the input is greater than largest uint208).\n     *\n     * Counterpart to Solidity's `uint208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toUint208(uint256 value) internal pure returns (uint208) {\n        if (value > type(uint208).max) {\n            revert SafeCastOverflowedUintDowncast(208, value);\n        }\n        return uint208(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint200 from uint256, reverting on\n     * overflow (when the input is greater than largest uint200).\n     *\n     * Counterpart to Solidity's `uint200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toUint200(uint256 value) internal pure returns (uint200) {\n        if (value > type(uint200).max) {\n            revert SafeCastOverflowedUintDowncast(200, value);\n        }\n        return uint200(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint192 from uint256, reverting on\n     * overflow (when the input is greater than largest uint192).\n     *\n     * Counterpart to Solidity's `uint192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toUint192(uint256 value) internal pure returns (uint192) {\n        if (value > type(uint192).max) {\n            revert SafeCastOverflowedUintDowncast(192, value);\n        }\n        return uint192(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint184 from uint256, reverting on\n     * overflow (when the input is greater than largest uint184).\n     *\n     * Counterpart to Solidity's `uint184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toUint184(uint256 value) internal pure returns (uint184) {\n        if (value > type(uint184).max) {\n            revert SafeCastOverflowedUintDowncast(184, value);\n        }\n        return uint184(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint176 from uint256, reverting on\n     * overflow (when the input is greater than largest uint176).\n     *\n     * Counterpart to Solidity's `uint176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toUint176(uint256 value) internal pure returns (uint176) {\n        if (value > type(uint176).max) {\n            revert SafeCastOverflowedUintDowncast(176, value);\n        }\n        return uint176(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint168 from uint256, reverting on\n     * overflow (when the input is greater than largest uint168).\n     *\n     * Counterpart to Solidity's `uint168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toUint168(uint256 value) internal pure returns (uint168) {\n        if (value > type(uint168).max) {\n            revert SafeCastOverflowedUintDowncast(168, value);\n        }\n        return uint168(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint160 from uint256, reverting on\n     * overflow (when the input is greater than largest uint160).\n     *\n     * Counterpart to Solidity's `uint160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toUint160(uint256 value) internal pure returns (uint160) {\n        if (value > type(uint160).max) {\n            revert SafeCastOverflowedUintDowncast(160, value);\n        }\n        return uint160(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint152 from uint256, reverting on\n     * overflow (when the input is greater than largest uint152).\n     *\n     * Counterpart to Solidity's `uint152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toUint152(uint256 value) internal pure returns (uint152) {\n        if (value > type(uint152).max) {\n            revert SafeCastOverflowedUintDowncast(152, value);\n        }\n        return uint152(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint144 from uint256, reverting on\n     * overflow (when the input is greater than largest uint144).\n     *\n     * Counterpart to Solidity's `uint144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toUint144(uint256 value) internal pure returns (uint144) {\n        if (value > type(uint144).max) {\n            revert SafeCastOverflowedUintDowncast(144, value);\n        }\n        return uint144(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint136 from uint256, reverting on\n     * overflow (when the input is greater than largest uint136).\n     *\n     * Counterpart to Solidity's `uint136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toUint136(uint256 value) internal pure returns (uint136) {\n        if (value > type(uint136).max) {\n            revert SafeCastOverflowedUintDowncast(136, value);\n        }\n        return uint136(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint128 from uint256, reverting on\n     * overflow (when the input is greater than largest uint128).\n     *\n     * Counterpart to Solidity's `uint128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toUint128(uint256 value) internal pure returns (uint128) {\n        if (value > type(uint128).max) {\n            revert SafeCastOverflowedUintDowncast(128, value);\n        }\n        return uint128(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint120 from uint256, reverting on\n     * overflow (when the input is greater than largest uint120).\n     *\n     * Counterpart to Solidity's `uint120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toUint120(uint256 value) internal pure returns (uint120) {\n        if (value > type(uint120).max) {\n            revert SafeCastOverflowedUintDowncast(120, value);\n        }\n        return uint120(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint112 from uint256, reverting on\n     * overflow (when the input is greater than largest uint112).\n     *\n     * Counterpart to Solidity's `uint112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toUint112(uint256 value) internal pure returns (uint112) {\n        if (value > type(uint112).max) {\n            revert SafeCastOverflowedUintDowncast(112, value);\n        }\n        return uint112(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint104 from uint256, reverting on\n     * overflow (when the input is greater than largest uint104).\n     *\n     * Counterpart to Solidity's `uint104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toUint104(uint256 value) internal pure returns (uint104) {\n        if (value > type(uint104).max) {\n            revert SafeCastOverflowedUintDowncast(104, value);\n        }\n        return uint104(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint96 from uint256, reverting on\n     * overflow (when the input is greater than largest uint96).\n     *\n     * Counterpart to Solidity's `uint96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toUint96(uint256 value) internal pure returns (uint96) {\n        if (value > type(uint96).max) {\n            revert SafeCastOverflowedUintDowncast(96, value);\n        }\n        return uint96(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint88 from uint256, reverting on\n     * overflow (when the input is greater than largest uint88).\n     *\n     * Counterpart to Solidity's `uint88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toUint88(uint256 value) internal pure returns (uint88) {\n        if (value > type(uint88).max) {\n            revert SafeCastOverflowedUintDowncast(88, value);\n        }\n        return uint88(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint80 from uint256, reverting on\n     * overflow (when the input is greater than largest uint80).\n     *\n     * Counterpart to Solidity's `uint80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toUint80(uint256 value) internal pure returns (uint80) {\n        if (value > type(uint80).max) {\n            revert SafeCastOverflowedUintDowncast(80, value);\n        }\n        return uint80(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint72 from uint256, reverting on\n     * overflow (when the input is greater than largest uint72).\n     *\n     * Counterpart to Solidity's `uint72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toUint72(uint256 value) internal pure returns (uint72) {\n        if (value > type(uint72).max) {\n            revert SafeCastOverflowedUintDowncast(72, value);\n        }\n        return uint72(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint64 from uint256, reverting on\n     * overflow (when the input is greater than largest uint64).\n     *\n     * Counterpart to Solidity's `uint64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toUint64(uint256 value) internal pure returns (uint64) {\n        if (value > type(uint64).max) {\n            revert SafeCastOverflowedUintDowncast(64, value);\n        }\n        return uint64(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint56 from uint256, reverting on\n     * overflow (when the input is greater than largest uint56).\n     *\n     * Counterpart to Solidity's `uint56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toUint56(uint256 value) internal pure returns (uint56) {\n        if (value > type(uint56).max) {\n            revert SafeCastOverflowedUintDowncast(56, value);\n        }\n        return uint56(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint48 from uint256, reverting on\n     * overflow (when the input is greater than largest uint48).\n     *\n     * Counterpart to Solidity's `uint48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toUint48(uint256 value) internal pure returns (uint48) {\n        if (value > type(uint48).max) {\n            revert SafeCastOverflowedUintDowncast(48, value);\n        }\n        return uint48(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint40 from uint256, reverting on\n     * overflow (when the input is greater than largest uint40).\n     *\n     * Counterpart to Solidity's `uint40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toUint40(uint256 value) internal pure returns (uint40) {\n        if (value > type(uint40).max) {\n            revert SafeCastOverflowedUintDowncast(40, value);\n        }\n        return uint40(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint32 from uint256, reverting on\n     * overflow (when the input is greater than largest uint32).\n     *\n     * Counterpart to Solidity's `uint32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toUint32(uint256 value) internal pure returns (uint32) {\n        if (value > type(uint32).max) {\n            revert SafeCastOverflowedUintDowncast(32, value);\n        }\n        return uint32(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint24 from uint256, reverting on\n     * overflow (when the input is greater than largest uint24).\n     *\n     * Counterpart to Solidity's `uint24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toUint24(uint256 value) internal pure returns (uint24) {\n        if (value > type(uint24).max) {\n            revert SafeCastOverflowedUintDowncast(24, value);\n        }\n        return uint24(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint16 from uint256, reverting on\n     * overflow (when the input is greater than largest uint16).\n     *\n     * Counterpart to Solidity's `uint16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toUint16(uint256 value) internal pure returns (uint16) {\n        if (value > type(uint16).max) {\n            revert SafeCastOverflowedUintDowncast(16, value);\n        }\n        return uint16(value);\n    }\n\n    /**\n     * @dev Returns the downcasted uint8 from uint256, reverting on\n     * overflow (when the input is greater than largest uint8).\n     *\n     * Counterpart to Solidity's `uint8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toUint8(uint256 value) internal pure returns (uint8) {\n        if (value > type(uint8).max) {\n            revert SafeCastOverflowedUintDowncast(8, value);\n        }\n        return uint8(value);\n    }\n\n    /**\n     * @dev Converts a signed int256 into an unsigned uint256.\n     *\n     * Requirements:\n     *\n     * - input must be greater than or equal to 0.\n     */\n    function toUint256(int256 value) internal pure returns (uint256) {\n        if (value < 0) {\n            revert SafeCastOverflowedIntToUint(value);\n        }\n        return uint256(value);\n    }\n\n    /**\n     * @dev Returns the downcasted int248 from int256, reverting on\n     * overflow (when the input is less than smallest int248 or\n     * greater than largest int248).\n     *\n     * Counterpart to Solidity's `int248` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 248 bits\n     */\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\n        downcasted = int248(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(248, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int240 from int256, reverting on\n     * overflow (when the input is less than smallest int240 or\n     * greater than largest int240).\n     *\n     * Counterpart to Solidity's `int240` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 240 bits\n     */\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\n        downcasted = int240(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(240, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int232 from int256, reverting on\n     * overflow (when the input is less than smallest int232 or\n     * greater than largest int232).\n     *\n     * Counterpart to Solidity's `int232` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 232 bits\n     */\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\n        downcasted = int232(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(232, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int224 from int256, reverting on\n     * overflow (when the input is less than smallest int224 or\n     * greater than largest int224).\n     *\n     * Counterpart to Solidity's `int224` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 224 bits\n     */\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\n        downcasted = int224(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(224, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int216 from int256, reverting on\n     * overflow (when the input is less than smallest int216 or\n     * greater than largest int216).\n     *\n     * Counterpart to Solidity's `int216` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 216 bits\n     */\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\n        downcasted = int216(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(216, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int208 from int256, reverting on\n     * overflow (when the input is less than smallest int208 or\n     * greater than largest int208).\n     *\n     * Counterpart to Solidity's `int208` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 208 bits\n     */\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\n        downcasted = int208(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(208, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int200 from int256, reverting on\n     * overflow (when the input is less than smallest int200 or\n     * greater than largest int200).\n     *\n     * Counterpart to Solidity's `int200` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 200 bits\n     */\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\n        downcasted = int200(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(200, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int192 from int256, reverting on\n     * overflow (when the input is less than smallest int192 or\n     * greater than largest int192).\n     *\n     * Counterpart to Solidity's `int192` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 192 bits\n     */\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\n        downcasted = int192(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(192, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int184 from int256, reverting on\n     * overflow (when the input is less than smallest int184 or\n     * greater than largest int184).\n     *\n     * Counterpart to Solidity's `int184` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 184 bits\n     */\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\n        downcasted = int184(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(184, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int176 from int256, reverting on\n     * overflow (when the input is less than smallest int176 or\n     * greater than largest int176).\n     *\n     * Counterpart to Solidity's `int176` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 176 bits\n     */\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\n        downcasted = int176(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(176, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int168 from int256, reverting on\n     * overflow (when the input is less than smallest int168 or\n     * greater than largest int168).\n     *\n     * Counterpart to Solidity's `int168` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 168 bits\n     */\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\n        downcasted = int168(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(168, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int160 from int256, reverting on\n     * overflow (when the input is less than smallest int160 or\n     * greater than largest int160).\n     *\n     * Counterpart to Solidity's `int160` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 160 bits\n     */\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\n        downcasted = int160(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(160, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int152 from int256, reverting on\n     * overflow (when the input is less than smallest int152 or\n     * greater than largest int152).\n     *\n     * Counterpart to Solidity's `int152` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 152 bits\n     */\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\n        downcasted = int152(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(152, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int144 from int256, reverting on\n     * overflow (when the input is less than smallest int144 or\n     * greater than largest int144).\n     *\n     * Counterpart to Solidity's `int144` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 144 bits\n     */\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\n        downcasted = int144(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(144, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int136 from int256, reverting on\n     * overflow (when the input is less than smallest int136 or\n     * greater than largest int136).\n     *\n     * Counterpart to Solidity's `int136` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 136 bits\n     */\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\n        downcasted = int136(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(136, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int128 from int256, reverting on\n     * overflow (when the input is less than smallest int128 or\n     * greater than largest int128).\n     *\n     * Counterpart to Solidity's `int128` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 128 bits\n     */\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\n        downcasted = int128(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(128, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int120 from int256, reverting on\n     * overflow (when the input is less than smallest int120 or\n     * greater than largest int120).\n     *\n     * Counterpart to Solidity's `int120` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 120 bits\n     */\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\n        downcasted = int120(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(120, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int112 from int256, reverting on\n     * overflow (when the input is less than smallest int112 or\n     * greater than largest int112).\n     *\n     * Counterpart to Solidity's `int112` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 112 bits\n     */\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\n        downcasted = int112(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(112, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int104 from int256, reverting on\n     * overflow (when the input is less than smallest int104 or\n     * greater than largest int104).\n     *\n     * Counterpart to Solidity's `int104` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 104 bits\n     */\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\n        downcasted = int104(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(104, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int96 from int256, reverting on\n     * overflow (when the input is less than smallest int96 or\n     * greater than largest int96).\n     *\n     * Counterpart to Solidity's `int96` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 96 bits\n     */\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\n        downcasted = int96(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(96, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int88 from int256, reverting on\n     * overflow (when the input is less than smallest int88 or\n     * greater than largest int88).\n     *\n     * Counterpart to Solidity's `int88` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 88 bits\n     */\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\n        downcasted = int88(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(88, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int80 from int256, reverting on\n     * overflow (when the input is less than smallest int80 or\n     * greater than largest int80).\n     *\n     * Counterpart to Solidity's `int80` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 80 bits\n     */\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\n        downcasted = int80(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(80, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int72 from int256, reverting on\n     * overflow (when the input is less than smallest int72 or\n     * greater than largest int72).\n     *\n     * Counterpart to Solidity's `int72` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 72 bits\n     */\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\n        downcasted = int72(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(72, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int64 from int256, reverting on\n     * overflow (when the input is less than smallest int64 or\n     * greater than largest int64).\n     *\n     * Counterpart to Solidity's `int64` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 64 bits\n     */\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\n        downcasted = int64(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(64, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int56 from int256, reverting on\n     * overflow (when the input is less than smallest int56 or\n     * greater than largest int56).\n     *\n     * Counterpart to Solidity's `int56` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 56 bits\n     */\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\n        downcasted = int56(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(56, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int48 from int256, reverting on\n     * overflow (when the input is less than smallest int48 or\n     * greater than largest int48).\n     *\n     * Counterpart to Solidity's `int48` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 48 bits\n     */\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\n        downcasted = int48(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(48, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int40 from int256, reverting on\n     * overflow (when the input is less than smallest int40 or\n     * greater than largest int40).\n     *\n     * Counterpart to Solidity's `int40` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 40 bits\n     */\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\n        downcasted = int40(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(40, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int32 from int256, reverting on\n     * overflow (when the input is less than smallest int32 or\n     * greater than largest int32).\n     *\n     * Counterpart to Solidity's `int32` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 32 bits\n     */\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\n        downcasted = int32(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(32, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int24 from int256, reverting on\n     * overflow (when the input is less than smallest int24 or\n     * greater than largest int24).\n     *\n     * Counterpart to Solidity's `int24` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 24 bits\n     */\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\n        downcasted = int24(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(24, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int16 from int256, reverting on\n     * overflow (when the input is less than smallest int16 or\n     * greater than largest int16).\n     *\n     * Counterpart to Solidity's `int16` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 16 bits\n     */\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\n        downcasted = int16(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(16, value);\n        }\n    }\n\n    /**\n     * @dev Returns the downcasted int8 from int256, reverting on\n     * overflow (when the input is less than smallest int8 or\n     * greater than largest int8).\n     *\n     * Counterpart to Solidity's `int8` operator.\n     *\n     * Requirements:\n     *\n     * - input must fit into 8 bits\n     */\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\n        downcasted = int8(value);\n        if (downcasted != value) {\n            revert SafeCastOverflowedIntDowncast(8, value);\n        }\n    }\n\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\n        if (value > uint256(type(int256).max)) {\n            revert SafeCastOverflowedUintToInt(value);\n        }\n        return int256(value);\n    }\n\n    /**\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\n     */\n    function toUint(bool b) internal pure returns (uint256 u) {\n        assembly (\"memory-safe\") {\n            u := iszero(iszero(b))\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.20;\n\nimport {SafeCast} from \"./SafeCast.sol\";\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\n     *\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\n     * one branch when needed, making this function more expensive.\n     */\n    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {\n        unchecked {\n            // branchless ternary works because:\n            // b ^ (a ^ b) == a\n            // b ^ 0 == b\n            return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));\n        }\n    }\n\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a > b, a, b);\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return ternary(a < b, a, b);\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // Formula from the \"Bit Twiddling Hacks\" by Sean Eron Anderson.\n            // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift,\n            // taking advantage of the most significant (or \"sign\" bit) in two's complement representation.\n            // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result,\n            // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative).\n            int256 mask = n >> 255;\n\n            // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it.\n            return uint256((n + mask) ^ mask);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS\n    }\n\n    /**\n     * @dev The signature derives the `address(0)`.\n     */\n    error ECDSAInvalidSignature();\n\n    /**\n     * @dev The signature has an invalid length.\n     */\n    error ECDSAInvalidSignatureLength(uint256 length);\n\n    /**\n     * @dev The signature has an S value that is in the upper half order.\n     */\n    error ECDSAInvalidSignatureS(bytes32 s);\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\n     * return address(0) without also returning an error description. Errors are documented using an enum (error type)\n     * and a bytes32 providing additional information about the error.\n     *\n     * If no error is returned, then the address can be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n     * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n     * invalidation or nonces for replay protection.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     *\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes memory signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            assembly (\"memory-safe\") {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Variant of {tryRecover} that takes a signature in calldata\n     */\n    function tryRecoverCalldata(\n        bytes32 hash,\n        bytes calldata signature\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, calldata slices would work here, but are\n            // significantly more expensive (length check) than using calldataload in assembly.\n            assembly (\"memory-safe\") {\n                r := calldataload(signature.offset)\n                s := calldataload(add(signature.offset, 0x20))\n                v := byte(0, calldataload(add(signature.offset, 0x40)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * NOTE: This function only supports 65-byte signatures. ERC-2098 short signatures are rejected. This restriction\n     * is DEPRECATED and will be removed in v6.0. Developers SHOULD NOT use signatures as unique identifiers; use hash\n     * invalidation or nonces for replay protection.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Variant of {recover} that takes a signature in calldata\n     */\n    function recoverCalldata(bytes32 hash, bytes calldata signature) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecoverCalldata(hash, signature);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        unchecked {\n            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n            // We do not check for an overflow here since the shift operation results in 0 or 1.\n            uint8 v = uint8((uint256(vs) >> 255) + 27);\n            return tryRecover(hash, v, r, s);\n        }\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     */\n    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS, s);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature, bytes32(0));\n        }\n\n        return (signer, RecoverError.NoError, bytes32(0));\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\n        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\n        _throwError(error, errorArg);\n        return recovered;\n    }\n\n    /**\n     * @dev Parse a signature into its `v`, `r` and `s` components. Supports 65-byte and 64-byte (ERC-2098)\n     * formats. Returns (0,0,0) for invalid signatures.\n     *\n     * For 64-byte signatures, `v` is automatically normalized to 27 or 28.\n     * For 65-byte signatures, `v` is returned as-is and MUST already be 27 or 28 for use with ecrecover.\n     *\n     * Consider validating the result before use, or use {tryRecover}/{recover} which perform full validation.\n     */\n    function parse(bytes memory signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n        assembly (\"memory-safe\") {\n            // Check the signature length\n            switch mload(signature)\n            // - case 65: r,s,v signature (standard)\n            case 65 {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n            case 64 {\n                let vs := mload(add(signature, 0x40))\n                r := mload(add(signature, 0x20))\n                s := and(vs, shr(1, not(0)))\n                v := add(shr(255, vs), 27)\n            }\n            default {\n                r := 0\n                s := 0\n                v := 0\n            }\n        }\n    }\n\n    /**\n     * @dev Variant of {parse} that takes a signature in calldata\n     */\n    function parseCalldata(bytes calldata signature) internal pure returns (uint8 v, bytes32 r, bytes32 s) {\n        assembly (\"memory-safe\") {\n            // Check the signature length\n            switch signature.length\n            // - case 65: r,s,v signature (standard)\n            case 65 {\n                r := calldataload(signature.offset)\n                s := calldataload(add(signature.offset, 0x20))\n                v := byte(0, calldataload(add(signature.offset, 0x40)))\n            }\n            // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)\n            case 64 {\n                let vs := calldataload(add(signature.offset, 0x20))\n                r := calldataload(signature.offset)\n                s := and(vs, shr(1, not(0)))\n                v := add(shr(255, vs), 27)\n            }\n            default {\n                r := 0\n                s := 0\n                v := 0\n            }\n        }\n    }\n\n    /**\n     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\n     */\n    function _throwError(RecoverError error, bytes32 errorArg) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert ECDSAInvalidSignature();\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert ECDSAInvalidSignatureLength(uint256(errorArg));\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert ECDSAInvalidSignatureS(errorArg);\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/EIP712.sol)\n\npragma solidity ^0.8.24;\n\nimport {MessageHashUtils} from \"./MessageHashUtils.sol\";\nimport {ShortStrings, ShortString} from \"../ShortStrings.sol\";\nimport {IERC5267} from \"../../interfaces/IERC5267.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose\n * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract\n * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to\n * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain\n * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the\n * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.\n *\n * @custom:oz-upgrades-unsafe-allow state-variable-immutable\n */\nabstract contract EIP712 is IERC5267 {\n    using ShortStrings for *;\n\n    bytes32 private constant TYPE_HASH =\n        keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n\n    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n    // invalidate the cached domain separator if the chain id changes.\n    bytes32 private immutable _cachedDomainSeparator;\n    uint256 private immutable _cachedChainId;\n    address private immutable _cachedThis;\n\n    bytes32 private immutable _hashedName;\n    bytes32 private immutable _hashedVersion;\n\n    ShortString private immutable _name;\n    ShortString private immutable _version;\n    // slither-disable-next-line constable-states\n    string private _nameFallback;\n    // slither-disable-next-line constable-states\n    string private _versionFallback;\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP-712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        _name = name.toShortStringWithFallback(_nameFallback);\n        _version = version.toShortStringWithFallback(_versionFallback);\n        _hashedName = keccak256(bytes(name));\n        _hashedVersion = keccak256(bytes(version));\n\n        _cachedChainId = block.chainid;\n        _cachedDomainSeparator = _buildDomainSeparator();\n        _cachedThis = address(this);\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view returns (bytes32) {\n        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {\n            return _cachedDomainSeparator;\n        } else {\n            return _buildDomainSeparator();\n        }\n    }\n\n    function _buildDomainSeparator() private view returns (bytes32) {\n        return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\n    }\n\n    /// @inheritdoc IERC5267\n    function eip712Domain()\n        public\n        view\n        virtual\n        returns (\n            bytes1 fields,\n            string memory name,\n            string memory version,\n            uint256 chainId,\n            address verifyingContract,\n            bytes32 salt,\n            uint256[] memory extensions\n        )\n    {\n        return (\n            hex\"0f\", // 01111\n            _EIP712Name(),\n            _EIP712Version(),\n            block.chainid,\n            address(this),\n            bytes32(0),\n            new uint256[](0)\n        );\n    }\n\n    /**\n     * @dev The name parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _name which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Name() internal view returns (string memory) {\n        return _name.toStringWithFallback(_nameFallback);\n    }\n\n    /**\n     * @dev The version parameter for the EIP712 domain.\n     *\n     * NOTE: By default this function reads _version which is an immutable value.\n     * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function _EIP712Version() internal view returns (string memory) {\n        return _version.toStringWithFallback(_versionFallback);\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuardTransient.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuardTransient.sol)\n\npragma solidity ^0.8.24;\n\nimport {TransientSlot} from \"./TransientSlot.sol\";\n\n/**\n * @dev Variant of {ReentrancyGuard} that uses transient storage.\n *\n * NOTE: This variant only works on networks where EIP-1153 is available.\n *\n * _Available since v5.1._\n *\n * @custom:stateless\n */\nabstract contract ReentrancyGuardTransient {\n    using TransientSlot for *;\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.ReentrancyGuard\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant REENTRANCY_GUARD_STORAGE =\n        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    /**\n     * @dev A `view` only version of {nonReentrant}. Use to block view functions\n     * from being called, preventing reading from inconsistent contract state.\n     *\n     * CAUTION: This is a \"view\" modifier and does not change the reentrancy\n     * status. Use it only on view functions. For payable or non-payable functions,\n     * use the standard {nonReentrant} modifier instead.\n     */\n    modifier nonReentrantView() {\n        _nonReentrantBeforeView();\n        _;\n    }\n\n    function _nonReentrantBeforeView() private view {\n        if (_reentrancyGuardEntered()) {\n            revert ReentrancyGuardReentrantCall();\n        }\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, REENTRANCY_GUARD_STORAGE.asBoolean().tload() will be false\n        _nonReentrantBeforeView();\n\n        // Any calls to nonReentrant after this point will fail\n        _reentrancyGuardStorageSlot().asBoolean().tstore(true);\n    }\n\n    function _nonReentrantAfter() private {\n        _reentrancyGuardStorageSlot().asBoolean().tstore(false);\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _reentrancyGuardStorageSlot().asBoolean().tload();\n    }\n\n    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {\n        return REENTRANCY_GUARD_STORAGE;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/MessageHashUtils.sol)\n\npragma solidity ^0.8.24;\n\nimport {Strings} from \"../Strings.sol\";\n\n/**\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\n *\n * The library provides methods for generating a hash of a message that conforms to the\n * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\n * specifications.\n */\nlibrary MessageHashUtils {\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing a bytes32 `messageHash` with\n     * `\"\\x19Ethereum Signed Message:\\n32\"` and hashing the result. It corresponds with the\n     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\n     * keccak256, although any bytes32 value can be safely used because the final digest will\n     * be re-hashed.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            mstore(0x00, \"\\x19Ethereum Signed Message:\\n32\") // 32 is the bytes-length of messageHash\n            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\n            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x45` (`personal_sign` messages).\n     *\n     * The digest is calculated by prefixing an arbitrary `message` with\n     * `\"\\x19Ethereum Signed Message:\\n\" + len(message)` and hashing the result. It corresponds with the\n     * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\n        return\n            keccak256(bytes.concat(\"\\x19Ethereum Signed Message:\\n\", bytes(Strings.toString(message.length)), message));\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an ERC-191 signed data with version\n     * `0x00` (data with intended validator).\n     *\n     * The digest is calculated by prefixing an arbitrary `data` with `\"\\x19\\x00\"` and the intended\n     * `validator` address. Then hashing the result.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(hex\"19_00\", validator, data));\n    }\n\n    /**\n     * @dev Variant of {toDataWithIntendedValidatorHash-address-bytes} optimized for cases where `data` is a bytes32.\n     */\n    function toDataWithIntendedValidatorHash(\n        address validator,\n        bytes32 messageHash\n    ) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            mstore(0x00, hex\"19_00\")\n            mstore(0x02, shl(96, validator))\n            mstore(0x16, messageHash)\n            digest := keccak256(0x00, 0x36)\n        }\n    }\n\n    /**\n     * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`).\n     *\n     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\n     * `\\x19\\x01` and hashing the result. It corresponds to the hash signed by the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\n     *\n     * See {ECDSA-recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            mstore(ptr, hex\"19_01\")\n            mstore(add(ptr, 0x02), domainSeparator)\n            mstore(add(ptr, 0x22), structHash)\n            digest := keccak256(ptr, 0x42)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/cryptography/SignatureChecker.sol)\n\npragma solidity ^0.8.24;\n\nimport {ECDSA} from \"./ECDSA.sol\";\nimport {IERC1271} from \"../../interfaces/IERC1271.sol\";\nimport {IERC7913SignatureVerifier} from \"../../interfaces/IERC7913.sol\";\nimport {Bytes} from \"../Bytes.sol\";\n\n/**\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support:\n *\n * * ECDSA signatures from externally owned accounts (EOAs)\n * * ERC-1271 signatures from smart contract wallets like Argent and Safe Wallet (previously Gnosis Safe)\n * * ERC-7913 signatures from keys that do not have an Ethereum address of their own\n *\n * See https://eips.ethereum.org/EIPS/eip-1271[ERC-1271] and https://eips.ethereum.org/EIPS/eip-7913[ERC-7913].\n */\nlibrary SignatureChecker {\n    using Bytes for bytes;\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. If the signer has code, the\n     * signature is validated against it using ERC-1271, otherwise it's validated using `ECDSA.recover`.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     *\n     * NOTE: For an extended version of this function that supports ERC-7913 signatures, see {isValidSignatureNow-bytes-bytes32-bytes-}.\n     */\n    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\n        if (signer.code.length == 0) {\n            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecover(hash, signature);\n            return err == ECDSA.RecoverError.NoError && recovered == signer;\n        } else {\n            return isValidERC1271SignatureNow(signer, hash, signature);\n        }\n    }\n\n    /**\n     * @dev Variant of {isValidSignatureNow} that takes a signature in calldata\n     */\n    function isValidSignatureNowCalldata(\n        address signer,\n        bytes32 hash,\n        bytes calldata signature\n    ) internal view returns (bool) {\n        if (signer.code.length == 0) {\n            (address recovered, ECDSA.RecoverError err, ) = ECDSA.tryRecoverCalldata(hash, signature);\n            return err == ECDSA.RecoverError.NoError && recovered == signer;\n        } else {\n            return isValidERC1271SignatureNow(signer, hash, signature);\n        }\n    }\n\n    /**\n     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\n     * against the signer smart contract using ERC-1271.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidERC1271SignatureNow(\n        address signer,\n        bytes32 hash,\n        bytes memory signature\n    ) internal view returns (bool result) {\n        bytes4 selector = IERC1271.isValidSignature.selector;\n        uint256 length = signature.length;\n\n        assembly (\"memory-safe\") {\n            // Encoded calldata is :\n            // [ 0x00 - 0x03 ] <selector>\n            // [ 0x04 - 0x23 ] <hash>\n            // [ 0x24 - 0x44 ] <signature offset> (0x40)\n            // [ 0x44 - 0x64 ] <signature length>\n            // [ 0x64 - ...  ] <signature data>\n            let ptr := mload(0x40)\n            mstore(ptr, selector)\n            mstore(add(ptr, 0x04), hash)\n            mstore(add(ptr, 0x24), 0x40)\n            mcopy(add(ptr, 0x44), signature, add(length, 0x20))\n\n            let success := staticcall(gas(), signer, ptr, add(length, 0x64), 0x00, 0x20)\n            result := and(success, and(gt(returndatasize(), 0x1f), eq(mload(0x00), selector)))\n        }\n    }\n\n    /**\n     * @dev Verifies a signature for a given ERC-7913 signer and hash.\n     *\n     * The signer is a `bytes` object that is the concatenation of an address and optionally a key:\n     * `verifier || key`. A signer must be at least 20 bytes long.\n     *\n     * Verification is done as follows:\n     *\n     * * If `signer.length < 20`: verification fails\n     * * If `signer.length == 20`: verification is done using {isValidSignatureNow}\n     * * Otherwise: verification is done using {IERC7913SignatureVerifier}\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function isValidSignatureNow(\n        bytes memory signer,\n        bytes32 hash,\n        bytes memory signature\n    ) internal view returns (bool) {\n        if (signer.length < 20) {\n            return false;\n        } else if (signer.length == 20) {\n            return isValidSignatureNow(address(bytes20(signer)), hash, signature);\n        } else {\n            (bool success, bytes memory result) = address(bytes20(signer)).staticcall(\n                abi.encodeCall(IERC7913SignatureVerifier.verify, (signer.slice(20), hash, signature))\n            );\n            return (success &&\n                result.length >= 32 &&\n                abi.decode(result, (bytes32)) == bytes32(IERC7913SignatureVerifier.verify.selector));\n        }\n    }\n\n    /**\n     * @dev Verifies multiple ERC-7913 `signatures` for a given `hash` using a set of `signers`.\n     * Returns `false` if the number of signers and signatures is not the same.\n     *\n     * The signers should be ordered by their `keccak256` hash to ensure efficient duplication check. Unordered\n     * signers are supported, but the uniqueness check will be more expensive.\n     *\n     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\n     * change through time. It could return true at block N and false at block N+1 (or the opposite).\n     */\n    function areValidSignaturesNow(\n        bytes32 hash,\n        bytes[] memory signers,\n        bytes[] memory signatures\n    ) internal view returns (bool) {\n        if (signers.length != signatures.length) return false;\n\n        bytes32 lastId = bytes32(0);\n\n        for (uint256 i = 0; i < signers.length; ++i) {\n            bytes memory signer = signers[i];\n\n            // If one of the signatures is invalid, reject the batch\n            if (!isValidSignatureNow(signer, hash, signatures[i])) return false;\n\n            bytes32 id = keccak256(signer);\n            // If the current signer ID is greater than all previous IDs, then this is a new signer.\n            if (lastId < id) {\n                lastId = id;\n            } else {\n                // If this signer id is not greater than all the previous ones, verify that it is not a duplicate of a previous one\n                // This loop is never executed if the signers are ordered by id.\n                for (uint256 j = 0; j < i; ++j) {\n                    if (id == keccak256(signers[j])) return false;\n                }\n            }\n        }\n\n        return true;\n    }\n}\n"}},"language":"Solidity","settings":{"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":[":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":ds-test/=lib/permit2/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":permit2/=lib/permit2/src/",":solmate/=lib/permit2/lib/solmate/"]}},"stdJsonOutput":{"sources":{"src/x402BatchSettlement.sol":{"id":29},"src/interfaces/IDepositCollector.sol":{"id":28},"lib/openzeppelin-contracts/contracts/utils/Bytes.sol":{"id":9},"lib/openzeppelin-contracts/contracts/utils/Panic.sol":{"id":14},"lib/openzeppelin-contracts/contracts/utils/Errors.sol":{"id":11},"lib/openzeppelin-contracts/contracts/utils/Address.sol":{"id":8},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"id":10},"lib/openzeppelin-contracts/contracts/utils/Strings.sol":{"id":18},"lib/openzeppelin-contracts/contracts/utils/Multicall.sol":{"id":13},"lib/openzeppelin-contracts/contracts/utils/math/Math.sol":{"id":25},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"id":3},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"id":17},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":6},"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":{"id":12},"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol":{"id":16},"lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol":{"id":0},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"id":1},"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol":{"id":4},"lib/openzeppelin-contracts/contracts/interfaces/IERC7913.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/TransientSlot.sol":{"id":19},"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol":{"id":26},"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol":{"id":27},"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol":{"id":20},"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol":{"id":21},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"id":7},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":24},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuardTransient.sol":{"id":15},"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol":{"id":22},"lib/openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol":{"id":23}},"contracts":{"src/x402BatchSettlement.sol":{"x402BatchSettlement":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AddressEmptyCode","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"ClaimExceedsBalance","type":"error","inputs":[]},{"name":"ClaimExceedsCeiling","type":"error","inputs":[]},{"name":"DepositCollectionFailed","type":"error","inputs":[]},{"name":"DepositOverflow","type":"error","inputs":[]},{"name":"ECDSAInvalidSignature","type":"error","inputs":[]},{"name":"ECDSAInvalidSignatureLength","type":"error","inputs":[{"name":"length","type":"uint256","internalType":"uint256"}]},{"name":"ECDSAInvalidSignatureS","type":"error","inputs":[{"name":"s","type":"bytes32","internalType":"bytes32"}]},{"name":"EmptyBatch","type":"error","inputs":[]},{"name":"FailedCall","type":"error","inputs":[]},{"name":"InvalidChannel","type":"error","inputs":[]},{"name":"InvalidCollector","type":"error","inputs":[]},{"name":"InvalidRefundNonce","type":"error","inputs":[]},{"name":"InvalidShortString","type":"error","inputs":[]},{"name":"InvalidSignature","type":"error","inputs":[]},{"name":"NotAuthorizedToClaim","type":"error","inputs":[]},{"name":"NotAuthorizedToFinalizeWithdraw","type":"error","inputs":[]},{"name":"NotAuthorizedToRefund","type":"error","inputs":[]},{"name":"NotReceiverAuthorizer","type":"error","inputs":[]},{"name":"NothingToWithdraw","type":"error","inputs":[]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"StringTooLong","type":"error","inputs":[{"name":"str","type":"string","internalType":"string"}]},{"name":"WithdrawAmountExceedsAvailable","type":"error","inputs":[]},{"name":"WithdrawDelayNotElapsed","type":"error","inputs":[]},{"name":"WithdrawDelayOutOfRange","type":"error","inputs":[]},{"name":"WithdrawalAlreadyPending","type":"error","inputs":[]},{"name":"WithdrawalNotPending","type":"error","inputs":[]},{"name":"ZeroDeposit","type":"error","inputs":[]},{"name":"ZeroRefund","type":"error","inputs":[]},{"name":"ChannelClosed","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"config","type":"tuple","indexed":false,"components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"anonymous":false},{"name":"ChannelCreated","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"config","type":"tuple","indexed":false,"components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"anonymous":false},{"name":"Claimed","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"claimAmount","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"newTotalClaimed","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"Deposited","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"newBalance","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"EIP712DomainChanged","type":"event","inputs":[],"anonymous":false},{"name":"Refunded","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"Settled","type":"event","inputs":[{"name":"receiver","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"WithdrawFinalized","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"}],"anonymous":false},{"name":"WithdrawInitiated","type":"event","inputs":[{"name":"channelId","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"amount","type":"uint128","indexed":false,"internalType":"uint128"},{"name":"finalizeAfter","type":"uint40","indexed":false,"internalType":"uint40"}],"anonymous":false},{"name":"CHANNEL_CONFIG_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"CLAIM_BATCH_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"CLAIM_ENTRY_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"MAX_WITHDRAW_DELAY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"MIN_WITHDRAW_DELAY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"REFUND_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"VOUCHER_TYPEHASH","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"channels","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"balance","type":"uint128","internalType":"uint128"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"voucherClaims","type":"tuple[]","components":[{"name":"voucher","type":"tuple","components":[{"name":"channel","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimWithSignature","type":"function","inputs":[{"name":"voucherClaims","type":"tuple[]","components":[{"name":"voucher","type":"tuple","components":[{"name":"channel","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]"},{"name":"authorizerSignature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"deposit","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"},{"name":"collector","type":"address","internalType":"address"},{"name":"collectorData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"eip712Domain","type":"function","inputs":[],"outputs":[{"name":"fields","type":"bytes1","internalType":"bytes1"},{"name":"name","type":"string","internalType":"string"},{"name":"version","type":"string","internalType":"string"},{"name":"chainId","type":"uint256","internalType":"uint256"},{"name":"verifyingContract","type":"address","internalType":"address"},{"name":"salt","type":"bytes32","internalType":"bytes32"},{"name":"extensions","type":"uint256[]","internalType":"uint256[]"}],"stateMutability":"view"},{"name":"finalizeWithdraw","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"getChannelId","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getClaimBatchDigest","type":"function","inputs":[{"name":"voucherClaims","type":"tuple[]","components":[{"name":"voucher","type":"tuple","components":[{"name":"channel","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.Voucher"},{"name":"signature","type":"bytes","internalType":"bytes"},{"name":"totalClaimed","type":"uint128","internalType":"uint128"}],"internalType":"struct x402BatchSettlement.VoucherClaim[]"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getRefundDigest","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"amount","type":"uint128","internalType":"uint128"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"getVoucherDigest","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"},{"name":"maxClaimableAmount","type":"uint128","internalType":"uint128"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"initiateWithdraw","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"multicall","type":"function","inputs":[{"name":"data","type":"bytes[]","internalType":"bytes[]"}],"outputs":[{"name":"results","type":"bytes[]","internalType":"bytes[]"}],"stateMutability":"nonpayable"},{"name":"pendingWithdrawals","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"amount","type":"uint128","internalType":"uint128"},{"name":"initiatedAt","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"receivers","type":"function","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"}],"outputs":[{"name":"totalClaimed","type":"uint128","internalType":"uint128"},{"name":"totalSettled","type":"uint128","internalType":"uint128"}],"stateMutability":"view"},{"name":"refund","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"refundNonce","type":"function","inputs":[{"name":"channelId","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"refundWithSignature","type":"function","inputs":[{"name":"config","type":"tuple","components":[{"name":"payer","type":"address","internalType":"address"},{"name":"payerAuthorizer","type":"address","internalType":"address"},{"name":"receiver","type":"address","internalType":"address"},{"name":"receiverAuthorizer","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"withdrawDelay","type":"uint40","internalType":"uint40"},{"name":"salt","type":"bytes32","internalType":"bytes32"}],"internalType":"struct x402BatchSettlement.ChannelConfig"},{"name":"amount","type":"uint128","internalType":"uint128"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"receiverAuthorizerSignature","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"settle","type":"function","inputs":[{"name":"receiver","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ClaimExceedsBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ClaimExceedsCeiling\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositCollectionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ECDSAInvalidSignature\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"ECDSAInvalidSignatureLength\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"ECDSAInvalidSignatureS\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EmptyBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChannel\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidCollector\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRefundNonce\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidShortString\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAuthorizedToClaim\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAuthorizedToFinalizeWithdraw\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotAuthorizedToRefund\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotReceiverAuthorizer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NothingToWithdraw\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"}],\"name\":\"StringTooLong\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawAmountExceedsAvailable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawDelayNotElapsed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawDelayOutOfRange\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalAlreadyPending\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalNotPending\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroDeposit\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroRefund\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"indexed\":false,\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"ChannelClosed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"indexed\":false,\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"ChannelCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"claimAmount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"newTotalClaimed\",\"type\":\"uint128\"}],\"name\":\"Claimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"newBalance\",\"type\":\"uint128\"}],\"name\":\"Deposited\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EIP712DomainChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"Refunded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"Settled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"WithdrawFinalized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint40\",\"name\":\"finalizeAfter\",\"type\":\"uint40\"}],\"name\":\"WithdrawInitiated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHANNEL_CONFIG_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CLAIM_BATCH_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"CLAIM_ENTRY_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MAX_WITHDRAW_DELAY\",\"outputs\":[{\"internalType\":\"uint40\",\"name\":\"\",\"type\":\"uint40\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MIN_WITHDRAW_DELAY\",\"outputs\":[{\"internalType\":\"uint40\",\"name\":\"\",\"type\":\"uint40\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REFUND_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VOUCHER_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"}],\"name\":\"channels\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"balance\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"totalClaimed\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"channel\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"maxClaimableAmount\",\"type\":\"uint128\"}],\"internalType\":\"struct x402BatchSettlement.Voucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"uint128\",\"name\":\"totalClaimed\",\"type\":\"uint128\"}],\"internalType\":\"struct x402BatchSettlement.VoucherClaim[]\",\"name\":\"voucherClaims\",\"type\":\"tuple[]\"}],\"name\":\"claim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"channel\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"maxClaimableAmount\",\"type\":\"uint128\"}],\"internalType\":\"struct x402BatchSettlement.Voucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"uint128\",\"name\":\"totalClaimed\",\"type\":\"uint128\"}],\"internalType\":\"struct x402BatchSettlement.VoucherClaim[]\",\"name\":\"voucherClaims\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes\",\"name\":\"authorizerSignature\",\"type\":\"bytes\"}],\"name\":\"claimWithSignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"address\",\"name\":\"collector\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"collectorData\",\"type\":\"bytes\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"eip712Domain\",\"outputs\":[{\"internalType\":\"bytes1\",\"name\":\"fields\",\"type\":\"bytes1\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"verifyingContract\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"uint256[]\",\"name\":\"extensions\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"finalizeWithdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"name\":\"getChannelId\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"channel\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"maxClaimableAmount\",\"type\":\"uint128\"}],\"internalType\":\"struct x402BatchSettlement.Voucher\",\"name\":\"voucher\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"uint128\",\"name\":\"totalClaimed\",\"type\":\"uint128\"}],\"internalType\":\"struct x402BatchSettlement.VoucherClaim[]\",\"name\":\"voucherClaims\",\"type\":\"tuple[]\"}],\"name\":\"getClaimBatchDigest\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"getRefundDigest\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"},{\"internalType\":\"uint128\",\"name\":\"maxClaimableAmount\",\"type\":\"uint128\"}],\"name\":\"getVoucherDigest\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"initiateWithdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"multicall\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"results\",\"type\":\"bytes[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"}],\"name\":\"pendingWithdrawals\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"uint40\",\"name\":\"initiatedAt\",\"type\":\"uint40\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"receivers\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"totalClaimed\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"totalSettled\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"refund\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"channelId\",\"type\":\"bytes32\"}],\"name\":\"refundNonce\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"payer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"payerAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"receiverAuthorizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint40\",\"name\":\"withdrawDelay\",\"type\":\"uint40\"},{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"}],\"internalType\":\"struct x402BatchSettlement.ChannelConfig\",\"name\":\"config\",\"type\":\"tuple\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"receiverAuthorizerSignature\",\"type\":\"bytes\"}],\"name\":\"refundWithSignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"settle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Coinbase\",\"details\":\"Channel identity is derived from an immutable `ChannelConfig`:      `channelId = keccak256(abi.encode(channelConfig))`.      Deploy at the same address on every chain via CREATE2.      Uses `ReentrancyGuardTransient` (EIP-1153); deploy only where transient storage is supported.      Fee-on-transfer and rebasing tokens are not recommended and are not guaranteed to behave like standard ERC-20s.\",\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"ECDSAInvalidSignature()\":[{\"details\":\"The signature derives the `address(0)`.\"}],\"ECDSAInvalidSignatureLength(uint256)\":[{\"details\":\"The signature has an invalid length.\"}],\"ECDSAInvalidSignatureS(bytes32)\":[{\"details\":\"The signature has an S value that is in the upper half order.\"}],\"FailedCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"InvalidChannel()\":[{\"details\":\"Errors use CapWords naming.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"EIP712DomainChanged()\":{\"details\":\"MAY be emitted to signal that the domain could have changed.\"}},\"kind\":\"dev\",\"methods\":{\"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])\":{\"details\":\"For each row, `msg.sender` must be `receiverAuthorizer` or `receiver` for that row's channel.      Receiver-side integrators should submit `claim` **promptly** once a payer-signed voucher should bind on-chain      entitlement: only **recorded** claims (`totalClaimed`) reduce what the payer can withdraw. If the payer      finalizes a timed withdrawal before this call executes, later `claim` can revert with `ClaimExceedsBalance`.\",\"params\":{\"voucherClaims\":\"Signed voucher rows with cumulative claim totals.\"}},\"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)\":{\"details\":\"Callable by anyone (relay-friendly). All rows must match the same `receiverAuthorizer`.      Same liveness consideration as `claim`: relays should submit before payer timed withdrawal drains escrow      (see `finalizeWithdraw` / `initiateWithdraw`).\",\"params\":{\"authorizerSignature\":\"Signature from `receiverAuthorizer` over `getClaimBatchDigest(voucherClaims)`.\",\"voucherClaims\":\"Claim rows for channels sharing the same `receiverAuthorizer`.\"}},\"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)\":{\"details\":\"The collector executes the pull; this function checks the contract's token balance increased      by `amount` after the call (post-condition) to detect fee-on-transfer or failed pulls.\",\"params\":{\"amount\":\"The exact amount of tokens to deposit.\",\"collector\":\"The deposit collector contract address.\",\"collectorData\":\"Opaque bytes forwarded to the collector (signatures, nonces, etc.).\",\"config\":\"The immutable channel configuration.\"}},\"eip712Domain()\":{\"details\":\"returns the fields and values that describe the domain separator used by this contract for EIP-712 signature.\"},\"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))\":{\"details\":\"Only `config.payer` or `config.payerAuthorizer` may call. Amount may be capped by available escrow.      Uses **current** `ch.balance` and `ch.totalClaimed` at execution time. If this transaction executes before a      competing `claim`, it can reduce escrow such that the claim later reverts with `ClaimExceedsBalance`.\",\"params\":{\"config\":\"The channel configuration.\"}},\"getChannelId((address,address,address,address,address,uint40,bytes32))\":{\"params\":{\"config\":\"The channel configuration to hash.\"},\"returns\":{\"_0\":\"The EIP-712 typed-data hash of `ChannelConfig`, bound to this contract's domain         (chainId + verifyingContract). Identical configs on different chains or different         deployments produce different ids, preventing cross-chain channel-state collision.\"}},\"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])\":{\"details\":\"`claim` and `claimWithSignature` revert with `EmptyBatch()` when `voucherClaims.length == 0`, so they      never call this with an empty array. The digest for `length == 0` is still defined (`entriesRoot = keccak256(\\\"\\\")`)      for `eth_call` and off-chain tools to match this contract’s EIP-712 encoding without duplicating hashing logic.\",\"params\":{\"voucherClaims\":\"The claim rows hashed into the batch.\"},\"returns\":{\"_0\":\"The typed data hash `receiverAuthorizer` signs for the batch.\"}},\"getRefundDigest(bytes32,uint256,uint128)\":{\"details\":\"Off-chain signers should use the current `refundNonce(channelId)` as `nonce`. A successful direct `refund`      on the same channel advances that nonce and invalidates digests signed for the old value until re-signed.\",\"params\":{\"amount\":\"The signed refund amount.\",\"channelId\":\"The channel identifier.\",\"nonce\":\"The refund nonce; must equal on-chain `refundNonce(channelId)` when `refundWithSignature` runs.\"},\"returns\":{\"_0\":\"The typed data hash for `receiverAuthorizer` to sign.\"}},\"getVoucherDigest(bytes32,uint128)\":{\"params\":{\"channelId\":\"The channel identifier.\",\"maxClaimableAmount\":\"The ceiling encoded in the voucher.\"},\"returns\":{\"_0\":\"The typed data hash signers use for payer authorization.\"}},\"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)\":{\"details\":\"Only `config.payer` or `config.payerAuthorizer` may call. Reverts if a withdrawal is already pending.      Available liquidity is `ch.balance - ch.totalClaimed` using **only** on-chain `totalClaimed`. Payer-signed      vouchers that are not yet claimed do **not** reserve funds; receivers relying on voucher value must treat      inclusion of `claim` during the withdrawal window as an operational requirement (RPC outages, censorship,      or relay failure can interact badly with `finalizeWithdraw`).\",\"params\":{\"amount\":\"The gross amount requested; may be capped on finalization.\",\"config\":\"The channel configuration.\"}},\"multicall(bytes[])\":{\"custom:oz-upgrades-unsafe-allow-reachable\":\"delegatecall\",\"details\":\"Receives and executes a batch of function calls on this contract.\"},\"refund((address,address,address,address,address,uint40,bytes32),uint128)\":{\"details\":\"Only `receiverAuthorizer` or `receiver` may call. Shares `_executeRefund` with `refundWithSignature`, so      every successful call advances `refundNonce` for the channel. Any in-flight EIP-712 `Refund` signature      produced for the previous nonce becomes unusable; relayers and authorizers should expect re-signing if      direct refunds race ahead of relayed `refundWithSignature` submissions.\",\"params\":{\"amount\":\"Requested refund; capped to `balance - totalClaimed`. Reverts with `ZeroRefund` if `amount == 0`.               If the capped amount is zero but `amount > 0`, no token transfer occurs (no `Refunded` event)               yet `refundNonce` still advances (see `_executeRefund`).\",\"config\":\"The channel configuration.\"}},\"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)\":{\"details\":\"Callable by anyone (relay-friendly). A prior direct `refund` on the same channel can advance the nonce      and cause `InvalidRefundNonce` here until the authorizer signs at the new nonce.\",\"params\":{\"amount\":\"The amount in the signature; capped like `refund`. If the capped amount is zero, no transfer               and no `Refunded` event, but `refundNonce` still advances once `_executeRefund` runs.\",\"config\":\"The channel configuration.\",\"nonce\":\"Must equal `refundNonce(channelId)` at entry; `_executeRefund` increments it (same as `refund`).\",\"receiverAuthorizerSignature\":\"EIP-712 signature from `receiverAuthorizer` over the refund digest.\"}},\"settle(address,address)\":{\"details\":\"Permissionless: typically called by the receiver or a facilitator.\",\"params\":{\"receiver\":\"The receiver address whose pending settlement is swept.\",\"token\":\"The ERC-20 token to transfer.\"}}},\"stateVariables\":{\"CLAIM_BATCH_TYPEHASH\":{\"details\":\"Full nested EIP-712 type so wallets can render `ClaimEntry[]` for user review.\"},\"CLAIM_ENTRY_TYPEHASH\":{\"details\":\"EIP-712 entry for one row in a signed claim batch (mirrors on-chain `VoucherClaim` fields used for authorization).\"},\"refundNonce\":{\"details\":\"Monotonic sequence per `channelId` for EIP-712 `Refund` replay protection. Incremented inside      `_executeRefund` **before** the capped refund amount is applied, for **both** `refund` and      `refundWithSignature`, including when the capped amount is zero (no transfer, no `Refunded` event).      A direct `refund` therefore advances the nonce and invalidates any presigned `refundWithSignature`      digest that was bound to the previous nonce; coordinate receiver vs relayer flows off-chain.\"}},\"title\":\"x402BatchSettlement\",\"version\":1},\"userdoc\":{\"events\":{\"ChannelClosed(bytes32,(address,address,address,address,address,uint40,bytes32))\":{\"notice\":\"Emitted when unclaimed escrow returns to zero and no claims were recorded.\"},\"ChannelCreated(bytes32,(address,address,address,address,address,uint40,bytes32))\":{\"notice\":\"Emitted the first time a channel receives escrowed balance.\"},\"Claimed(bytes32,address,uint128,uint128)\":{\"notice\":\"Emitted when the receiver side increases the cumulative claimed amount for a channel.\"},\"Deposited(bytes32,address,uint128,uint128)\":{\"notice\":\"Emitted after a successful deposit into a channel.\"},\"Refunded(bytes32,address,uint128)\":{\"notice\":\"Emitted when escrowed funds are refunded to the payer.\"},\"Settled(address,address,address,uint128)\":{\"notice\":\"Emitted when claimed funds are transferred to the receiver during settlement.\"},\"WithdrawFinalized(bytes32,address,uint128)\":{\"notice\":\"Emitted when a timed withdrawal completes and funds move to the payer.\"},\"WithdrawInitiated(bytes32,uint128,uint40)\":{\"notice\":\"Emitted when a timed withdrawal is started.\"}},\"kind\":\"user\",\"methods\":{\"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])\":{\"notice\":\"Applies a batch of voucher claims and updates channel accounting.\"},\"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)\":{\"notice\":\"Applies voucher claims authorized by a `receiverAuthorizer` EIP-712 signature over the batch.\"},\"constructor\":{\"notice\":\"Sets the EIP-712 domain for vouchers, refunds, and claim batches.\"},\"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)\":{\"notice\":\"Deposits tokens into a channel using a pluggable collector.\"},\"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))\":{\"notice\":\"Finalizes a pending withdrawal after `withdrawDelay` and sends tokens to the payer.\"},\"getChannelId((address,address,address,address,address,uint40,bytes32))\":{\"notice\":\"Returns the canonical `channelId` for a channel configuration.\"},\"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])\":{\"notice\":\"EIP-712 digest for the signed `ClaimBatch` (used by `claimWithSignature` and off-chain signing).\"},\"getRefundDigest(bytes32,uint256,uint128)\":{\"notice\":\"EIP-712 digest for a cooperative `Refund` authorization.\"},\"getVoucherDigest(bytes32,uint128)\":{\"notice\":\"EIP-712 digest for a `Voucher` with the given `channelId` and `maxClaimableAmount`.\"},\"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)\":{\"notice\":\"Starts the payer-side timed withdrawal window for unclaimed escrow.\"},\"refund((address,address,address,address,address,uint40,bytes32),uint128)\":{\"notice\":\"Cooperative refund of unclaimed escrow to the payer.\"},\"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)\":{\"notice\":\"Refunds unclaimed escrow to the payer using an EIP-712 `Refund` signature from `receiverAuthorizer`.\"},\"settle(address,address)\":{\"notice\":\"Transfers claimed-but-not-yet-settled tokens to the receiver for a `(receiver, token)` pair.\"}},\"notice\":\"Stateless unidirectional payment channel contract for the x402 `batch-settlement` scheme on EVM.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/x402BatchSettlement.sol\":\"x402BatchSettlement\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":ds-test/=lib/permit2/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":permit2/=lib/permit2/src/\",\":solmate/=lib/permit2/lib/solmate/\"]},\"sources\":{\"lib/openzeppelin-contracts/contracts/interfaces/IERC1271.sol\":{\"keccak256\":\"0x66c7ec42c6c43712be2107a50ab4529379bc76a632b425babec698d9da921ac6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://dce2778f0b638adfc5ba29c2c618c855fe725fa74a16846386aa1d56a834aa04\",\"dweb:/ipfs/QmPV9oWnzQdi58od266j62xvviavLNHqKLZfm6k2K1qy9E\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol\":{\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://da5e832b40fc5c3145d3781e2e5fa60ac2052c9d08af7e300dc8ab80c4343100\",\"dweb:/ipfs/QmTzf7N5ZUdh5raqtzbM11yexiUoLC9z3Ws632MCuycq1d\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol\":{\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1c299900ac4ec268d4570ecef0d697a3013cd11a6eb74e295ee3fbc945056037\",\"dweb:/ipfs/Qmab9owJoxcA7vJT5XNayCMaUR1qxqj1NDzzisduwaJMcZ\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d\",\"dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC5267.sol\":{\"keccak256\":\"0xfb223a85dd0b2175cfbbaa325a744e2cd74ecd17c3df2b77b0722f991d2725ee\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://84bf1dea0589ec49c8d15d559cc6d86ee493048a89b2d4adb60fbe705a3d89ae\",\"dweb:/ipfs/Qmd56n556d529wk2pRMhYhm5nhMDhviwereodDikjs68w1\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC7913.sol\":{\"keccak256\":\"0xe5a126930df1d54e4a6dd5fea09010c4a7db0ea974c6c17a1e6082879f5a032b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2f58f5a90328536a6c68289916bfa4ed653d871319c7b2a416ab3f6263c4f2f5\",\"dweb:/ipfs/Qmaa9DmgUA16Urz5fuF4RbFz2NaVpNLV41ddwykSdasFUd\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303\",\"dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0x304d732678032a9781ae85c8f204c8fba3d3a5e31c02616964e75cfdc5049098\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://299ced486011781dc98f638059678323c03079fefae1482abaa2135b22fa92d0\",\"dweb:/ipfs/QmbZNbcPTBxNvwChavN2kkZZs7xHhYL7mv51KrxMhsMs3j\"]},\"lib/openzeppelin-contracts/contracts/utils/Address.sol\":{\"keccak256\":\"0x0fa9e0d3a859900b5a46f70a03c73adf259603d5e05027a37fe0b45529d85346\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c2add4da0240c9f2ce47649c8bb6b11b40e98cf6f88b8bdc76b2704e89391710\",\"dweb:/ipfs/QmNQTwF2uVzu4CRtNxr8bxyP9XuW6VsZuo2Nr4KR2bZr3d\"]},\"lib/openzeppelin-contracts/contracts/utils/Bytes.sol\":{\"keccak256\":\"0x8140d608316521b1fd71167c3b708ebb8659da070723fc8807609553b296ee33\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a7bf7db66869ba1e945a0390b85da2f6afc7e42a4735ca918d0d56ac90c50147\",\"dweb:/ipfs/QmRmNyhpBpgzSdQqLtrQCYE7H7eLnVVxh2Yy4YMrySR8AR\"]},\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"lib/openzeppelin-contracts/contracts/utils/Errors.sol\":{\"keccak256\":\"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf\",\"dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB\"]},\"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol\":{\"keccak256\":\"0x5b4802a4352474792df3107e961d1cc593e47b820c14f69d3505cb28f5a6a583\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a6f86fd01f829499fe0545ff5dda07d4521988e88bfe0bf801fc15650921ed56\",\"dweb:/ipfs/QmUUKu4ZDffHAmfkf3asuQfmLTyfpuy2Amdncc3SqfzKPG\"]},\"lib/openzeppelin-contracts/contracts/utils/Multicall.sol\":{\"keccak256\":\"0x72a5499dfae7676e4298a7299bccd3b27438ba1a4c72df5cd69c1c343c7ea20d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://de0fb51ccae3a0ff377ed185d187440fc612a71bf8e42fdb0e032ce747fa3eef\",\"dweb:/ipfs/QmPNBaiVsAiUhz8qfXcSy27S7CqBbtSd8rPqmaykKBhw7Q\"]},\"lib/openzeppelin-contracts/contracts/utils/Panic.sol\":{\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c6a5ff4f9fd8649b7ee20800b7fa387d3465bd77cf20c2d1068cd5c98e1ed57a\",\"dweb:/ipfs/QmVSaVJf9FXFhdYEYeCEfjMVHrxDh5qL4CGkxdMWpQCrqG\"]},\"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuardTransient.sol\":{\"keccak256\":\"0x8b95459390767d84c984d18faee298ce913e69cf0be8d2fe7785e2ad487ffed8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b5949065ea24feded902e4b0586f547ae6360b4eda7572419d72fe9d5714d1b9\",\"dweb:/ipfs/Qme52ocDwVG8nt9Xvf3j4h9SU1WWk2PHSEk97nRD4sNvY4\"]},\"lib/openzeppelin-contracts/contracts/utils/ShortStrings.sol\":{\"keccak256\":\"0x0768b3bdb701fe4994b3be932ca8635551dfebe04c645f77500322741bebf57c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a2059f9ca8d3c11c49ca49fc9c5fb070f18cc85d12a7688e45322ed0e2a1cb99\",\"dweb:/ipfs/QmS2gwX51RAvSw4tYbjHccY2CKbh2uvDzqHLAFXdsddgia\"]},\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b\",\"dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM\"]},\"lib/openzeppelin-contracts/contracts/utils/Strings.sol\":{\"keccak256\":\"0x36d1750bf1aa5fee9c52adb2f7857ab652daca722fc05dff533b364f67a1139a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2e5e7052539b7849d02f3ce25acc1dce29373c11cfae9f0bc918c54b780c549a\",\"dweb:/ipfs/QmRGE32xNkMTo6i4pHHMxjpiu77yPwnTA25SFngw2NXJys\"]},\"lib/openzeppelin-contracts/contracts/utils/TransientSlot.sol\":{\"keccak256\":\"0xac673fa1e374d9e6107504af363333e3e5f6344d2e83faf57d9bfd41d77cc946\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5982478dbbb218e9dd5a6e83f5c0e8d1654ddf20178484b43ef21dd2246809de\",\"dweb:/ipfs/QmaB1hS68n2kG8vTbt7EPEzmrGhkUbfiFyykGGLsAr9X22\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/ECDSA.sol\":{\"keccak256\":\"0x360cf86214a764694dae1522a38200b1737fe90e46dcf56a0f89de143071cc20\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2e393290a46ca6d1fa1addb40709d26e1d250638ab6acdd103b5af21768ebc7b\",\"dweb:/ipfs/QmPwT3tXwQ9NbGtZ99XRq7sr8LCQP8XaCrzw49JdXGn7us\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol\":{\"keccak256\":\"0x8440117ea216b97a7bad690a67449fd372c840d073c8375822667e14702782b4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ebb6645995b8290d0b9121825e2533e4e28977b2c6befee76e15e58f0feb61d4\",\"dweb:/ipfs/QmVR72j6kL5R2txuihieDev1FeTi4KWJS1Z6ABbwL3Qtph\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/MessageHashUtils.sol\":{\"keccak256\":\"0x6abeed5940e1da7bb329e458db9a1c5c4ea6f86d651b952af99c6bddcd6bbb94\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5fe75e9a6b759c5d7fd82fb59bd4f58c672b36f0a69b84f4789b7c7895d3e61c\",\"dweb:/ipfs/QmX28wsir8w5sS3acfJMNHcBwoPsDpqCu7WDkPnUWLMNiZ\"]},\"lib/openzeppelin-contracts/contracts/utils/cryptography/SignatureChecker.sol\":{\"keccak256\":\"0x445455b8be33e09cf1db14e59c0d1c5aa5d312b5e754e8ae751e42313a0cae88\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d6939df526d1c3f1d773448f6451eebb8de344113744e0da121b6349658b1298\",\"dweb:/ipfs/QmPffovzJ8qGRuUh57qrnWajHqYPPrntb1EA1VRh8p5TLP\"]},\"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617\",\"dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u\"]},\"lib/openzeppelin-contracts/contracts/utils/math/Math.sol\":{\"keccak256\":\"0x09e3f1c72d4c5cbe8e2644ab7313f8f7177533ae2f4c24cdcbbeaf520a73734c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://93208401215d539fa2d81626b207c1f611def7883d0e447b3b5969ebaa7b3c2c\",\"dweb:/ipfs/QmXPxDnQPx8LAweX5ZJqEcwkvs59kP4c64VVDG1Jjq1mef\"]},\"lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol\":{\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b1d578337048cad08c1c03041cca5978eff5428aa130c781b271ad9e5566e1f8\",\"dweb:/ipfs/QmPFKL2r9CBsMwmUqqdcFPfHZB2qcs9g1HDrPxzWSxomvy\"]},\"lib/openzeppelin-contracts/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0xb1970fac7b64e6c09611e6691791e848d5e3fe410fa5899e7df2e0afd77a99e3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://db5fbb3dddd8b7047465b62575d96231ba8a2774d37fb4737fbf23340fabbb03\",\"dweb:/ipfs/QmVUSvooZKEdEdap619tcJjTLcAuH6QBdZqAzWwnAXZAWJ\"]},\"src/interfaces/IDepositCollector.sol\":{\"keccak256\":\"0xc11528f5c3b3b4392705df68c9b2925c90e768c3bf34d13c58a04bdcc156ebc1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7761b53affced8b18ddc6c5d56db5de7df33970833d6f4599d4cff91b62a2c69\",\"dweb:/ipfs/QmTKSGnHM2CFCUVCndm48bAYTJ1X35RjcMVhLLHHQw3H8Q\"]},\"src/x402BatchSettlement.sol\":{\"keccak256\":\"0xa1d7b1c228f43964a6c299f5d4bceeca38f0e01870c6c6902fc5522b1955e7d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9625e247ce2bf7179df106196cee1d853bcbd8ac30bb05dc62a2eb87c97b7361\",\"dweb:/ipfs/QmRQkBDuJ28goiPCtgkDTLZfVJW1KyB6ZKVtMtpW1ndDQw\"]}},\"version\":1}","userdoc":{"kind":"user","events":{"Refunded(bytes32,address,uint128)":{"notice":"Emitted when escrowed funds are refunded to the payer."},"Claimed(bytes32,address,uint128,uint128)":{"notice":"Emitted when the receiver side increases the cumulative claimed amount for a channel."},"Settled(address,address,address,uint128)":{"notice":"Emitted when claimed funds are transferred to the receiver during settlement."},"WithdrawInitiated(bytes32,uint128,uint40)":{"notice":"Emitted when a timed withdrawal is started."},"Deposited(bytes32,address,uint128,uint128)":{"notice":"Emitted after a successful deposit into a channel."},"WithdrawFinalized(bytes32,address,uint128)":{"notice":"Emitted when a timed withdrawal completes and funds move to the payer."},"ChannelClosed(bytes32,(address,address,address,address,address,uint40,bytes32))":{"notice":"Emitted when unclaimed escrow returns to zero and no claims were recorded."},"ChannelCreated(bytes32,(address,address,address,address,address,uint40,bytes32))":{"notice":"Emitted the first time a channel receives escrowed balance."}},"notice":"Stateless unidirectional payment channel contract for the x402 `batch-settlement` scheme on EVM.","methods":{"constructor":{"notice":"Sets the EIP-712 domain for vouchers, refunds, and claim batches."},"settle(address,address)":{"notice":"Transfers claimed-but-not-yet-settled tokens to the receiver for a `(receiver, token)` pair."},"getVoucherDigest(bytes32,uint128)":{"notice":"EIP-712 digest for a `Voucher` with the given `channelId` and `maxClaimableAmount`."},"getRefundDigest(bytes32,uint256,uint128)":{"notice":"EIP-712 digest for a cooperative `Refund` authorization."},"getChannelId((address,address,address,address,address,uint40,bytes32))":{"notice":"Returns the canonical `channelId` for a channel configuration."},"refund((address,address,address,address,address,uint40,bytes32),uint128)":{"notice":"Cooperative refund of unclaimed escrow to the payer."},"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))":{"notice":"Finalizes a pending withdrawal after `withdrawDelay` and sends tokens to the payer."},"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)":{"notice":"Starts the payer-side timed withdrawal window for unclaimed escrow."},"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)":{"notice":"Deposits tokens into a channel using a pluggable collector."},"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"notice":"Applies a batch of voucher claims and updates channel accounting."},"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)":{"notice":"Refunds unclaimed escrow to the payer using an EIP-712 `Refund` signature from `receiverAuthorizer`."},"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"notice":"EIP-712 digest for the signed `ClaimBatch` (used by `claimWithSignature` and off-chain signing)."},"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)":{"notice":"Applies voucher claims authorized by a `receiverAuthorizer` EIP-712 signature over the batch."}},"version":1},"devdoc":{"kind":"dev","title":"x402BatchSettlement","author":"Coinbase","errors":{"FailedCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"InvalidChannel()":[{"details":"Errors use CapWords naming."}],"ECDSAInvalidSignature()":[{"details":"The signature derives the `address(0)`."}],"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"ECDSAInvalidSignatureS(bytes32)":[{"details":"The signature has an S value that is in the upper half order."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}],"ECDSAInvalidSignatureLength(uint256)":[{"details":"The signature has an invalid length."}]},"events":{"EIP712DomainChanged()":{"details":"MAY be emitted to signal that the domain could have changed."}},"details":"Channel identity is derived from an immutable `ChannelConfig`:      `channelId = keccak256(abi.encode(channelConfig))`.      Deploy at the same address on every chain via CREATE2.      Uses `ReentrancyGuardTransient` (EIP-1153); deploy only where transient storage is supported.      Fee-on-transfer and rebasing tokens are not recommended and are not guaranteed to behave like standard ERC-20s.","methods":{"eip712Domain()":{"details":"returns the fields and values that describe the domain separator used by this contract for EIP-712 signature."},"multicall(bytes[])":{"details":"Receives and executes a batch of function calls on this contract.","custom:oz-upgrades-unsafe-allow-reachable":"delegatecall"},"settle(address,address)":{"params":{"token":"The ERC-20 token to transfer.","receiver":"The receiver address whose pending settlement is swept."},"details":"Permissionless: typically called by the receiver or a facilitator."},"getVoucherDigest(bytes32,uint128)":{"params":{"channelId":"The channel identifier.","maxClaimableAmount":"The ceiling encoded in the voucher."},"returns":{"_0":"The typed data hash signers use for payer authorization."}},"getRefundDigest(bytes32,uint256,uint128)":{"params":{"nonce":"The refund nonce; must equal on-chain `refundNonce(channelId)` when `refundWithSignature` runs.","amount":"The signed refund amount.","channelId":"The channel identifier."},"details":"Off-chain signers should use the current `refundNonce(channelId)` as `nonce`. A successful direct `refund`      on the same channel advances that nonce and invalidates digests signed for the old value until re-signed.","returns":{"_0":"The typed data hash for `receiverAuthorizer` to sign."}},"getChannelId((address,address,address,address,address,uint40,bytes32))":{"params":{"config":"The channel configuration to hash."},"returns":{"_0":"The EIP-712 typed-data hash of `ChannelConfig`, bound to this contract's domain         (chainId + verifyingContract). Identical configs on different chains or different         deployments produce different ids, preventing cross-chain channel-state collision."}},"refund((address,address,address,address,address,uint40,bytes32),uint128)":{"params":{"amount":"Requested refund; capped to `balance - totalClaimed`. Reverts with `ZeroRefund` if `amount == 0`.               If the capped amount is zero but `amount > 0`, no token transfer occurs (no `Refunded` event)               yet `refundNonce` still advances (see `_executeRefund`).","config":"The channel configuration."},"details":"Only `receiverAuthorizer` or `receiver` may call. Shares `_executeRefund` with `refundWithSignature`, so      every successful call advances `refundNonce` for the channel. Any in-flight EIP-712 `Refund` signature      produced for the previous nonce becomes unusable; relayers and authorizers should expect re-signing if      direct refunds race ahead of relayed `refundWithSignature` submissions."},"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))":{"params":{"config":"The channel configuration."},"details":"Only `config.payer` or `config.payerAuthorizer` may call. Amount may be capped by available escrow.      Uses **current** `ch.balance` and `ch.totalClaimed` at execution time. If this transaction executes before a      competing `claim`, it can reduce escrow such that the claim later reverts with `ClaimExceedsBalance`."},"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)":{"params":{"amount":"The gross amount requested; may be capped on finalization.","config":"The channel configuration."},"details":"Only `config.payer` or `config.payerAuthorizer` may call. Reverts if a withdrawal is already pending.      Available liquidity is `ch.balance - ch.totalClaimed` using **only** on-chain `totalClaimed`. Payer-signed      vouchers that are not yet claimed do **not** reserve funds; receivers relying on voucher value must treat      inclusion of `claim` during the withdrawal window as an operational requirement (RPC outages, censorship,      or relay failure can interact badly with `finalizeWithdraw`)."},"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)":{"params":{"amount":"The exact amount of tokens to deposit.","config":"The immutable channel configuration.","collector":"The deposit collector contract address.","collectorData":"Opaque bytes forwarded to the collector (signatures, nonces, etc.)."},"details":"The collector executes the pull; this function checks the contract's token balance increased      by `amount` after the call (post-condition) to detect fee-on-transfer or failed pulls."},"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"params":{"voucherClaims":"Signed voucher rows with cumulative claim totals."},"details":"For each row, `msg.sender` must be `receiverAuthorizer` or `receiver` for that row's channel.      Receiver-side integrators should submit `claim` **promptly** once a payer-signed voucher should bind on-chain      entitlement: only **recorded** claims (`totalClaimed`) reduce what the payer can withdraw. If the payer      finalizes a timed withdrawal before this call executes, later `claim` can revert with `ClaimExceedsBalance`."},"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)":{"params":{"nonce":"Must equal `refundNonce(channelId)` at entry; `_executeRefund` increments it (same as `refund`).","amount":"The amount in the signature; capped like `refund`. If the capped amount is zero, no transfer               and no `Refunded` event, but `refundNonce` still advances once `_executeRefund` runs.","config":"The channel configuration.","receiverAuthorizerSignature":"EIP-712 signature from `receiverAuthorizer` over the refund digest."},"details":"Callable by anyone (relay-friendly). A prior direct `refund` on the same channel can advance the nonce      and cause `InvalidRefundNonce` here until the authorizer signs at the new nonce."},"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])":{"params":{"voucherClaims":"The claim rows hashed into the batch."},"details":"`claim` and `claimWithSignature` revert with `EmptyBatch()` when `voucherClaims.length == 0`, so they      never call this with an empty array. The digest for `length == 0` is still defined (`entriesRoot = keccak256(\"\")`)      for `eth_call` and off-chain tools to match this contract’s EIP-712 encoding without duplicating hashing logic.","returns":{"_0":"The typed data hash `receiverAuthorizer` signs for the batch."}},"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)":{"params":{"voucherClaims":"Claim rows for channels sharing the same `receiverAuthorizer`.","authorizerSignature":"Signature from `receiverAuthorizer` over `getClaimBatchDigest(voucherClaims)`."},"details":"Callable by anyone (relay-friendly). All rows must match the same `receiverAuthorizer`.      Same liveness consideration as `claim`: relays should submit before payer timed withdrawal drains escrow      (see `finalizeWithdraw` / `initiateWithdraw`)."}},"version":1,"stateVariables":{"refundNonce":{"details":"Monotonic sequence per `channelId` for EIP-712 `Refund` replay protection. Incremented inside      `_executeRefund` **before** the capped refund amount is applied, for **both** `refund` and      `refundWithSignature`, including when the capped amount is zero (no transfer, no `Refunded` event).      A direct `refund` therefore advances the nonce and invalidates any presigned `refundWithSignature`      digest that was bound to the previous nonce; coordinate receiver vs relayer flows off-chain."},"CLAIM_BATCH_TYPEHASH":{"details":"Full nested EIP-712 type so wallets can render `ClaimEntry[]` for user review."},"CLAIM_ENTRY_TYPEHASH":{"details":"EIP-712 entry for one row in a signed claim batch (mirrors on-chain `VoucherClaim` fields used for authorization)."}}},"storageLayout":{"types":{"t_uint40":{"label":"uint40","encoding":"inplace","numberOfBytes":"5"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint128":{"label":"uint128","encoding":"inplace","numberOfBytes":"16"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_bytes32,t_uint256)":{"key":"t_bytes32","label":"mapping(bytes32 => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_struct(ChannelState)8972_storage":{"label":"struct x402BatchSettlement.ChannelState","members":[{"slot":"0","type":"t_uint128","astId":8969,"label":"balance","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"0","type":"t_uint128","astId":8971,"label":"totalClaimed","offset":16,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}],"encoding":"inplace","numberOfBytes":"32"},"t_struct(ReceiverState)8985_storage":{"label":"struct x402BatchSettlement.ReceiverState","members":[{"slot":"0","type":"t_uint128","astId":8982,"label":"totalClaimed","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"0","type":"t_uint128","astId":8984,"label":"totalSettled","offset":16,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}],"encoding":"inplace","numberOfBytes":"32"},"t_struct(WithdrawalState)8979_storage":{"label":"struct x402BatchSettlement.WithdrawalState","members":[{"slot":"0","type":"t_uint128","astId":8975,"label":"amount","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"0","type":"t_uint40","astId":8978,"label":"initiatedAt","offset":16,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(ChannelState)8972_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct x402BatchSettlement.ChannelState)","value":"t_struct(ChannelState)8972_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_struct(ReceiverState)8985_storage)":{"key":"t_address","label":"mapping(address => struct x402BatchSettlement.ReceiverState)","value":"t_struct(ReceiverState)8985_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(WithdrawalState)8979_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct x402BatchSettlement.WithdrawalState)","value":"t_struct(WithdrawalState)8979_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_struct(ReceiverState)8985_storage))":{"key":"t_address","label":"mapping(address => mapping(address => struct x402BatchSettlement.ReceiverState))","value":"t_mapping(t_address,t_struct(ReceiverState)8985_storage)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_string_storage","astId":4739,"label":"_nameFallback","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"1","type":"t_string_storage","astId":4741,"label":"_versionFallback","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"2","type":"t_mapping(t_bytes32,t_struct(ChannelState)8972_storage)","astId":9039,"label":"channels","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"3","type":"t_mapping(t_bytes32,t_uint256)","astId":9044,"label":"refundNonce","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"4","type":"t_mapping(t_bytes32,t_struct(WithdrawalState)8979_storage)","astId":9049,"label":"pendingWithdrawals","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"},{"slot":"5","type":"t_mapping(t_address,t_mapping(t_address,t_struct(ReceiverState)8985_storage))","astId":9056,"label":"receivers","offset":0,"contract":"src/x402BatchSettlement.sol:x402BatchSettlement"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"1298:26723:29:-:0;;;8684:53;;;;;;;;;-1:-1:-1;3428:431:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;3428:431:21;;;;;3501:45;3428:431;-1:-1:-1;3501:30:21;:45::i;:::-;3493:53;;3567:51;:7;3601:16;3567:33;:51::i;:::-;3556:62;;3642:22;;;;;;;;;;3628:36;;3691:25;;;;;;3674:42;;3744:13;3727:30;;3792:23;4326:11;;4339:14;;4304:80;;;2079:95;4304:80;;;2914:25:30;2955:18;;;2948:34;;;;2998:18;;;2991:34;4355:13:21;3041:18:30;;;3034:34;4378:4:21;3084:19:30;;;3077:61;4268:7:21;;2886:19:30;;4304:80:21;;;;;;;;;;;;4294:91;;;;;;4287:98;;4213:179;;3792:23;3767:48;;-1:-1:-1;;3847:4:21;3825:27;;1298:26723:29;;2893:342:16;2989:11;3038:4;3022:5;3016:19;:26;3012:217;;;3065:20;3079:5;3065:13;:20::i;:::-;3058:27;;;;3012:217;3142:5;3116:46;3157:5;3142;3116:46;:::i;:::-;-1:-1:-1;1390:66:16;;-1:-1:-1;3012:217:16;2893:342;;;;:::o;1708:288::-;1773:11;1796:17;1822:3;1796:30;;1854:4;1840;:11;:18;1836:74;;;1895:3;1881:18;;-1:-1:-1;;;1881:18:16;;;;;;;;:::i;:::-;;;;;;;;1836:74;1976:11;;1959:13;1976:4;1959:13;:::i;:::-;1951:36;;1708:288;-1:-1:-1;;;1708:288:16:o;14:127:30:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:380;225:1;221:12;;;;268;;;289:61;;343:4;335:6;331:17;321:27;;289:61;396:2;388:6;385:14;365:18;362:38;359:161;;442:10;437:3;433:20;430:1;423:31;477:4;474:1;467:15;505:4;502:1;495:15;359:161;;146:380;;;:::o;657:518::-;759:2;754:3;751:11;748:421;;;795:5;792:1;785:16;839:4;836:1;826:18;909:2;897:10;893:19;890:1;886:27;880:4;876:38;945:4;933:10;930:20;927:47;;;-1:-1:-1;968:4:30;927:47;1023:2;1018:3;1014:12;1011:1;1007:20;1001:4;997:31;987:41;;1078:81;1096:2;1089:5;1086:13;1078:81;;;1155:1;1141:16;;1122:1;1111:13;1078:81;;;1082:3;;748:421;657:518;;;:::o;1351:1299::-;1471:10;;-1:-1:-1;;;;;1493:30:30;;1490:56;;;1526:18;;:::i;:::-;1555:97;1645:6;1605:38;1637:4;1631:11;1605:38;:::i;:::-;1599:4;1555:97;:::i;:::-;1701:4;1732:2;1721:14;;1749:1;1744:649;;;;2437:1;2454:6;2451:89;;;-1:-1:-1;2506:19:30;;;2500:26;2451:89;-1:-1:-1;;1308:1:30;1304:11;;;1300:24;1296:29;1286:40;1332:1;1328:11;;;1283:57;2553:81;;1714:930;;1744:649;604:1;597:14;;;641:4;628:18;;-1:-1:-1;;1780:20:30;;;1898:222;1912:7;1909:1;1906:14;1898:222;;;1994:19;;;1988:26;1973:42;;2101:4;2086:20;;;;2054:1;2042:14;;;;1928:12;1898:222;;;1902:3;2148:6;2139:7;2136:19;2133:201;;;2209:19;;;2203:26;-1:-1:-1;;2292:1:30;2288:14;;;2304:3;2284:24;2280:37;2276:42;2261:58;2246:74;;2133:201;-1:-1:-1;;;;2380:1:30;2364:14;;;2360:22;2347:36;;-1:-1:-1;1351:1299:30:o;3149:418::-;3298:2;3287:9;3280:21;3261:4;3330:6;3324:13;3373:6;3368:2;3357:9;3353:18;3346:34;3432:6;3427:2;3419:6;3415:15;3410:2;3399:9;3395:18;3389:50;3488:1;3483:2;3474:6;3463:9;3459:22;3455:31;3448:42;3558:2;3551;3547:7;3542:2;3534:6;3530:15;3526:29;3515:9;3511:45;3507:54;3499:62;;;3149:418;;;;:::o;3572:297::-;3690:12;;3737:4;3726:16;;;3720:23;;3690:12;3755:16;;3752:111;;;-1:-1:-1;;3829:4:30;3825:17;;;;3822:1;3818:25;3814:38;3803:50;;3572:297;-1:-1:-1;3572:297:30:o;:::-;1298:26723:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1298:26723:29:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9502:1547;;;;;;:::i;:::-;;:::i;:::-;;4221:109;;4263:67;4221:109;;;;;1754:25:30;;;1742:2;1727:18;4221:109:29;;;;;;;;3615:51;;3659:7;3615:51;;;;;2065:12:30;2053:25;;;2035:44;;2023:2;2008:18;3615:51:29;1891:194:30;5822:85:29;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5822:85:29;;;;-1:-1:-1;;;5822:85:29;;;;;;;;;-1:-1:-1;;;;;2547:47:30;;;2529:66;;2631:47;;;;2626:2;2611:18;;2604:75;2502:18;5822:85:29;2355:330:30;11894:466:29;;;;;;:::i;:::-;;:::i;23485:953::-;;;;;;:::i;:::-;;:::i;4709:182::-;;4756:135;4709:182;;21268:193;;;;;;:::i;:::-;;:::i;5076:58::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;5076:58:29;;;;-1:-1:-1;;;5076:58:29;;;;;5228:557:21;;;:::i;:::-;;;;;;;;;;;;;:::i;21775:215:29:-;;;;;;:::i;:::-;;:::i;3877:221::-;;3927:171;3877:221;;4105:109;;4148:66;4105:109;;14100:393;;;;;;:::i;:::-;;:::i;1224:482:13:-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3555:54:29:-;;3599:10;3555:54;;20032:600;;;;;;:::i;:::-;;:::i;5745:71::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;5745:71:29;;;-1:-1:-1;;;5745:71:29;;;;;;;;;;-1:-1:-1;;;;;8100:47:30;;;8082:66;;8196:12;8184:25;;;8179:2;8164:18;;8157:53;8055:18;5745:71:29;7910:306:30;4465:145:29;;4520:90;4465:145;;15471:884;;;;;;:::i;:::-;;:::i;18944:238::-;;;;;;:::i;:::-;;:::i;22616:211::-;;;;;;:::i;:::-;;:::i;12985:773::-;;;;;;:::i;:::-;;:::i;16884:1170::-;;;;;;:::i;:::-;;:::i;5683:56::-;;;;;;:::i;:::-;;;;;;;;;;;;;;9502:1547;1239:21:15;:19;:21::i;:::-;9713:1:29::1;9689:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;9689:26:29::1;::::0;9685:55:::1;;9724:16;;-1:-1:-1::0;;;9724:16:29::1;;;;;;;;;;;9685:55;9781:1;9754:15;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;9754:29:29::1;::::0;9750:58:::1;;9792:16;;-1:-1:-1::0;;;9792:16:29::1;;;;;;;;;;;9750:58;9859:1;9822:25;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;9822:39:29::1;::::0;9818:68:::1;;9870:16;;-1:-1:-1::0;;;9870:16:29::1;;;;;;;;;;;9818:68;9924:1;9900:12;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;9900:26:29::1;::::0;9896:55:::1;;9935:16;;-1:-1:-1::0;;;9935:16:29::1;;;;;;;;;;;9896:55;3599:10;9965:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;:41;;;:86;;;-1:-1:-1::0;3659:7:29::1;10010:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;:41;;;9965:86;9961:149;;;10074:25;;-1:-1:-1::0;;;10074:25:29::1;;;;;;;;;;;9961:149;10123:6;-1:-1:-1::0;;;;;10123:11:29::1;10133:1;10123:11:::0;10119:37:::1;;10143:13;;-1:-1:-1::0;;;10143:13:29::1;;;;;;;;;;;10119:37;-1:-1:-1::0;;;;;10170:23:29;::::1;10166:54;;10202:18;;-1:-1:-1::0;;;10202:18:29::1;;;;;;;;;;;10166:54;10231:17;10251:20;10264:6;10251:12;:20::i;:::-;10281:23;10307:19:::0;;;:8:::1;:19;::::0;;;;10370:10;;10231:40;;-1:-1:-1;10307:19:29;10350:30:::1;::::0;-1:-1:-1;;;;;10370:10:29;;::::1;::::0;10350:30:::1;:::i;:::-;-1:-1:-1::0;;;;;10341:39:29::1;:6;-1:-1:-1::0;;;;;10341:39:29::1;;10337:69;;;10389:17;;-1:-1:-1::0;;;10389:17:29::1;;;;;;;;;;;10337:69;10416:20:::0;;10430:6;;10416:2;;:10:::1;::::0;:20:::1;::::0;10430:6;;-1:-1:-1;;;;;10416:20:29::1;;:::i;:::-;;;;;;;;-1:-1:-1::0;;;;;10416:20:29::1;;;;;-1:-1:-1::0;;;;;10416:20:29::1;;;;;;10447:17;10474:6;:12;;;;;;;;;;:::i;:::-;10467:45;::::0;-1:-1:-1;;;10467:45:29;;10506:4:::1;10467:45;::::0;::::1;11278:51:30::0;-1:-1:-1;;;;;10467:30:29;;;::::1;::::0;::::1;::::0;11251:18:30;;10467:45:29::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10447:65:::0;-1:-1:-1;;;;;;10522:36:29;::::1;;10559:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;10573;::::0;;;::::1;::::0;::::1;;:::i;:::-;10587:6;10595:9;10606:13;;10522:98;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;10630:16:29::1;::::0;-1:-1:-1;10656:12:29::1;::::0;-1:-1:-1;;10656:12:29;;;::::1;::::0;::::1;;:::i;:::-;10649:45;::::0;-1:-1:-1;;;10649:45:29;;10688:4:::1;10649:45;::::0;::::1;11278:51:30::0;-1:-1:-1;;;;;10649:30:29;;;::::1;::::0;::::1;::::0;11251:18:30;;10649:45:29::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10630:64:::0;-1:-1:-1;10720:18:29::1;-1:-1:-1::0;;;;;10720:18:29;::::1;:9:::0;:18:::1;:::i;:::-;10708:8;:30;10704:68;;10747:25;;-1:-1:-1::0;;;10747:25:29::1;;;;;;;;;;;10704:68;10867:10:::0;;-1:-1:-1;;;;;10867:20:29;;::::1;:10:::0;::::1;:20;:44:::0;::::1;;;-1:-1:-1::0;10891:15:29;;-1:-1:-1;;;10891:15:29;::::1;-1:-1:-1::0;;;;;10891:15:29::1;:20:::0;10867:44:::1;10863:113;;;10947:9;10932:33;10958:6;10932:33;;;;;;:::i;:::-;;;;;;;;10863:113;11031:10:::0;;10990:52:::1;::::0;;-1:-1:-1;;;;;2547:47:30;;;2529:66;;11031:10:29;;::::1;2626:2:30::0;2611:18;;2604:75;11011:10:29::1;::::0;11000:9;;10990:52:::1;::::0;2502:18:30;10990:52:29::1;;;;;;;9675:1374;;;;1281:20:15::0;:18;:20::i;:::-;9502:1547:29;;;;;:::o;11894:466::-;1239:21:15;:19;:21::i;:::-;12022:1:29::1;11998:25:::0;;;11994:50:::1;;12032:12;;-1:-1:-1::0;;;12032:12:29::1;;;;;;;;;;;11994:50;12060:9;12055:299;12075:24:::0;;::::1;12055:299;;;12120:24;12147:13;;12161:1;12147:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:24:::0;-1:-1:-1;12198:30:29::1;12214:10;12147:24:::0;12198:15:::1;:30::i;:::-;12193:99;;12255:22;;-1:-1:-1::0;;;12255:22:29::1;;;;;;;;;;;12193:99;12305:38;12326:13;;12340:1;12326:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;12305:20;:38::i;:::-;-1:-1:-1::0;12101:3:29::1;;12055:299;;;;1281:20:15::0;:18;:20::i;:::-;11894:466:29;;:::o;23485:953::-;23588:7;23619:13;23588:7;23682:6;;;23678:663;;-1:-1:-1;23718:13:29;23678:663;;;23762:28;23807:1;23793:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23793:16:29;-1:-1:-1;23762:47:29;-1:-1:-1;23828:9:29;23823:440;23847:1;23843;:5;23823:440;;;23873:11;23887:46;23900:13;;23914:1;23900:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;23887:46::-;23873:60;;4520:90;24081:3;24110:13;;24124:1;24110:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:43;;;;;;;;;:::i;:::-;24179:13;;24193:1;24179:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:29;;;;;;;;;:::i;:::-;23999:231;;;;;;14503:25:30;;;;14544:18;;14537:34;;;;-1:-1:-1;;;;;14607:47:30;;;14587:18;;;14580:75;14691:47;14671:18;;;14664:75;14475:19;;23999:231:29;;;;;;;;;;;;23968:280;;;;;;23951:11;23963:1;23951:14;;;;;;;;:::i;:::-;;;;;;;;;;:297;-1:-1:-1;23850:3:29;;23823:440;;;;24317:11;24300:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;24290:40;;;;;;24276:54;;23748:593;23678:663;24384:45;;;4756:135;24384:45;;;15455:25:30;15496:18;;;15489:34;;;24357:74:29;;15428:18:30;;24384:45:29;;;;;;;;;;;;;24374:56;;;;;;24357:16;:74::i;:::-;24350:81;;;;23485:953;;;;;:::o;21268:193::-;21356:7;21382:72;3927:171;21445:6;21409:43;;;;;;;;;:::i;5228:557:21:-;5326:13;5353:18;5385:21;5420:15;5449:25;5488:12;5514:27;5617:13;:11;:13::i;:::-;5644:16;:14;:16::i;:::-;5752;;;5736:1;5752:16;;;;;;;;;-1:-1:-1;;;5566:212:21;;;-1:-1:-1;5566:212:21;;-1:-1:-1;5674:13:21;;-1:-1:-1;5709:4:21;;-1:-1:-1;5736:1:21;-1:-1:-1;5752:16:21;-1:-1:-1;5566:212:21;-1:-1:-1;5228:557:21:o;21775:215:29:-;21922:59;;;4148:66;21922:59;;;16088:25:30;16129:18;;;16122:34;;;-1:-1:-1;;;;;16192:47:30;;16172:18;;;16165:75;21869:7:29;;21895:88;;16061:18:30;;21922:59:29;15886:360:30;21895:88:29;21888:95;21775:215;-1:-1:-1;;;21775:215:29:o;14100:393::-;1239:21:15;:19;:21::i;:::-;-1:-1:-1;;;;;14208:19:29;;::::1;14181:24;14208:19:::0;;;:9:::1;:19;::::0;;;;;;;:26;;::::1;::::0;;;;;;;;14279:15;;14208:26;;14181:24;14261:33:::1;::::0;-1:-1:-1;;;;;;;;14279:15:29;::::1;::::0;::::1;::::0;14261::::1;:33;:::i;:::-;14244:50;;14308:6;-1:-1:-1::0;;;;;14308:11:29::1;14318:1;14308:11:::0;14304:24:::1;;14321:7;;;;14304:24;14356:15:::0;;-1:-1:-1;;;;;14356:15:29;;::::1;-1:-1:-1::0;;;14338:33:29;::::1;;::::0;;14382:44:::1;::::0;-1:-1:-1;;;;;14382:26:29;::::1;::::0;14409:8;;14382:44;::::1;:26;:44::i;:::-;14442;::::0;-1:-1:-1;;;;;16415:47:30;;16397:66;;14467:10:29::1;::::0;-1:-1:-1;;;;;14442:44:29;;::::1;::::0;;;::::1;::::0;::::1;::::0;16385:2:30;16370:18;14442:44:29::1;;;;;;;14171:322;;1270:1:15;1281:20:::0;:18;:20::i;1224:482:13:-;1388:12;;;1324:20;1388:12;;;;;;;;1290:22;;1499:4;1487:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1477:34:13;-1:-1:-1;1526:9:13;1521:155;1541:15;;;1521:155;;;1590:75;1627:4;1647;;1652:1;1647:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;1656;1634:30;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1590:28;:75::i;:::-;1577:7;1585:1;1577:10;;;;;;;;:::i;:::-;;;;;;;;;;:88;1558:3;;1521:155;;;;1685:14;1224:482;;;;:::o;20032:600:29:-;1239:21:15;:19;:21::i;:::-;20237:17:29::1;20257:20;20270:6;20257:12;:20::i;:::-;20300:22;::::0;;;:11:::1;:22;::::0;;;;;20237:40;;-1:-1:-1;20291:31:29;::::1;20287:64;;20331:20;;-1:-1:-1::0;;;20331:20:29::1;;;;;;;;;;;20287:64;20361:14;20378:41;20394:9;20405:5;20412:6;20378:15;:41::i;:::-;20361:58:::0;-1:-1:-1;20434:100:29::1;20471:25;::::0;;;::::1;::::0;::::1;;:::i;:::-;20498:6;20506:27;;20434:100;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;20434:36:29::1;::::0;-1:-1:-1;;;20434:100:29:i:1;:::-;20429:157;;20557:18;;-1:-1:-1::0;;;20557:18:29::1;;;;;;;;;;;20429:157;20595:30;20610:6;20618;20595:14;:30::i;:::-;20227:405;;1281:20:15::0;:18;:20::i;15471:884:29:-;1239:21:15;:19;:21::i;:::-;15594:12:29::1;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;15580:26:29::1;:10;-1:-1:-1::0;;;;;15580:26:29::1;;;:66;;;;-1:-1:-1::0;15624:22:29::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;15610:36:29::1;:10;-1:-1:-1::0;;;;;15610:36:29::1;;;15580:66;15576:120;;;15669:16;;-1:-1:-1::0;;;15669:16:29::1;;;;;;;;;;;15576:120;15709:6;-1:-1:-1::0;;;;;15709:11:29::1;15719:1;15709:11:::0;15705:43:::1;;15729:19;;-1:-1:-1::0;;;15729:19:29::1;;;;;;;;;;;15705:43;15759:17;15779:20;15792:6;15779:12;:20::i;:::-;15810:26;15839:29:::0;;;:18:::1;:29;::::0;;;;15882:14;;15839:29;;-1:-1:-1;15839:29:29;-1:-1:-1;;;15882:14:29;::::1;;;:19:::0;15878:58:::1;;15910:26;;-1:-1:-1::0;;;15910:26:29::1;;;;;;;;;;;15878:58;15947:23;15973:19:::0;;;:8:::1;:19;::::0;;;;16035:15;;15973:19;;15947:23;16022:28:::1;::::0;-1:-1:-1;;;;;;;;16035:15:29;::::1;::::0;::::1;::::0;16022:10:::1;:28;:::i;:::-;16002:48;;16073:9;-1:-1:-1::0;;;;;16064:18:29::1;:6;-1:-1:-1::0;;;;;16064:18:29::1;;16060:63;;;16091:32;;-1:-1:-1::0;;;16091:32:29::1;;;;;;;;;;;16060:63;16134:18:::0;;16162:40:::1;16186:15;16162:40;-1:-1:-1::0;;;16162:40:29::1;-1:-1:-1::0;;;;;;16162:40:29;;;-1:-1:-1;;;;;16134:18:29;::::1;16162:40:::0;::::1;::::0;;16134:9:::1;16262:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;16236:46;::::0;16243:15:::1;16236:46;:::i;:::-;16297:51;::::0;;-1:-1:-1;;;;;8100:47:30;;8082:66;;8196:12;8184:25;;8179:2;8164:18;;8157:53;16213:69:29;;-1:-1:-1;16315:9:29;;16297:51:::1;::::0;8055:18:30;16297:51:29::1;;;;;;;15566:789;;;;;1281:20:15::0;:18;:20::i;18944:238:29:-;1239:21:15;:19;:21::i;:::-;19044:35:29::1;19060:10;19072:6;19044:15;:35::i;:::-;19039:97;;19102:23;;-1:-1:-1::0;;;19102:23:29::1;;;;;;;;;;;19039:97;19145:30;19160:6;19168;19145:14;:30::i;22616:211::-:0;22765:53;;;4263:67;22765:53;;;18337:25:30;18378:18;;;18371:34;;;18421:18;;;18414:34;;;-1:-1:-1;;;;;18484:47:30;;18464:18;;;18457:75;22712:7:29;;22738:82;;18309:19:30;;22765:53:29;18106:432:30;22738:82:29;22731:89;22616:211;-1:-1:-1;;;;22616:211:29:o;12985:773::-;1239:21:15;:19;:21::i;:::-;13170:1:29::1;13146:25:::0;;;13142:50:::1;;13180:12;;-1:-1:-1::0;;;13180:12:29::1;;;;;;;;;;;13142:50;13203:18;13224:13;;13238:1;13224:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:51;::::0;;;;;::::1;;;:::i;:::-;13203:72;;13286:14;13303:34;13323:13;;13303:19;:34::i;:::-;13286:51;;13352:77;13389:10;13401:6;13409:19;;13352:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;13352:36:29::1;::::0;-1:-1:-1;;;13352:77:29:i:1;:::-;13347:134;;13452:18;;-1:-1:-1::0;;;13452:18:29::1;;;;;;;;;;;13347:134;13496:9;13491:261;13511:24:::0;;::::1;13491:261;;;13615:10;-1:-1:-1::0;;;;;13560:65:29::1;:13;;13574:1;13560:16;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:51;::::0;;;;;::::1;;;:::i;:::-;-1:-1:-1::0;;;;;13560:65:29::1;;13556:134;;13652:23;;-1:-1:-1::0;;;13652:23:29::1;;;;;;;;;;;13556:134;13703:38;13724:13;;13738:1;13724:16;;;;;;;:::i;13703:38::-;13537:3;;13491:261;;;;13132:626;;1281:20:15::0;:18;:20::i;:::-;12985:773:29;;;;:::o;16884:1170::-;1239:21:15;:19;:21::i;:::-;17005:12:29::1;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;16991:26:29::1;:10;-1:-1:-1::0;;;;;16991:26:29::1;;;:66;;;;-1:-1:-1::0;17035:22:29::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;17021:36:29::1;:10;-1:-1:-1::0;;;;;17021:36:29::1;;;16991:66;16987:137;;;17080:33;;-1:-1:-1::0;;;17080:33:29::1;;;;;;;;;;;16987:137;17134:17;17154:20;17167:6;17154:12;:20::i;:::-;17184:26;17213:29:::0;;;:18:::1;:29;::::0;;;;17257:14;;17213:29;;-1:-1:-1;17213:29:29;-1:-1:-1;;;17257:14:29;::::1;;;:19:::0;;17253:54:::1;;17285:22;;-1:-1:-1::0;;;17285:22:29::1;;;;;;;;;;;17253:54;17373:20;::::0;;;::::1;::::0;::::1;;:::i;:::-;17347:14:::0;;17339:55:::1;::::0;17365:29:::1;::::0;;::::1;::::0;-1:-1:-1;;;17347:14:29;::::1;;17339:55;:::i;:::-;17321:15;:73;17317:136;;;17417:25;;-1:-1:-1::0;;;17417:25:29::1;;;;;;;;;;;17317:136;17463:23;17489:19:::0;;;:8:::1;:19;::::0;;;;17551:15;;17489:19;;17463:23;17538:28:::1;::::0;-1:-1:-1;;;;;;;;17551:15:29;::::1;::::0;::::1;::::0;17538:10:::1;:28;:::i;:::-;17601:9:::0;;17518:48;;-1:-1:-1;17576:22:29::1;::::0;-1:-1:-1;;;;;17601:21:29;;::::1;:9:::0;::::1;:21;:45;;17637:9:::0;;-1:-1:-1;;;;;17637:9:29::1;17601:45;;;17625:9;17601:45;17657:13:::0;;-1:-1:-1;;;;;;17680:18:29;;;17708:28;;17576:70;;-1:-1:-1;17576:70:29;;17708:2;;17669:1:::1;::::0;17708:28:::1;::::0;17576:70;;-1:-1:-1;;;;;17708:28:29::1;;:::i;:::-;;;;;;;;-1:-1:-1::0;;;;;17708:28:29::1;;;;;-1:-1:-1::0;;;;;17708:28:29::1;;;;;;17781:10;-1:-1:-1::0;;;;;17752:56:29::1;17770:9;17752:56;17793:14;17752:56;;;;;-1:-1:-1::0;;;;;16415:47:30;;;;16397:66;;16385:2;16370:18;;16251:218;17752:56:29::1;;;;;;;;17823:10:::0;;-1:-1:-1;;;;;17823:10:29::1;:15:::0;:39;::::1;;;-1:-1:-1::0;17842:15:29;;-1:-1:-1;;;17842:15:29;::::1;-1:-1:-1::0;;;;;17842:15:29::1;:20:::0;17823:39:::1;17819:107;;;17897:9;17883:32;17908:6;17883:32;;;;;;:::i;:::-;;;;;;;;17819:107;-1:-1:-1::0;;;;;17940:18:29;::::1;::::0;17936:112:::1;;17974:63;18008:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;-1:-1:-1::0;;;;;17974:63:29;::::1;17981:12;::::0;;;::::1;::::0;::::1;;:::i;:::-;-1:-1:-1::0;;;;;17974:33:29::1;::::0;:63;:33:::1;:63::i;:::-;16977:1077;;;;;1281:20:15::0;:18;:20::i;:::-;16884:1170:29;:::o;1965:315:15:-;2119:25;:23;:25::i;:::-;2219:54;2268:4;661:66;2219:41;:48;;:54::i;:::-;1965:315::o;2286:110::-;2334:55;2383:5;661:66;2334:41;1666:115:19;24735:189:29;24830:4;24863:25;;;;;;;;:::i;:::-;-1:-1:-1;;;;;24853:35:29;:6;-1:-1:-1;;;;;24853:35:29;;:64;;;-1:-1:-1;24902:15:29;;;;;;;;:::i;:::-;-1:-1:-1;;;;;24892:25:29;:6;-1:-1:-1;;;;;24892:25:29;;24846:71;;24735:189;;;;:::o;25031:1254::-;25120:17;25140:32;25153:2;25140:12;:32::i;:::-;25182:23;25208:19;;;:8;:19;;;;;25261:15;;25208:19;;-1:-1:-1;25208:19:29;-1:-1:-1;;;25261:15:29;;-1:-1:-1;;;;;25261:15:29;25242;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25242:34:29;;25238:47;;25278:7;;25031:1254;:::o;25238:47::-;25316:29;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25298:47:29;:15;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25298:47:29;;25294:106;;;25368:21;;-1:-1:-1;;;25368:21:29;;;;;;;;;;;25294:106;25431:10;;-1:-1:-1;;;;;25431:10:29;25413:15;;;;;;;;:::i;:::-;-1:-1:-1;;;;;25413:28:29;;25409:62;;;25450:21;;-1:-1:-1;;;25450:21:29;;;;;;;;;;;25409:62;25482:14;25499:58;25516:9;25527:29;;;;;;;;:::i;25499:58::-;25482:75;-1:-1:-1;25568:17:29;25588:34;;;;;;;;:::i;:::-;25568:54;-1:-1:-1;;;;;;25636:23:29;;;25632:363;;25675:17;25695:43;25717:6;25725:12;;;;:2;:12;:::i;:::-;25695:21;:43::i;:::-;25675:63;;25769:9;-1:-1:-1;;;;;25756:22:29;:9;-1:-1:-1;;;;;25756:22:29;;25752:53;;25787:18;;-1:-1:-1;;;25787:18:29;;;;;;;;;;;25752:53;25661:155;25632:363;;;25841:84;25878:24;;;;:2;:24;:::i;:::-;25904:6;25912:12;;;;:2;:12;:::i;:::-;25841:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25841:36:29;;-1:-1:-1;;;25841:84:29:i;:::-;25836:149;;25952:18;;-1:-1:-1;;;25952:18:29;;;;;;;;;;;25836:149;26044:15;;26005:18;;-1:-1:-1;;;26044:15:29;;-1:-1:-1;;;;;26044:15:29;26026;;;;;;;;:::i;:::-;:33;;;;:::i;:::-;26005:54;-1:-1:-1;26087:15:29;;;;;;;;:::i;:::-;26069:33;;-1:-1:-1;;;;;26069:33:29;;;-1:-1:-1;;;26069:33:29;;;;;;26193:10;26112:9;26069:15;26122:27;;;;;;;;:::i;:::-;-1:-1:-1;;;;;26112:38:29;;;;;;;;;;;;-1:-1:-1;26112:38:29;;;;26151:24;;;;;;;;:::i;:::-;-1:-1:-1;;;;;26112:64:29;;;;;;;;;;;;-1:-1:-1;26112:64:29;;;:91;;:64;;-1:-1:-1;26112:91:29;;;;-1:-1:-1;;;;;26112:91:29;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;26112:91:29;;;;;-1:-1:-1;;;;;26112:91:29;;;;;;26238:10;-1:-1:-1;;;;;26219:59:29;26227:9;26219:59;26250:10;26262:2;:15;;;;;;;;;;:::i;:::-;26219:59;;;-1:-1:-1;;;;;2547:47:30;;;2529:66;;2631:47;;;;2626:2;2611:18;;2604:75;2502:18;26219:59:29;;;;;;;25110:1175;;;;;25031:1254;:::o;5017:176:21:-;5094:7;5120:66;5153:20;:18;:20::i;:::-;5175:10;4049:4:22;4043:11;-1:-1:-1;;;4067:23:22;;4119:4;4110:14;;4103:39;;;;4171:4;4162:14;;4155:34;4227:4;4212:20;;;3874:374;6105:126:21;6151:13;6183:41;:5;6210:13;6183:26;:41::i;:::-;6176:48;;6105:126;:::o;6557:135::-;6606:13;6638:47;:8;6668:16;6638:29;:47::i;1219:204:7:-;1306:37;1320:5;1327:2;1331:5;1338:4;1306:13;:37::i;:::-;1301:116;;1366:40;;-1:-1:-1;;;1366:40:7;;-1:-1:-1;;;;;11296:32:30;;1366:40:7;;;11278:51:30;11251:18;;1366:40:7;;;;;;;;1301:116;1219:204;;;:::o;4691:549:8:-;4774:12;4798;4813:47;4847:6;4855:4;4813:33;:47::i;:::-;4798:62;;4874:7;:72;;;;-1:-1:-1;4918:1:8;4583:16:12;4886:33:8;:59;;;;4944:1;4923:6;-1:-1:-1;;;;;4923:18:8;;:22;4886:59;4870:364;;;4969:25;:23;:25::i;:::-;4962:32;;;;;4870:364;5015:7;5011:223;;;5045:24;;-1:-1:-1;;;5045:24:8;;-1:-1:-1;;;;;11296:32:30;;5045:24:8;;;11278:51:30;11251:18;;5045:24:8;11132:203:30;5011:223:8;4583:16:12;5090:33:8;5086:148;;5139:27;:25;:27::i;:::-;5086:148;;;5204:19;;-1:-1:-1;;;5204:19:8;;;;;;;;;;;5086:148;4788:452;4691:549;;;;:::o;1485:429:23:-;1591:4;1611:6;-1:-1:-1;;;;;1611:18:23;;1633:1;1611:23;1607:301;;1651:17;1670:22;1698:33;1715:4;1721:9;1698:16;:33::i;:::-;-1:-1:-1;1650:81:23;;-1:-1:-1;1650:81:23;-1:-1:-1;1759:26:23;1752:3;:33;;;;;;;;:::i;:::-;;:56;;;;;1802:6;-1:-1:-1;;;;;1789:19:23;:9;-1:-1:-1;;;;;1789:19:23;;1752:56;1745:63;;;;;;1607:301;1846:51;1873:6;1881:4;1887:9;1846:26;:51::i;:::-;1839:58;;;;26945:1074:29;27039:6;-1:-1:-1;;;;;27039:11:29;27049:1;27039:11;27035:36;;27059:12;;-1:-1:-1;;;27059:12:29;;;;;;;;;;;27035:36;27082:17;27102:20;27115:6;27102:12;:20::i;:::-;27156:22;;;;:11;:22;;;;;;;;:24;;;;;;27227:8;:19;;;;;27289:15;;27082:40;;-1:-1:-1;27227:19:29;27276:28;;-1:-1:-1;;;;;;;;27289:15:29;;;;;27276:10;:28;:::i;:::-;27256:48;;27314:20;27346:9;-1:-1:-1;;;;;27337:18:29;:6;-1:-1:-1;;;;;27337:18:29;;:39;;27370:6;27337:39;;;27358:9;27337:39;27314:62;;27390:12;-1:-1:-1;;;;;27390:17:29;27406:1;27390:17;27386:30;;27409:7;;;;26945:1074;;:::o;27386:30::-;27426:26;;27440:12;;27426:2;;:10;;:26;;27440:12;;-1:-1:-1;;;;;27426:26:29;;:::i;:::-;;;-1:-1:-1;;;;;27426:26:29;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;27493:29:29;;;:18;:29;;;;;27536:15;;;-1:-1:-1;;;27536:15:29;;;;:20;27532:231;;27592:10;;-1:-1:-1;;;;;27592:10:29;;;27576:26;;;;27572:181;;27622:14;;-1:-1:-1;;;;;;27654:19:29;;;27572:181;;;27712:26;;27726:12;;27712:3;;:10;;:26;;27726:12;;-1:-1:-1;;;;;27712:26:29;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;27712:26:29;;;;;-1:-1:-1;;;;;27712:26:29;;;;;;27572:181;27778:45;;-1:-1:-1;;;;;16415:47:30;;16397:66;;27798:10:29;;27787:9;;27778:45;;16385:2:30;16370:18;27778:45:29;;;;;;;27838:10;;-1:-1:-1;;;;;27838:10:29;:15;:39;;;;-1:-1:-1;27857:15:29;;-1:-1:-1;;;27857:15:29;;-1:-1:-1;;;;;27857:15:29;:20;27838:39;27834:107;;;27912:9;27898:32;27923:6;27898:32;;;;;;:::i;:::-;;;;;;;;27834:107;27951:61;27985:12;;;;:6;:12;:::i;:::-;-1:-1:-1;;;;;27951:61:29;;27958:12;;;;;;;;:::i;27951:61::-;27025:994;;;;;26945:1074;;:::o;1802:157:15:-;661:66;3375:11:19;1860:93:15;;;1912:30;;-1:-1:-1;;;1912:30:15;;;;;;;;;;;3491:139:19;3608:5;3602:4;3595:19;3491:139;;:::o;5635:273:20:-;5723:7;5743:17;5762:18;5782:16;5802:35;5821:4;5827:9;;5802:18;:35::i;:::-;5742:95;;;;;;5847:28;5859:5;5866:8;5847:11;:28::i;:::-;-1:-1:-1;5892:9:20;;5635:273;-1:-1:-1;;;;;5635:273:20:o;3945:262:21:-;3998:7;4029:4;-1:-1:-1;;;;;4038:11:21;4021:28;;:63;;;;;4070:14;4053:13;:31;4021:63;4017:184;;;-1:-1:-1;4107:22:21;;3945:262::o;4017:184::-;4167:23;4304:80;;;2079:95;4304:80;;;19319:25:30;4326:11:21;19360:18:30;;;19353:34;;;;4339:14:21;19403:18:30;;;19396:34;4355:13:21;19446:18:30;;;19439:34;4378:4:21;19489:19:30;;;19482:61;4268:7:21;;19291:19:30;;4304:80:21;;;;;;;;;;;;4294:91;;;;;;4287:98;;4213:179;;3376:267:16;3470:13;1390:66;3499:46;;3495:142;;3568:15;3577:5;3568:8;:15::i;:::-;3561:22;;;;3495:142;3621:5;3614:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8373:1244:7;8600:4;8594:11;-1:-1:-1;;;8467:12:7;8618:22;;;-1:-1:-1;;;;;8666:24:7;;8660:4;8653:38;8711:4;8704:19;;;8467:12;8787:4;8467:12;8775:4;8467:12;;8759:5;8752;8747:45;8736:56;;9004:1;8997:4;8991:11;8988:18;8979:7;8975:32;8965:606;;9136:6;9126:7;9119:15;9115:28;9112:165;;;9192:16;9186:4;9181:3;9166:43;9242:16;9237:3;9230:29;9112:165;9553:1;9545:5;9533:18;9530:25;9511:16;9504:24;9500:56;9491:7;9487:70;9476:81;;8965:606;9591:4;9584:17;-1:-1:-1;8373:1244:7;;-1:-1:-1;;;;8373:1244:7:o;3383:242:12:-;3466:12;3604:4;3598;3591;3585:11;3578:4;3572;3568:15;3560:6;3553:5;3540:69;3529:80;3383:242;-1:-1:-1;;;3383:242:12:o;4698:334::-;4829:4;4823:11;4862:16;4847:32;;4932:16;4926:4;4919;4907:17;;4892:57;4997:16;4991:4;4987:27;4979:6;4975:40;4969:4;4962:54;4698:334;:::o;5099:223::-;5203:4;5197:11;5247:16;5241:4;5236:3;5221:43;5289:16;5284:3;5277:29;2433:778:20;2536:17;2555:16;2573:14;2603:9;:16;2623:2;2603:22;2599:606;;2908:4;2893:20;;2887:27;2957:4;2942:20;;2936:27;3014:4;2999:20;;2993:27;2641:9;2985:36;3055:25;3066:4;2985:36;2887:27;2936;3055:10;:25::i;:::-;3048:32;;;;;;;;;;;2599:606;-1:-1:-1;;3176:16:20;;3127:1;;-1:-1:-1;3131:35:20;;2599:606;2433:778;;;;;:::o;2900:986:23:-;3145:16;;3500:4;3494:11;;-1:-1:-1;;;3518:21:23;;;3568:4;3559:14;;3552:28;;;3609:4;3600:14;;3593:28;;;;3043:11;;3145:16;3679:4;3667:17;;3145:9;3649:4;3640:14;;3634:51;3770:4;3764;3757;3749:6;3745:17;3740:3;3732:6;3725:5;3714:61;3699:76;;3859:8;3852:4;3846:11;3843:25;3836:4;3818:16;3815:26;3811:58;3802:7;3798:72;3788:82;;;3197:683;;2900:986;;;;;:::o;3304:882:20:-;3417:17;;;3504:2;3484:22;;;3480:700;;3831:30;;3918:4;3896:27;;3883:41;3989:4;3967:27;;3954:41;3522:9;3946:50;4030:25;4041:4;3946:50;3831:30;3883:41;4030:10;:25::i;:::-;4023:32;;;;;;;;;;;3480:700;-1:-1:-1;4102:1:20;;-1:-1:-1;4106:35:20;;-1:-1:-1;4151:9:20;3480:700;3304:882;;;;;;;:::o;11630:532::-;11725:20;11716:5;:29;;;;;;;;:::i;:::-;;11712:444;;11630:532;;:::o;11712:444::-;11821:29;11812:5;:38;;;;;;;;:::i;:::-;;11808:348;;11873:23;;-1:-1:-1;;;11873:23:20;;;;;;;;;;;11808:348;11926:35;11917:5;:44;;;;;;;;:::i;:::-;;11913:243;;11984:46;;-1:-1:-1;;;11984:46:20;;;;;1754:25:30;;;1727:18;;11984:46:20;1608:177:30;11913:243:20;12060:30;12051:5;:39;;;;;;;;:::i;:::-;;12047:109;;12113:32;;-1:-1:-1;;;12113:32:20;;;;;1754:25:30;;;1727:18;;12113:32:20;1608:177:30;2080:380:16;2139:13;2164:11;2178:16;2189:4;2178:10;:16::i;:::-;2302;;;2313:4;2302:16;;;;;;;;;2164:30;;-1:-1:-1;2282:17:16;;2302:16;;;;;;;;;-1:-1:-1;;;2367:16:16;;;-1:-1:-1;2412:4:16;2403:14;;2396:28;;;;-1:-1:-1;2367:16:16;2080:380::o;7142:1551:20:-;7268:17;;;8222:66;8209:79;;8205:164;;;-1:-1:-1;8320:1:20;;-1:-1:-1;8324:30:20;;-1:-1:-1;8356:1:20;8304:54;;8205:164;8480:24;;;8463:14;8480:24;;;;;;;;;19781:25:30;;;19854:4;19842:17;;19822:18;;;19815:45;;;;19876:18;;;19869:34;;;19919:18;;;19912:34;;;8480:24:20;;19753:19:30;;8480:24:20;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;8480:24:20;;-1:-1:-1;;8480:24:20;;;-1:-1:-1;;;;;;;8518:20:20;;8514:113;;-1:-1:-1;8570:1:20;;-1:-1:-1;8574:29:20;;-1:-1:-1;8570:1:20;;-1:-1:-1;8554:62:20;;8514:113;8645:6;-1:-1:-1;8653:20:20;;-1:-1:-1;8653:20:20;;-1:-1:-1;7142:1551:20;;;;;;;;;:::o;2532:247:16:-;2593:7;2665:4;2629:40;;2692:4;2683:13;;2679:71;;;2719:20;;-1:-1:-1;;;2719:20:16;;;;;;;;;;;14:162:30;80:5;125:3;116:6;111:3;107:16;103:26;100:46;;;142:1;139;132:12;100:46;-1:-1:-1;164:6:30;14:162;-1:-1:-1;14:162:30:o;181:188::-;249:20;;-1:-1:-1;;;;;298:46:30;;288:57;;278:85;;359:1;356;349:12;278:85;181:188;;;:::o;374:173::-;442:20;;-1:-1:-1;;;;;491:31:30;;481:42;;471:70;;537:1;534;527:12;552:347;603:8;613:6;667:3;660:4;652:6;648:17;644:27;634:55;;685:1;682;675:12;634:55;-1:-1:-1;708:20:30;;751:18;740:30;;737:50;;;783:1;780;773:12;737:50;820:4;812:6;808:17;796:29;;872:3;865:4;856:6;848;844:19;840:30;837:39;834:59;;;889:1;886;879:12;834:59;552:347;;;;;:::o;904:699::-;1034:6;1042;1050;1058;1066;1119:3;1107:9;1098:7;1094:23;1090:33;1087:53;;;1136:1;1133;1126:12;1087:53;1159:60;1211:7;1200:9;1159:60;:::i;:::-;1149:70;;1238:39;1272:3;1261:9;1257:19;1238:39;:::i;:::-;1228:49;;1296:39;1330:3;1319:9;1315:19;1296:39;:::i;:::-;1286:49;;1386:3;1375:9;1371:19;1358:33;1414:18;1406:6;1403:30;1400:50;;;1446:1;1443;1436:12;1400:50;1485:58;1535:7;1526:6;1515:9;1511:22;1485:58;:::i;:::-;904:699;;;;-1:-1:-1;904:699:30;;-1:-1:-1;1562:8:30;;1459:84;904:699;-1:-1:-1;;;904:699:30:o;2090:260::-;2158:6;2166;2219:2;2207:9;2198:7;2194:23;2190:32;2187:52;;;2235:1;2232;2225:12;2187:52;2258:29;2277:9;2258:29;:::i;:::-;2248:39;;2306:38;2340:2;2329:9;2325:18;2306:38;:::i;:::-;2296:48;;2090:260;;;;;:::o;2690:388::-;2774:8;2784:6;2838:3;2831:4;2823:6;2819:17;2815:27;2805:55;;2856:1;2853;2846:12;2805:55;-1:-1:-1;2879:20:30;;2922:18;2911:30;;2908:50;;;2954:1;2951;2944:12;2908:50;2991:4;2983:6;2979:17;2967:29;;3051:3;3044:4;3034:6;3031:1;3027:14;3019:6;3015:27;3011:38;3008:47;3005:67;;;3068:1;3065;3058:12;3083:490;3201:6;3209;3262:2;3250:9;3241:7;3237:23;3233:32;3230:52;;;3278:1;3275;3268:12;3230:52;3318:9;3305:23;3351:18;3343:6;3340:30;3337:50;;;3383:1;3380;3373:12;3337:50;3422:91;3505:7;3496:6;3485:9;3481:22;3422:91;:::i;:::-;3532:8;;3396:117;;-1:-1:-1;3083:490:30;-1:-1:-1;;;;3083:490:30:o;3578:251::-;3670:6;3723:3;3711:9;3702:7;3698:23;3694:33;3691:53;;;3740:1;3737;3730:12;3691:53;3763:60;3815:7;3804:9;3763:60;:::i;3834:226::-;3893:6;3946:2;3934:9;3925:7;3921:23;3917:32;3914:52;;;3962:1;3959;3952:12;3914:52;-1:-1:-1;4007:23:30;;3834:226;-1:-1:-1;3834:226:30:o;4065:289::-;4107:3;4145:5;4139:12;4172:6;4167:3;4160:19;4228:6;4221:4;4214:5;4210:16;4203:4;4198:3;4194:14;4188:47;4280:1;4273:4;4264:6;4259:3;4255:16;4251:27;4244:38;4343:4;4336:2;4332:7;4327:2;4319:6;4315:15;4311:29;4306:3;4302:39;4298:50;4291:57;;;4065:289;;;;:::o;4359:1238::-;4765:3;4760;4756:13;4748:6;4744:26;4733:9;4726:45;4807:3;4802:2;4791:9;4787:18;4780:31;4707:4;4834:46;4875:3;4864:9;4860:19;4852:6;4834:46;:::i;:::-;4928:9;4920:6;4916:22;4911:2;4900:9;4896:18;4889:50;4962:33;4988:6;4980;4962:33;:::i;:::-;5026:2;5011:18;;5004:34;;;-1:-1:-1;;;;;5075:32:30;;5069:3;5054:19;;5047:61;5095:3;5124:19;;5117:35;;;5189:22;;;5183:3;5168:19;;5161:51;5261:13;;5283:22;;;5333:2;5359:15;;;;-1:-1:-1;5321:15:30;;;;-1:-1:-1;5402:169:30;5416:6;5413:1;5410:13;5402:169;;;5477:13;;5465:26;;5520:2;5546:15;;;;5511:12;;;;5438:1;5431:9;5402:169;;;-1:-1:-1;5588:3:30;;4359:1238;-1:-1:-1;;;;;;;;;;;4359:1238:30:o;5602:300::-;5670:6;5678;5731:2;5719:9;5710:7;5706:23;5702:32;5699:52;;;5747:1;5744;5737:12;5699:52;5792:23;;;-1:-1:-1;5858:38:30;5892:2;5877:18;;5858:38;:::i;6381:780::-;6541:4;6589:2;6578:9;6574:18;6619:2;6608:9;6601:21;6642:6;6677;6671:13;6708:6;6700;6693:22;6746:2;6735:9;6731:18;6724:25;;6808:2;6798:6;6795:1;6791:14;6780:9;6776:30;6772:39;6758:53;;6846:2;6838:6;6834:15;6867:1;6877:255;6891:6;6888:1;6885:13;6877:255;;;6984:2;6980:7;6968:9;6960:6;6956:22;6952:36;6947:3;6940:49;7012:40;7045:6;7036;7030:13;7012:40;:::i;:::-;7002:50;-1:-1:-1;7087:2:30;7110:12;;;;7075:15;;;;;6913:1;6906:9;6877:255;;;-1:-1:-1;7149:6:30;;6381:780;-1:-1:-1;;;;;;6381:780:30:o;7166:739::-;7296:6;7304;7312;7320;7328;7381:3;7369:9;7360:7;7356:23;7352:33;7349:53;;;7398:1;7395;7388:12;7349:53;7421:60;7473:7;7462:9;7421:60;:::i;:::-;7411:70;;7500:39;7534:3;7523:9;7519:19;7500:39;:::i;:::-;7490:49;-1:-1:-1;7608:3:30;7593:19;;7580:33;;-1:-1:-1;7688:3:30;7673:19;;7660:33;7716:18;7705:30;;7702:50;;;7748:1;7745;7738:12;8221:326;8322:6;8330;8383:3;8371:9;8362:7;8358:23;8354:33;8351:53;;;8400:1;8397;8390:12;8351:53;8423:60;8475:7;8464:9;8423:60;:::i;:::-;8413:70;;8502:39;8536:3;8525:9;8521:19;8502:39;:::i;8552:420::-;8629:6;8637;8645;8698:2;8686:9;8677:7;8673:23;8669:32;8666:52;;;8714:1;8711;8704:12;8666:52;8759:23;;;-1:-1:-1;8879:2:30;8864:18;;8851:32;;-1:-1:-1;8928:38:30;8962:2;8947:18;;8928:38;:::i;:::-;8918:48;;8552:420;;;;;:::o;8977:793::-;9115:6;9123;9131;9139;9192:2;9180:9;9171:7;9167:23;9163:32;9160:52;;;9208:1;9205;9198:12;9160:52;9248:9;9235:23;9281:18;9273:6;9270:30;9267:50;;;9313:1;9310;9303:12;9267:50;9352:91;9435:7;9426:6;9415:9;9411:22;9352:91;:::i;:::-;9462:8;;-1:-1:-1;9326:117:30;-1:-1:-1;;9550:2:30;9535:18;;9522:32;9579:18;9566:32;;9563:52;;;9611:1;9608;9601:12;9563:52;9650:60;9702:7;9691:8;9680:9;9676:24;9650:60;:::i;:::-;8977:793;;;;-1:-1:-1;9729:8:30;-1:-1:-1;;;;8977:793:30:o;9957:186::-;10016:6;10069:2;10057:9;10048:7;10044:23;10040:32;10037:52;;;10085:1;10082;10075:12;10037:52;10108:29;10127:9;10108:29;:::i;10148:165::-;10215:20;;10275:12;10264:24;;10254:35;;10244:63;;10303:1;10300;10293:12;10318:184;10376:6;10429:2;10417:9;10408:7;10404:23;10400:32;10397:52;;;10445:1;10442;10435:12;10397:52;10468:28;10486:9;10468:28;:::i;10507:127::-;10568:10;10563:3;10559:20;10556:1;10549:31;10599:4;10596:1;10589:15;10623:4;10620:1;10613:15;10639:243;-1:-1:-1;;;;;10754:42:30;;;10710;;;10706:91;;10809:44;;10806:70;;;10856:18;;:::i;10887:240::-;-1:-1:-1;;;;;10956:42:30;;;11000;;;10952:91;;11055:43;;11052:69;;;11101:18;;:::i;11340:184::-;11410:6;11463:2;11451:9;11442:7;11438:23;11434:32;11431:52;;;11479:1;11476;11469:12;11431:52;-1:-1:-1;11502:16:30;;11340:184;-1:-1:-1;11340:184:30:o;11529:771::-;-1:-1:-1;;;;;11798:32:30;;;11780:51;;11867:32;;11862:2;11847:18;;11840:60;-1:-1:-1;;;;;11936:47:30;;11931:2;11916:18;;11909:75;12015:2;12000:18;;11993:34;;;11818:3;12058;12043:19;;12036:32;;;12084:19;;12077:35;;;12105:6;12155;12149:3;12134:19;;12121:49;12220:1;12190:22;;;12214:3;12186:32;;;12179:43;;;;12283:2;12262:15;;;-1:-1:-1;;12258:29:30;12243:45;12239:55;;11529:771;-1:-1:-1;;;;;11529:771:30:o;12305:125::-;12370:9;;;12391:10;;;12388:36;;;12404:18;;:::i;12435:761::-;-1:-1:-1;;;;;12527:25:30;12546:5;12527:25;:::i;:::-;12523:51;12511:64;;-1:-1:-1;;;;;12611:36:30;12641:4;12630:16;;12611:36;:::i;:::-;12607:62;12600:4;12591:14;;12584:86;-1:-1:-1;;;;;12706:36:30;12736:4;12725:16;;12706:36;:::i;:::-;12702:62;12695:4;12686:14;;12679:86;-1:-1:-1;;;;;12801:36:30;12831:4;12820:16;;12801:36;:::i;:::-;12797:62;12790:4;12781:14;;12774:86;-1:-1:-1;;;;;12896:36:30;12926:4;12915:16;;12896:36;:::i;:::-;12892:62;12885:4;12880:3;12876:14;12869:86;12984:35;13013:4;13006:5;13002:16;12984:35;:::i;:::-;1866:12;1855:24;13069:4;13060:14;;1843:37;13144:4;13133:16;;;13120:30;13166:14;;13159:31;12435:761::o;13201:276::-;13399:3;13384:19;;13412:59;13388:9;13453:6;13412:59;:::i;13482:127::-;13543:10;13538:3;13534:20;13531:1;13524:31;13574:4;13571:1;13564:15;13598:4;13595:1;13588:15;13614:330;13712:4;13770:11;13757:25;13864:3;13860:8;13849;13833:14;13829:29;13825:44;13805:18;13801:69;13791:97;;13884:1;13881;13874:12;13791:97;13905:33;;;;;13614:330;-1:-1:-1;;13614:330:30:o;13949:127::-;14010:10;14005:3;14001:20;13998:1;13991:31;14041:4;14038:1;14031:15;14065:4;14062:1;14055:15;14081:186;14140:6;14193:2;14181:9;14172:7;14168:23;14164:32;14161:52;;;14209:1;14206;14199:12;14161:52;14232:29;14251:9;14232:29;:::i;14750:526::-;14968:13;;14911:3;;14942;;15037:4;15025:17;;14911:3;15070:179;15084:6;15081:1;15078:13;15070:179;;;15147:13;;15133:28;;15194:4;15183:16;;;;15222:17;;;;15106:1;15099:9;15070:179;;;-1:-1:-1;15265:5:30;;14750:526;-1:-1:-1;;;;;14750:526:30:o;15534:347::-;15773:25;;;15760:3;15745:19;;15807:68;15871:2;15856:18;;15848:6;15807:68;:::i;16943:521::-;17020:4;17026:6;17086:11;17073:25;17180:2;17176:7;17165:8;17149:14;17145:29;17141:43;17121:18;17117:68;17107:96;;17199:1;17196;17189:12;17107:96;17226:33;;17278:20;;;-1:-1:-1;17321:18:30;17310:30;;17307:50;;;17353:1;17350;17343:12;17307:50;17386:4;17374:17;;-1:-1:-1;17417:14:30;17413:27;;;17403:38;;17400:58;;;17454:1;17451;17444:12;17469:454;17698:6;17690;17685:3;17672:33;17654:3;17733:6;17728:3;17724:16;17760:1;17756:2;17749:13;17791:6;17785:13;17836:6;17829:4;17821:6;17817:17;17813:2;17807:36;17897:1;17862:15;;17886:13;;;17862:15;17469:454;-1:-1:-1;;;;;17469:454:30:o;17928:173::-;18025:12;17996:20;;;18018;;;17992:47;;18051:21;;18048:47;;;18075:18;;:::i;18543:127::-;18604:10;18599:3;18595:20;18592:1;18585:31;18635:4;18632:1;18625:15;18659:4;18656:1;18649:15;18675:380;18754:1;18750:12;;;;18797;;;18818:61;;18872:4;18864:6;18860:17;18850:27;;18818:61;18925:2;18917:6;18914:14;18894:18;18891:38;18888:161;;18971:10;18966:3;18962:20;18959:1;18952:31;19006:4;19003:1;18996:15;19034:4;19031:1;19024:15","linkReferences":{},"immutableReferences":{"4723":[{"start":8017,"length":32}],"4725":[{"start":7975,"length":32}],"4727":[{"start":7933,"length":32}],"4729":[{"start":8098,"length":32}],"4731":[{"start":8138,"length":32}],"4734":[{"start":6790,"length":32}],"4737":[{"start":6839,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"CHANNEL_CONFIG_TYPEHASH()","signatureHash4":"0x8e4a68ac","signatureHash32":"0x8e4a68acacf66071f90a05df231628129396a1a94f793fdf54a63d0a21d89827"},{"signature":"channels(bytes32)","signatureHash4":"0x7a7ebd7b","signatureHash32":"0x7a7ebd7b6e6a74838f6ed5c81dbb54ecd4b26f2e12a92b6199af4c5db9b46bf8"},{"signature":"claim((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])","signatureHash4":"0x29237b0c","signatureHash32":"0x29237b0c8a48f8d063744edccf986a297f3ff42e310ce7c16a4db078445d7f86"},{"signature":"CLAIM_BATCH_TYPEHASH()","signatureHash4":"0x53ab0fae","signatureHash32":"0x53ab0fae36cf80ed6d73fe8353c4f48cbaa50eeeccdec16f7fc7d8eecf043cee"},{"signature":"CLAIM_ENTRY_TYPEHASH()","signatureHash4":"0xba94ec0d","signatureHash32":"0xba94ec0d72a45d786a270844df755fc450610bc53ff4cea251819abd9ad6cc5c"},{"signature":"claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)","signatureHash4":"0xe43ce1f2","signatureHash32":"0xe43ce1f2e43af2371f167181f08d1fefce09d2a85a77bf88a954010324f0d9d3"},{"signature":"deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)","signatureHash4":"0x140f1e75","signatureHash32":"0x140f1e75a70b7ab9d6c9df7eb8677ee0096012f07954b9de4218834bfda7f88b"},{"signature":"eip712Domain()","signatureHash4":"0x84b0196e","signatureHash32":"0x84b0196e4b78e1918928c3b71e1f57a2bfc6d4a368fe07990ccc1367172719fb"},{"signature":"finalizeWithdraw((address,address,address,address,address,uint40,bytes32))","signatureHash4":"0xe88377b1","signatureHash32":"0xe88377b1664a59b53a39766156bcdc7cc7b93b9b5ade6b1f49b5060810c2f685"},{"signature":"getChannelId((address,address,address,address,address,uint40,bytes32))","signatureHash4":"0x5e5e0b87","signatureHash32":"0x5e5e0b87d1e4235b69b9f751179b3e49b5b5bc82bf5921fac105e61f1141fa04"},{"signature":"getClaimBatchDigest((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[])","signatureHash4":"0x488ccc3b","signatureHash32":"0x488ccc3b4524e25e5bc32eb9c33884b92114448bab1b4dd1ad8e46a8e4b1d73b"},{"signature":"getRefundDigest(bytes32,uint256,uint128)","signatureHash4":"0xe25cf189","signatureHash32":"0xe25cf18924f1b61a31cd7b93a1b1bd224252fa0c7de4664e2f8e05f02d759ee0"},{"signature":"getVoucherDigest(bytes32,uint128)","signatureHash4":"0x862bb199","signatureHash32":"0x862bb199b2a69bbe6855368153e8e837cb2ee63094b725339cfa38c6324b04a1"},{"signature":"initiateWithdraw((address,address,address,address,address,uint40,bytes32),uint128)","signatureHash4":"0xcf5cf3dc","signatureHash32":"0xcf5cf3dc62963bd380b4e84b8007d15bc2b05e43df3523669eaba23eecd587ff"},{"signature":"MAX_WITHDRAW_DELAY()","signatureHash4":"0x1fc3277d","signatureHash32":"0x1fc3277d0246ea78cde68916dfa42eb44517a30f7bda603d3e75bdbb807e819b"},{"signature":"MIN_WITHDRAW_DELAY()","signatureHash4":"0xae159439","signatureHash32":"0xae1594397de8f39c9b6aa73f024e1cb9857e93bf69456b86c2ecfbadd2fb3c1a"},{"signature":"multicall(bytes[])","signatureHash4":"0xac9650d8","signatureHash32":"0xac9650d882acfa253cba1ed543b9ff47351da99c3bd00a89625e5cdb2099009c"},{"signature":"pendingWithdrawals(bytes32)","signatureHash4":"0xb7f06ebe","signatureHash32":"0xb7f06ebe85249bb62305b758ba79fe7aa0596267c8012435d0b4751a1a6de7a7"},{"signature":"receivers(address,address)","signatureHash4":"0x21ff6389","signatureHash32":"0x21ff638983081ca41f985e78a9ebc97c256883ae986ab1c1ed4af9b53a01367a"},{"signature":"refund((address,address,address,address,address,uint40,bytes32),uint128)","signatureHash4":"0xdce4bfae","signatureHash32":"0xdce4bfaec4cfc54d98fa5e08f590cee516fd64652eaaa00af02738192514e006"},{"signature":"refundNonce(bytes32)","signatureHash4":"0xf0dc792e","signatureHash32":"0xf0dc792e9c92b937cd57b7eb6d6a4b37c8223b771f29b27afe63c2846f71bad0"},{"signature":"REFUND_TYPEHASH()","signatureHash4":"0x1e69ef40","signatureHash32":"0x1e69ef40b662785f8fa7a4838baa811f54f9b42f016061d68f669d6888fcdf6f"},{"signature":"refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)","signatureHash4":"0xb77433e9","signatureHash32":"0xb77433e9989af999b716f45f8dece28a402a180159b189aceb98150bbede3d86"},{"signature":"settle(address,address)","signatureHash4":"0x9db32a8f","signatureHash32":"0x9db32a8f8472697680dbe69b022a866382841e3043a4bab2cb7213d17937c3bd"},{"signature":"VOUCHER_TYPEHASH()","signatureHash4":"0x94739e87","signatureHash32":"0x94739e87b8b828261709b636eec3e935e4ba6498b65091c944cac856963f2412"}],"event":[{"signature":"ChannelClosed(bytes32,(address,address,address,address,address,uint40,bytes32))","signatureHash4":"0x8d5942f1","signatureHash32":"0x8d5942f197f362dfd44dfdc1b0b7a9721c9151b67f55817c83349271d3c08d37"},{"signature":"ChannelCreated(bytes32,(address,address,address,address,address,uint40,bytes32))","signatureHash4":"0x69d8248d","signatureHash32":"0x69d8248d5566bdb2ebc4d218970710d8378a2ff9b709a999e052b71970f808fa"},{"signature":"Claimed(bytes32,address,uint128,uint128)","signatureHash4":"0x36bd546b","signatureHash32":"0x36bd546bb573e8921fdbfd934bbed62d872796b01792cd240cce27f79dd3eddd"},{"signature":"Deposited(bytes32,address,uint128,uint128)","signatureHash4":"0x6c2a0935","signatureHash32":"0x6c2a09353b5e75e70d0b9778b80a413809bb235d46c211811c474b3346791d89"},{"signature":"EIP712DomainChanged()","signatureHash4":"0x0a6387c9","signatureHash32":"0x0a6387c9ea3628b88a633bb4f3b151770f70085117a15f9bf3787cda53f13d31"},{"signature":"Refunded(bytes32,address,uint128)","signatureHash4":"0xa84286cf","signatureHash32":"0xa84286cf8ebc7903a663c77c8d99aa92b600d4c2fcca872a5d4a663db4eb394b"},{"signature":"Settled(address,address,address,uint128)","signatureHash4":"0x7337b438","signatureHash32":"0x7337b4386b690fdb8ba66905b92b9d45d33bc6626ee2620c905fb150ec0cc47d"},{"signature":"WithdrawFinalized(bytes32,address,uint128)","signatureHash4":"0x546ce1e2","signatureHash32":"0x546ce1e2242cd930c196bd08b894443562d709b4fffe4f028a75a6d233efc6e3"},{"signature":"WithdrawInitiated(bytes32,uint128,uint40)","signatureHash4":"0xe4280d0d","signatureHash32":"0xe4280d0d903c7f258f62b07c62f262377cbaa23f7791d78126e6446e0f0e3c23"}],"error":[{"signature":"AddressEmptyCode(address)","signatureHash4":"0x9996b315","signatureHash32":"0x9996b315c842ff135b8fc4a08ad5df1c344efbc03d2687aecc0678050d2aac89"},{"signature":"ClaimExceedsBalance()","signatureHash4":"0x7d8242b6","signatureHash32":"0x7d8242b644ed15fd2ba487e6c0b4cd8132eeaec22a2a10eac4c365a7f6132dce"},{"signature":"ClaimExceedsCeiling()","signatureHash4":"0xf1789775","signatureHash32":"0xf1789775d20e6d801e1dcc76eab01f1cb47cdae0c7ca47c1339d503e1850128f"},{"signature":"DepositCollectionFailed()","signatureHash4":"0xeb43592c","signatureHash32":"0xeb43592c973aefddc2c72f3fcc1cd6babb3269a7dda5fedb2a98f5e1934613f1"},{"signature":"DepositOverflow()","signatureHash4":"0x1132981b","signatureHash32":"0x1132981b50988e5bf5914c2cdbec86f17b96e379b9fe376f3978c42411aafcd6"},{"signature":"ECDSAInvalidSignature()","signatureHash4":"0xf645eedf","signatureHash32":"0xf645eedf0193584640b6b90cb9477e4c95b98636c148a891d4c0a146dc46e75a"},{"signature":"ECDSAInvalidSignatureLength(uint256)","signatureHash4":"0xfce698f7","signatureHash32":"0xfce698f7e8e5342cd615f641317bc45fe7e1e4a8b0a14dd1383ff8dc9c41917f"},{"signature":"ECDSAInvalidSignatureS(bytes32)","signatureHash4":"0xd78bce0c","signatureHash32":"0xd78bce0cccb935155ed6428d1c13e50b7f3550fd2b66b9fe266006fea4a5e1eb"},{"signature":"EmptyBatch()","signatureHash4":"0xc2e5347d","signatureHash32":"0xc2e5347df6cf8d1bf68f8a9651642312bd381b900d857d97cd665976180d6ae0"},{"signature":"FailedCall()","signatureHash4":"0xd6bda275","signatureHash32":"0xd6bda27508c0fb6d8a39b4b122878dab26f731a7d4e4abe711dd3731899052a4"},{"signature":"InvalidChannel()","signatureHash4":"0xea3a9a39","signatureHash32":"0xea3a9a39ade8da556b2a0eb84fb492a877b9b1359a1d967769c796bffb21eff6"},{"signature":"InvalidCollector()","signatureHash4":"0x18b1afd4","signatureHash32":"0x18b1afd44def9c8e2335a0b175a19408f7f5ef09683ee05e2f45e8042eb0d72d"},{"signature":"InvalidRefundNonce()","signatureHash4":"0x164f1afe","signatureHash32":"0x164f1afe58c9ccb5990cf2f541ddec23cbaf091017a27897e515431a0b4fe8bf"},{"signature":"InvalidShortString()","signatureHash4":"0xb3512b0c","signatureHash32":"0xb3512b0c6163e5f0bafab72bb631b9d58cd7a731b082f910338aa21c83d5c274"},{"signature":"InvalidSignature()","signatureHash4":"0x8baa579f","signatureHash32":"0x8baa579fce362245063d36f11747a89dd489c54795634fc673cc0e0db51fedc5"},{"signature":"NotAuthorizedToClaim()","signatureHash4":"0xdefb7069","signatureHash32":"0xdefb7069aa3adba68f883d732ad2b24c087173487331fccb11d60d1fe7e970a0"},{"signature":"NotAuthorizedToFinalizeWithdraw()","signatureHash4":"0x15f969d5","signatureHash32":"0x15f969d5c9e170be2291c083d6b150e6fcebf00ef2d8be6550ae6c3dc50dabdb"},{"signature":"NotAuthorizedToRefund()","signatureHash4":"0x7864f008","signatureHash32":"0x7864f008ee834500b7f2733a6014e3f8eea31d50246cafde51f13a9311acfd40"},{"signature":"NothingToWithdraw()","signatureHash4":"0xd0d04f60","signatureHash32":"0xd0d04f60bf4f7629141a1f00f5d2908fa0f3e15bf4cbf8bb8edc6fcbdf2509fa"},{"signature":"NotReceiverAuthorizer()","signatureHash4":"0xf5e2237d","signatureHash32":"0xf5e2237d61f9c9a130c1b6459a9c805b19d61228df4da0c80ec97c91b5bc3fb8"},{"signature":"ReentrancyGuardReentrantCall()","signatureHash4":"0x3ee5aeb5","signatureHash32":"0x3ee5aeb571de7fc460830b4d0017439a1ca56fb0bc39062227ade4fe4a24c1ca"},{"signature":"SafeERC20FailedOperation(address)","signatureHash4":"0x5274afe7","signatureHash32":"0x5274afe73c98b4749fc91ffae6b7b574e7842cb2144a159e9377a5f20b32edf9"},{"signature":"StringTooLong(string)","signatureHash4":"0x305a27a9","signatureHash32":"0x305a27a93f8e33b7392df0a0f91d6fc63847395853c45991eec52dbf24d72381"},{"signature":"WithdrawalAlreadyPending()","signatureHash4":"0xa2aed0f0","signatureHash32":"0xa2aed0f0fb41b1f15d5794b35460e07faf6ebe60d83540c80e89b1f06eca9396"},{"signature":"WithdrawalNotPending()","signatureHash4":"0x3a0a1ca6","signatureHash32":"0x3a0a1ca689ec71617ac2a09f285d91cf55fffc1e4a31ad8aeebcc94abb3a85b3"},{"signature":"WithdrawAmountExceedsAvailable()","signatureHash4":"0x6d3d5764","signatureHash32":"0x6d3d5764eb95e3a6e5f7fa0be3c1d9073f1cf249735f075c057bad7a3474c94a"},{"signature":"WithdrawDelayNotElapsed()","signatureHash4":"0xf3965827","signatureHash32":"0xf3965827abb4b3501eba40fbc36bf95518923256f8e4150f82d6abaf898dfecb"},{"signature":"WithdrawDelayOutOfRange()","signatureHash4":"0x4574fab6","signatureHash32":"0x4574fab68d66a7482499780fe2cf118b6bf35c8ed02b94811df48a01231e8390"},{"signature":"ZeroDeposit()","signatureHash4":"0x56316e87","signatureHash32":"0x56316e877e9063fd05b03c347d61a4639470c3199f0bdddd28efee0a5f8b6b02"},{"signature":"ZeroRefund()","signatureHash4":"0xd758525c","signatureHash32":"0xd758525c34181c802038c9e1709640cd49191c6bc9afb13a57391cfe9abab6e8"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"8453","address":"0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003"}