{"matchId":"55821056","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-10-09T12:19:36Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"425:3178:5:-:0;;;1240:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1601:113:1;;;;;;;;;;;;;-1:-1:-1;;;1601:113:1;;;;;;;;;;;;;;;;-1:-1:-1;;;1601:113:1;;;1675:5;1667;:13;;;;;;:::i;:::-;-1:-1:-1;1690:7:1;:17;1700:7;1690;:17;:::i;:::-;;1601:113;;1352:13:5::1;1369:1;1352:18;1348:44;;1379:13;;-1:-1:-1::0;;;1379:13:5::1;;;;;;;;;;;1348:44;-1:-1:-1::0;;;;;1419:22:5;::::1;1431:10;1419:22;;::::0;:51:::1;;-1:-1:-1::0;;;;;;1445:20:5;::::1;;:25:::0;1419:51:::1;:84;;;-1:-1:-1::0;;;;;;1474:24:5;::::1;;:29:::0;1419:84:::1;:128;;;;1535:12;-1:-1:-1::0;;;;;1523:24:5::1;:8;-1:-1:-1::0;;;;;1523:24:5::1;;1419:128;:152;;;-1:-1:-1::0;;;;;;1551:20:5;::::1;552:42;1551:20;1419:152;1402:215;;;1589:28;;-1:-1:-1::0;;;1589:28:5::1;;;;;;;;;;;1402:215;-1:-1:-1::0;;;;;1627:18:5;;::::1;;::::0;1655:26;::::1;;::::0;-1:-1:-1;;;;;1691:28:5;::::1;;::::0;1729:33:::1;1735:10;496:19;1729:5;:33::i;:::-;1240:529:::0;;;425:3178;;7458:208:1;-1:-1:-1;;;;;7528:21:1;;7524:91;;7572:32;;-1:-1:-1;;;7572:32:1;;7601:1;7572:32;;;3446:51:6;3419:18;;7572:32:1;;;;;;;;7524:91;7624:35;7640:1;7644:7;7653:5;7624:7;:35::i;:::-;7458:208;;:::o;1775:403:5:-;-1:-1:-1;;;;;1866:18:5;;;;;;:40;;-1:-1:-1;1889:17:5;1897:4;1903:2;1889:7;:17::i;:::-;1888:18;1866:40;1862:269;;;1922:14;1939:12;1948:3;1939:6;:12;:::i;:::-;1922:29;-1:-1:-1;1969:11:5;;1965:156;;2015:6;2000:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;2039:33:5;;-1:-1:-1;2053:4:5;552:42;2065:6;2039:13;:33::i;:::-;2090:16;2100:6;2090:16;;:::i;:::-;;;1965:156;1908:223;1862:269;2140:31;2154:4;2160:2;2164:6;2140:13;:31::i;:::-;1775:403;;;:::o;2746:855::-;2811:4;2845:7;;-1:-1:-1;;;;;2831:21:5;:10;-1:-1:-1;;;;;2831:21:5;;:44;;;;2864:11;;-1:-1:-1;;;;;2856:19:5;:4;-1:-1:-1;;;;;2856:19:5;;2831:44;:65;;;;2885:11;;-1:-1:-1;;;;;2879:17:5;:2;-1:-1:-1;;;;;2879:17:5;;2831:65;2827:82;;;-1:-1:-1;2905:4:5;2898:11;;2827:82;3088:12;;3042:60;;-1:-1:-1;;;;;4287:31:6;;;3042:60:5;;;4269:50:6;3021:18:5;;4242::6;;3042:60:5;;;-1:-1:-1;;3042:60:5;;;;;;;;;;;;;;;-1:-1:-1;;;;;3042:60:5;-1:-1:-1;;;3042:60:5;;;3131:7;;3366:12;;3042:60;;-1:-1:-1;3131:7:5;-1:-1:-1;;;;3042:60:5;;-1:-1:-1;;3131:7:5;3328:10;3317:69;3472:1;3466:8;3416:16;3434:2;3413:24;3405:33;;;;-1:-1:-1;3466:8:5;-1:-1:-1;3405:33:5;3493:21;;3509:5;3502:12;;;;;;;;3493:21;3531:16;;;;;:63;;-1:-1:-1;3582:10:5;3551:43;;3531:63;3524:70;;;;;;2746:855;;;;;:::o;6008:1107:1:-;-1:-1:-1;;;;;6097:18:1;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:1;;-1:-1:-1;6093:540:1;;-1:-1:-1;;;;;6307:15:1;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;-1:-1:-1;;;6386:50:1;;-1:-1:-1;;;;;4550:32:6;;6386:50:1;;;4532:51:6;4599:18;;;4592:34;;;4642:18;;;4635:34;;;4505:18;;6386:50:1;4330:345:6;6336:115:1;-1:-1:-1;;;;;6571:15:1;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;-1:-1:-1;;;;;6647:16:1;;6643:425;;6810:12;:21;;;;;;;6643:425;;;-1:-1:-1;;;;;7021:13:1;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;-1:-1:-1;;;;;7083:25:1;7092:4;-1:-1:-1;;;;;7083:25:1;;7102:5;7083:25;;;;4826::6;;4814:2;4799:18;;4680:177;7083:25:1;;;;;;;;6008:1107;;;:::o;14:177:6:-;93:13;;-1:-1:-1;;;;;135:31:6;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:458::-;283:6;291;299;352:2;340:9;331:7;327:23;323:32;320:52;;;368:1;365;358:12;320:52;391:40;421:9;391:40;:::i;:::-;381:50;;450:49;495:2;484:9;480:18;450:49;:::i;:::-;542:2;527:18;;521:25;440:59;;-1:-1:-1;;;;;;575:30:6;;565:41;;555:69;;620:1;617;610:12;555:69;643:5;633:15;;;196:458;;;;;:::o;659:127::-;720:10;715:3;711:20;708:1;701:31;751:4;748:1;741:15;775:4;772:1;765:15;791:380;870:1;866:12;;;;913;;;934:61;;988:4;980:6;976:17;966:27;;934:61;1041:2;1033:6;1030:14;1010:18;1007:38;1004:161;;1087:10;1082:3;1078:20;1075:1;1068:31;1122:4;1119:1;1112:15;1150:4;1147:1;1140:15;1004:161;;791:380;;;:::o;1302:518::-;1404:2;1399:3;1396:11;1393:421;;;1440:5;1437:1;1430:16;1484:4;1481:1;1471:18;1554:2;1542:10;1538:19;1535:1;1531:27;1525:4;1521:38;1590:4;1578:10;1575:20;1572:47;;;-1:-1:-1;1613:4:6;1572:47;1668:2;1663:3;1659:12;1656:1;1652:20;1646:4;1642:31;1632:41;;1723:81;1741:2;1734:5;1731:13;1723:81;;;1800:1;1786:16;;1767:1;1756:13;1723:81;;;1727:3;;1302:518;;;:::o;1996:1299::-;2116:10;;-1:-1:-1;;;;;2138:30:6;;2135:56;;;2171:18;;:::i;:::-;2200:97;2290:6;2250:38;2282:4;2276:11;2250:38;:::i;:::-;2244:4;2200:97;:::i;:::-;2346:4;2377:2;2366:14;;2394:1;2389:649;;;;3082:1;3099:6;3096:89;;;-1:-1:-1;3151:19:6;;;3145:26;3096:89;-1:-1:-1;;1953:1:6;1949:11;;;1945:24;1941:29;1931:40;1977:1;1973:11;;;1928:57;3198:81;;2359:930;;2389:649;1249:1;1242:14;;;1286:4;1273:18;;-1:-1:-1;;2425:20:6;;;2543:222;2557:7;2554:1;2551:14;2543:222;;;2639:19;;;2633:26;2618:42;;2746:4;2731:20;;;;2699:1;2687:14;;;;2573:12;2543:222;;;2547:3;2793:6;2784:7;2781:19;2778:201;;;2854:19;;;2848:26;-1:-1:-1;;2937:1:6;2933:14;;;2949:3;2929:24;2925:37;2921:42;2906:58;2891:74;;2778:201;-1:-1:-1;;;;3025:1:6;3009:14;;;3005:22;2992:36;;-1:-1:-1;1996:1299:6:o;3508:127::-;3569:10;3564:3;3560:20;3557:1;3550:31;3600:4;3597:1;3590:15;3624:4;3621:1;3614:15;3640:217;3680:1;3706;3696:132;;3750:10;3745:3;3741:20;3738:1;3731:31;3785:4;3782:1;3775:15;3813:4;3810:1;3803:15;3696:132;-1:-1:-1;3842:9:6;;3640:217::o;3862:125::-;3927:9;;;3948:10;;;3945:36;;;3961:18;;:::i;3992:128::-;4059:9;;;4080:11;;;4077:37;;;4094:18;;:::i;4680:177::-;425:3178:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c634300081a000a","offset":4264}},"transformations":[{"type":"insert","offset":4276,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000ff03410d0fe5fa8f7f59f743de35e333d9857120000000000000000000000000000000000004444c5dc75cb358380d2e3de08a900000000000000000000000000000000000000000000000000000000000000443"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"425:3178:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;521:73;;552:42;521:73;;;;;-1:-1:-1;;;;;178:32:6;;;160:51;;148:2;133:18;521:73:5;;;;;;;;1779:89:1;;;:::i;:::-;;;;;;;:::i;3998:186::-;;;;;;:::i;:::-;;:::i;:::-;;;1293:14:6;;1286:22;1268:41;;1256:2;1241:18;3998:186:1;1128:187:6;2849:97:1;2927:12;;2849:97;;;1466:25:6;;;1454:2;1439:18;2849:97:1;1320:177:6;4776:244:1;;;;;;:::i;:::-;;:::i;455:60:5:-;;496:19;455:60;;2707:82:1;;;2780:2;2023:36:6;;2011:2;1996:18;2707:82:1;1881:184:6;3004:116:1;;;;;;:::i;:::-;-1:-1:-1;;;;;3095:18:1;3069:7;3095:18;;;;;;;;;;;;3004:116;680:36:5;;;;;;;;2435:18:6;2423:31;;;2405:50;;2393:2;2378:18;680:36:5;2261:200:6;1981:93:1;;;:::i;3315:178::-;;;;;;:::i;:::-;;:::i;600:32:5:-;;;;;810:26;;;;;;638:36;;;;;3551:140:1;;;;;;:::i;:::-;-1:-1:-1;;;;;3657:18:1;;;3631:7;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3551:140;1779:89;1824:13;1856:5;1849:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89;:::o;3998:186::-;4071:4;735:10:4;4125:31:1;735:10:4;4141:7:1;4150:5;4125:8;:31::i;:::-;4173:4;4166:11;;;3998:186;;;;;:::o;4776:244::-;4863:4;735:10:4;4919:37:1;4935:4;735:10:4;4950:5:1;4919:15;:37::i;:::-;4966:26;4976:4;4982:2;4986:5;4966:9;:26::i;:::-;-1:-1:-1;5009:4:1;;4776:244;-1:-1:-1;;;;4776:244:1:o;1981:93::-;2028:13;2060:7;2053:14;;;;;:::i;3315:178::-;3384:4;735:10:4;3438:27:1;735:10:4;3455:2:1;3459:5;3438:9;:27::i;8726:128::-;8810:37;8819:5;8826:7;8835:5;8842:4;8810:8;:37::i;:::-;8726:128;;;:::o;10415:476::-;-1:-1:-1;;;;;3657:18:1;;;10514:24;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;10580:36:1;;10576:309;;;10655:5;10636:16;:24;10632:130;;;10687:60;;-1:-1:-1;;;10687:60:1;;-1:-1:-1;;;;;3336:32:6;;10687:60:1;;;3318:51:6;3385:18;;;3378:34;;;3428:18;;;3421:34;;;3291:18;;10687:60:1;;;;;;;;10632:130;10803:57;10812:5;10819:7;10847:5;10828:16;:24;10854:5;10803:8;:57::i;:::-;10504:387;10415:476;;;:::o;5393:300::-;-1:-1:-1;;;;;5476:18:1;;5472:86;;5517:30;;-1:-1:-1;;;5517:30:1;;5544:1;5517:30;;;160:51:6;133:18;;5517:30:1;14:203:6;5472:86:1;-1:-1:-1;;;;;5571:16:1;;5567:86;;5610:32;;-1:-1:-1;;;5610:32:1;;5639:1;5610:32;;;160:51:6;133:18;;5610:32:1;14:203:6;5567:86:1;5662:24;5670:4;5676:2;5680:5;5662:7;:24::i;9701:432::-;-1:-1:-1;;;;;9813:19:1;;9809:89;;9855:32;;-1:-1:-1;;;9855:32:1;;9884:1;9855:32;;;160:51:6;133:18;;9855:32:1;14:203:6;9809:89:1;-1:-1:-1;;;;;9911:21:1;;9907:90;;9955:31;;-1:-1:-1;;;9955:31:1;;9983:1;9955:31;;;160:51:6;133:18;;9955:31:1;14:203:6;9907:90:1;-1:-1:-1;;;;;10006:18:1;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;10051:76;;;;10101:7;-1:-1:-1;;;;;10085:31:1;10094:5;-1:-1:-1;;;;;10085:31:1;;10110:5;10085:31;;;;1466:25:6;;1454:2;1439:18;;1320:177;10085:31:1;;;;;;;;9701:432;;;;:::o;1775:403:5:-;-1:-1:-1;;;;;1866:18:5;;;;;;:40;;;1889:17;1897:4;1903:2;1889:7;:17::i;:::-;1888:18;1866:40;1862:269;;;1922:14;1939:12;1948:3;1939:6;:12;:::i;:::-;1922:29;-1:-1:-1;1969:11:5;;1965:156;;2015:6;2000:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;2039:33:5;;-1:-1:-1;2053:4:5;552:42;2065:6;2039:13;:33::i;:::-;2090:16;2100:6;2090:16;;:::i;:::-;;;1965:156;1908:223;1862:269;2140:31;2154:4;2160:2;2164:6;2140:13;:31::i;2746:855::-;2811:4;2831:10;-1:-1:-1;;;;;2845:7:5;2831:21;;;:44;;;2864:11;-1:-1:-1;;;;;2856:19:5;:4;-1:-1:-1;;;;;2856:19:5;;2831:44;:65;;;;2885:11;-1:-1:-1;;;;;2879:17:5;:2;-1:-1:-1;;;;;2879:17:5;;2831:65;2827:82;;;-1:-1:-1;2905:4:5;2898:11;;2827:82;3042:60;;2435:18:6;3088:12:5;2423:31:6;3042:60:5;;;2405:50:6;3021:18:5;;2378::6;;3042:60:5;;;-1:-1:-1;;3042:60:5;;;;;;;;;;;;;;;-1:-1:-1;;;;;3042:60:5;-1:-1:-1;;;3042:60:5;;;3366:12;;3042:60;;-1:-1:-1;3131:7:5;;-1:-1:-1;;;;3042:60:5;;-1:-1:-1;;3131:7:5;3328:10;3317:69;3472:1;3466:8;3416:16;3434:2;3413:24;3405:33;;;;-1:-1:-1;3466:8:5;-1:-1:-1;3405:33:5;3493:21;;3509:5;3502:12;;;;;;;;3493:21;3531:16;;;;;:63;;-1:-1:-1;3582:10:5;3551:43;;3531:63;3524:70;2746:855;-1:-1:-1;;;;;;;2746:855:5:o;6008:1107:1:-;-1:-1:-1;;;;;6097:18:1;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:1;;-1:-1:-1;6093:540:1;;-1:-1:-1;;;;;6307:15:1;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;-1:-1:-1;;;6386:50:1;;-1:-1:-1;;;;;3336:32:6;;6386:50:1;;;3318:51:6;3385:18;;;3378:34;;;3428:18;;;3421:34;;;3291:18;;6386:50:1;3116:345:6;6336:115:1;-1:-1:-1;;;;;6571:15:1;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;-1:-1:-1;;;;;6647:16:1;;6643:425;;6810:12;:21;;;;;;;6643:425;;;-1:-1:-1;;;;;7021:13:1;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;-1:-1:-1;;;;;7083:25:1;7092:4;-1:-1:-1;;;;;7083:25:1;;7102:5;7083:25;;;;1466::6;;1454:2;1439:18;;1320:177;7083:25:1;;;;;;;;6008:1107;;;:::o;222:418:6:-;371:2;360:9;353:21;334:4;403:6;397:13;446:6;441:2;430:9;426:18;419:34;505:6;500:2;492:6;488:15;483:2;472:9;468:18;462:50;561:1;556:2;547:6;536:9;532:22;528:31;521:42;631:2;624;620:7;615:2;607:6;603:15;599:29;588:9;584:45;580:54;572:62;;;222:418;;;;:::o;645:173::-;713:20;;-1:-1:-1;;;;;762:31:6;;752:42;;742:70;;808:1;805;798:12;742:70;645:173;;;:::o;823:300::-;891:6;899;952:2;940:9;931:7;927:23;923:32;920:52;;;968:1;965;958:12;920:52;991:29;1010:9;991:29;:::i;:::-;981:39;1089:2;1074:18;;;;1061:32;;-1:-1:-1;;;823:300:6:o;1502:374::-;1579:6;1587;1595;1648:2;1636:9;1627:7;1623:23;1619:32;1616:52;;;1664:1;1661;1654:12;1616:52;1687:29;1706:9;1687:29;:::i;:::-;1677:39;;1735:38;1769:2;1758:9;1754:18;1735:38;:::i;:::-;1502:374;;1725:48;;-1:-1:-1;;;1842:2:6;1827:18;;;;1814:32;;1502:374::o;2070:186::-;2129:6;2182:2;2170:9;2161:7;2157:23;2153:32;2150:52;;;2198:1;2195;2188:12;2150:52;2221:29;2240:9;2221:29;:::i;:::-;2211:39;2070:186;-1:-1:-1;;;2070:186:6:o;2466:260::-;2534:6;2542;2595:2;2583:9;2574:7;2570:23;2566:32;2563:52;;;2611:1;2608;2601:12;2563:52;2634:29;2653:9;2634:29;:::i;:::-;2624:39;;2682:38;2716:2;2705:9;2701:18;2682:38;:::i;:::-;2672:48;;2466:260;;;;;:::o;2731:380::-;2810:1;2806:12;;;;2853;;;2874:61;;2928:4;2920:6;2916:17;2906:27;;2874:61;2981:2;2973:6;2970:14;2950:18;2947:38;2944:161;;3027:10;3022:3;3018:20;3015:1;3008:31;3062:4;3059:1;3052:15;3090:4;3087:1;3080:15;2944:161;;2731:380;;;:::o;3466:127::-;3527:10;3522:3;3518:20;3515:1;3508:31;3558:4;3555:1;3548:15;3582:4;3579:1;3572:15;3598:217;3638:1;3664;3654:132;;3708:10;3703:3;3699:20;3696:1;3689:31;3743:4;3740:1;3733:15;3771:4;3768:1;3761:15;3654:132;-1:-1:-1;3800:9:6;;3598:217::o;3820:125::-;3885:9;;;3906:10;;;3903:36;;;3919:18;;:::i;3950:128::-;4017:9;;;4038:11;;;4035:37;;;4052:18;;:::i","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c634300081a000a","offset":2567}},"immutableReferences":{"808":[{"start":545,"length":32},{"start":1495,"length":32},{"start":1767,"length":32}],"810":[{"start":593,"length":32},{"start":1536,"length":32},{"start":1596,"length":32}],"812":[{"start":454,"length":32},{"start":1675,"length":32}]},"transformations":[{"id":"812","type":"replace","offset":454,"reason":"immutable"},{"id":"808","type":"replace","offset":545,"reason":"immutable"},{"id":"810","type":"replace","offset":593,"reason":"immutable"},{"id":"808","type":"replace","offset":1495,"reason":"immutable"},{"id":"810","type":"replace","offset":1536,"reason":"immutable"},{"id":"810","type":"replace","offset":1596,"reason":"immutable"},{"id":"812","type":"replace","offset":1675,"reason":"immutable"},{"id":"808","type":"replace","offset":1767,"reason":"immutable"}],"transformationValues":{"immutables":{"808":"0x000000000000000000000000ff03410d0fe5fa8f7f59f743de35e333d9857120","810":"0x000000000000000000000000000000000004444c5dc75cb358380d2e3de08a90","812":"0x0000000000000000000000000000000000000000000000000000000000000443"}}},"deployment":{"transactionHash":"0xcdbb09627e10374f92eb9ce9c82dd6805692e7edc5d949d5d816585f25008ebc","blockNumber":"26150507","transactionIndex":"14","deployer":"0xcECc29B037f5064fCdF45a5C318F132ef76aA551"},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},"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"},"src/Swarm.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\ninterface ILaunchFactory {\n    function distributorOf(uint64 launchNumber) external view returns (address);\n}\n\n/// @notice Fixed-supply mainnet token. Ordinary transfers send floor(amount / 100) to DEAD.\n/// @dev Launch distribution and PoolManager settlement are exempt to preserve exact amounts.\ncontract Swarm is ERC20 {\n    uint256 public constant INITIAL_SUPPLY = 1_000_000_000 ether;\n    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;\n    address public immutable factory;\n    address public immutable poolManager;\n    uint64 public immutable launchNumber;\n    /// @notice Accumulated automatic 1% charges; excludes voluntary transfers to DEAD.\n    uint256 public totalBurned;\n    /// @dev Gas forwarded to the factory's distributor lookup. A plain mapping getter costs about\n    /// 3,000 gas; this budget also covers a proxy hop and a few dozen cold storage reads, so a\n    /// legitimate registry cannot silently fall into the burn path by exceeding it.\n    uint256 private constant LOOKUP_GAS = 100_000;\n\n    error MainnetOnly();\n    error InvalidLaunchConfiguration();\n\n    constructor(address factory_, address poolManager_, uint64 launchNumber_) ERC20(\"swarm\", \"SWARM\") {\n        if (block.chainid != 1) revert MainnetOnly();\n        if (\n            factory_ != msg.sender || factory_.code.length == 0 || poolManager_.code.length == 0\n                || factory_ == poolManager_ || poolManager_ == DEAD\n        ) revert InvalidLaunchConfiguration();\n        factory = factory_;\n        poolManager = poolManager_;\n        launchNumber = launchNumber_;\n        _mint(msg.sender, INITIAL_SUPPLY);\n    }\n\n    function _update(address from, address to, uint256 amount) internal override {\n        if (from != address(0) && !_exempt(from, to)) {\n            uint256 burned = amount / 100;\n            if (burned != 0) {\n                totalBurned += burned;\n                super._update(from, DEAD, burned);\n                amount -= burned;\n            }\n        }\n        super._update(from, to, amount);\n    }\n\n    /// @dev The PoolManager exemption is unconditional in both directions because v4 settlement\n    /// credits exactly the balance the manager receives and pays out exactly what it is asked to.\n    /// It therefore also covers transfers that merely pass through the manager's ledger\n    /// (sync/settle/take or ERC-6909 claims) without touching this token's pool. That is a\n    /// documented limit of the burn, not an oversight: a burn on either leg would leave a sell\n    /// unsettled, and the brief allows no hook to move the charge onto the swap itself.\n    function _exempt(address from, address to) private view returns (bool) {\n        if (msg.sender == factory || from == poolManager || to == poolManager) return true;\n        // Static, gas-bounded lookup: a missing or broken registry must not freeze holder transfers.\n        bytes memory input = abi.encodeCall(ILaunchFactory.distributorOf, (launchNumber));\n        address registry = factory;\n        bool ok;\n        uint256 distributor;\n        // Copy at most one word, even if the factory returns excessive data.\n        assembly (\"memory-safe\") {\n            ok := staticcall(LOOKUP_GAS, registry, add(input, 32), mload(input), 0, 32)\n            ok := and(ok, eq(returndatasize(), 32))\n            distributor := mload(0)\n        }\n        if (!ok) return false;\n        return distributor != 0 && distributor == uint256(uint160(msg.sender));\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.26+commit.8a97fa7a","compilerSettings":{"metadata":{"bytecodeHash":"none"},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":[":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",":solmate/=lib/solmate/",":v4-core/=lib/v4-core/"]},"name":"Swarm","fullyQualifiedName":"src/Swarm.sol:Swarm"},"abi":[{"type":"constructor","inputs":[{"name":"factory_","type":"address","internalType":"address"},{"name":"poolManager_","type":"address","internalType":"address"},{"name":"launchNumber_","type":"uint64","internalType":"uint64"}],"stateMutability":"nonpayable"},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"InvalidLaunchConfiguration","type":"error","inputs":[]},{"name":"MainnetOnly","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DEAD","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"INITIAL_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"factory","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"launchNumber","type":"function","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"poolManager","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalBurned","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.26+commit.8a97fa7a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"factory_","type":"address"},{"internalType":"address","name":"poolManager_","type":"address"},{"internalType":"uint64","name":"launchNumber_","type":"uint64"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"InvalidLaunchConfiguration","type":"error"},{"inputs":[],"name":"MainnetOnly","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEAD","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INITIAL_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchNumber","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBurned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"details":"Launch distribution and PoolManager settlement are exempt to preserve exact amounts.","errors":{"ERC20InsufficientAllowance(address,uint256,uint256)":[{"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers.","params":{"allowance":"Amount of tokens a `spender` is allowed to operate with.","needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner."}}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers.","params":{"balance":"Current balance for the interacting account.","needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred."}}],"ERC20InvalidApprover(address)":[{"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals.","params":{"approver":"Address initiating an approval operation."}}],"ERC20InvalidReceiver(address)":[{"details":"Indicates a failure with the token `receiver`. Used in transfers.","params":{"receiver":"Address to which tokens are being transferred."}}],"ERC20InvalidSender(address)":[{"details":"Indicates a failure with the token `sender`. Used in transfers.","params":{"sender":"Address whose tokens are being transferred."}}],"ERC20InvalidSpender(address)":[{"details":"Indicates a failure with the `spender` to be approved. Used in approvals.","params":{"spender":"Address that may be allowed to operate on tokens without being their owner."}}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"kind":"dev","methods":{"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"name()":{"details":"Returns the name of the token."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."}},"stateVariables":{"LOOKUP_GAS":{"details":"Gas forwarded to the factory's distributor lookup. A plain mapping getter costs about 3,000 gas; this budget also covers a proxy hop and a few dozen cold storage reads, so a legitimate registry cannot silently fall into the burn path by exceeding it."}},"version":1},"userdoc":{"kind":"user","methods":{"totalBurned()":{"notice":"Accumulated automatic 1% charges; excludes voluntary transfers to DEAD."}},"notice":"Fixed-supply mainnet token. Ordinary transfers send floor(amount / 100) to DEAD.","version":1}},"settings":{"compilationTarget":{"src/Swarm.sol":"Swarm"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",":solmate/=lib/solmate/",":v4-core/=lib/v4-core/"]},"sources":{"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol":{"keccak256":"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b","license":"MIT","urls":["bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b","dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz"]},"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol":{"keccak256":"0x6ef9389a2c07bc40d8a7ba48914724ab2c108fac391ce12314f01321813e6368","license":"MIT","urls":["bzz-raw://b7a5cb39b1e6df68f4dd9a5e76e853d745a74ffb3dfd7df4ae4d2ace6992a171","dweb:/ipfs/QmPbzKR19rdM8X3PLQjsmHRepUKhvoZnedSR63XyGtXZib"]},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"keccak256":"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7","license":"MIT","urls":["bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db","dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"]},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330","license":"MIT","urls":["bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf","dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r"]},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"src/Swarm.sol":{"keccak256":"0xb50b2ab2d2fe12475dc50d25dbee00a3145fb1780b6f0dc6f546d60049dac54f","license":"MIT","urls":["bzz-raw://b0faf7490feb0a4b2013ebe5ad83e019489da3d309153a67e5f63a6b824eadf4","dweb:/ipfs/QmT1rem8m54U7hy7dLmej1L2YiJivwixFxbGksZoK445uP"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":159,"label":"_balances","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":165,"label":"_allowances","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"2","type":"t_uint256","astId":167,"label":"_totalSupply","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"3","type":"t_string_storage","astId":169,"label":"_name","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"4","type":"t_string_storage","astId":171,"label":"_symbol","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"5","type":"t_uint256","astId":815,"label":"totalBurned","offset":0,"contract":"src/Swarm.sol:Swarm"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"Fixed-supply mainnet token. Ordinary transfers send floor(amount / 100) to DEAD.","methods":{"totalBurned()":{"notice":"Accumulated automatic 1% charges; excludes voluntary transfers to DEAD."}},"version":1},"devdoc":{"kind":"dev","errors":{"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"details":"Launch distribution and PoolManager settlement are exempt to preserve exact amounts.","methods":{"name()":{"details":"Returns the name of the token."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."}},"version":1,"stateVariables":{"LOOKUP_GAS":{"details":"Gas forwarded to the factory's distributor lookup. A plain mapping getter costs about 3,000 gas; this budget also covers a proxy hop and a few dozen cold storage reads, so a legitimate registry cannot silently fall into the burn path by exceeding it."}}},"sourceIds":{"src/Swarm.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"id":4},"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol":{"id":1},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":2},"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol":{"id":0},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"additionalInput":null,"stdJsonInput":{"sources":{"src/Swarm.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.26;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\ninterface ILaunchFactory {\n    function distributorOf(uint64 launchNumber) external view returns (address);\n}\n\n/// @notice Fixed-supply mainnet token. Ordinary transfers send floor(amount / 100) to DEAD.\n/// @dev Launch distribution and PoolManager settlement are exempt to preserve exact amounts.\ncontract Swarm is ERC20 {\n    uint256 public constant INITIAL_SUPPLY = 1_000_000_000 ether;\n    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;\n    address public immutable factory;\n    address public immutable poolManager;\n    uint64 public immutable launchNumber;\n    /// @notice Accumulated automatic 1% charges; excludes voluntary transfers to DEAD.\n    uint256 public totalBurned;\n    /// @dev Gas forwarded to the factory's distributor lookup. A plain mapping getter costs about\n    /// 3,000 gas; this budget also covers a proxy hop and a few dozen cold storage reads, so a\n    /// legitimate registry cannot silently fall into the burn path by exceeding it.\n    uint256 private constant LOOKUP_GAS = 100_000;\n\n    error MainnetOnly();\n    error InvalidLaunchConfiguration();\n\n    constructor(address factory_, address poolManager_, uint64 launchNumber_) ERC20(\"swarm\", \"SWARM\") {\n        if (block.chainid != 1) revert MainnetOnly();\n        if (\n            factory_ != msg.sender || factory_.code.length == 0 || poolManager_.code.length == 0\n                || factory_ == poolManager_ || poolManager_ == DEAD\n        ) revert InvalidLaunchConfiguration();\n        factory = factory_;\n        poolManager = poolManager_;\n        launchNumber = launchNumber_;\n        _mint(msg.sender, INITIAL_SUPPLY);\n    }\n\n    function _update(address from, address to, uint256 amount) internal override {\n        if (from != address(0) && !_exempt(from, to)) {\n            uint256 burned = amount / 100;\n            if (burned != 0) {\n                totalBurned += burned;\n                super._update(from, DEAD, burned);\n                amount -= burned;\n            }\n        }\n        super._update(from, to, amount);\n    }\n\n    /// @dev The PoolManager exemption is unconditional in both directions because v4 settlement\n    /// credits exactly the balance the manager receives and pays out exactly what it is asked to.\n    /// It therefore also covers transfers that merely pass through the manager's ledger\n    /// (sync/settle/take or ERC-6909 claims) without touching this token's pool. That is a\n    /// documented limit of the burn, not an oversight: a burn on either leg would leave a sell\n    /// unsettled, and the brief allows no hook to move the charge onto the swap itself.\n    function _exempt(address from, address to) private view returns (bool) {\n        if (msg.sender == factory || from == poolManager || to == poolManager) return true;\n        // Static, gas-bounded lookup: a missing or broken registry must not freeze holder transfers.\n        bytes memory input = abi.encodeCall(ILaunchFactory.distributorOf, (launchNumber));\n        address registry = factory;\n        bool ok;\n        uint256 distributor;\n        // Copy at most one word, even if the factory returns excessive data.\n        assembly (\"memory-safe\") {\n            ok := staticcall(LOOKUP_GAS, registry, add(input, 32), mload(input), 0, 32)\n            ok := and(ok, eq(returndatasize(), 32))\n            distributor := mload(0)\n        }\n        if (!ok) return false;\n        return distributor != 0 && distributor == uint256(uint160(msg.sender));\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/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC20Metadata} from \"./extensions/IERC20Metadata.sol\";\nimport {Context} from \"../../utils/Context.sol\";\nimport {IERC20Errors} from \"../../interfaces/draft-IERC6093.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC-20\n * applications.\n */\nabstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {\n    mapping(address account => uint256) private _balances;\n\n    mapping(address account => mapping(address spender => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `value`.\n     */\n    function transfer(address to, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 value) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, value);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Skips emitting an {Approval} event indicating an allowance update. This is not\n     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `value`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `value`.\n     */\n    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, value);\n        _transfer(from, to, value);\n        return true;\n    }\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _transfer(address from, address to, uint256 value) internal {\n        if (from == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        if (to == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(from, to, value);\n    }\n\n    /**\n     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\n     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\n     * this function.\n     *\n     * Emits a {Transfer} event.\n     */\n    function _update(address from, address to, uint256 value) internal virtual {\n        if (from == address(0)) {\n            // Overflow check required: The rest of the code assumes that totalSupply never overflows\n            _totalSupply += value;\n        } else {\n            uint256 fromBalance = _balances[from];\n            if (fromBalance < value) {\n                revert ERC20InsufficientBalance(from, fromBalance, value);\n            }\n            unchecked {\n                // Overflow not possible: value <= fromBalance <= totalSupply.\n                _balances[from] = fromBalance - value;\n            }\n        }\n\n        if (to == address(0)) {\n            unchecked {\n                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\n                _totalSupply -= value;\n            }\n        } else {\n            unchecked {\n                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\n                _balances[to] += value;\n            }\n        }\n\n        emit Transfer(from, to, value);\n    }\n\n    /**\n     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\n     * Relies on the `_update` mechanism\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead.\n     */\n    function _mint(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidReceiver(address(0));\n        }\n        _update(address(0), account, value);\n    }\n\n    /**\n     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\n     * Relies on the `_update` mechanism.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * NOTE: This function is not virtual, {_update} should be overridden instead\n     */\n    function _burn(address account, uint256 value) internal {\n        if (account == address(0)) {\n            revert ERC20InvalidSender(address(0));\n        }\n        _update(account, address(0), value);\n    }\n\n    /**\n     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     *\n     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\n     */\n    function _approve(address owner, address spender, uint256 value) internal {\n        _approve(owner, spender, value, true);\n    }\n\n    /**\n     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\n     *\n     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\n     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any\n     * `Approval` event during `transferFrom` operations.\n     *\n     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to\n     * true using the following override:\n     *\n     * ```solidity\n     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\n     *     super._approve(owner, spender, value, true);\n     * }\n     * ```\n     *\n     * Requirements are the same as {_approve}.\n     */\n    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\n        if (owner == address(0)) {\n            revert ERC20InvalidApprover(address(0));\n        }\n        if (spender == address(0)) {\n            revert ERC20InvalidSpender(address(0));\n        }\n        _allowances[owner][spender] = value;\n        if (emitEvent) {\n            emit Approval(owner, spender, value);\n        }\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `value`.\n     *\n     * Does not update the allowance value in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Does not emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance < type(uint256).max) {\n            if (currentAllowance < value) {\n                revert ERC20InsufficientAllowance(spender, currentAllowance, value);\n            }\n            unchecked {\n                _approve(owner, spender, currentAllowance - value, false);\n            }\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Standard ERC-20 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.\n */\ninterface IERC20Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC20InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC20InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     * @param allowance Amount of tokens a `spender` is allowed to operate with.\n     * @param needed Minimum amount required to perform a transfer.\n     */\n    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC20InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\n     * @param spender Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC20InvalidSpender(address spender);\n}\n\n/**\n * @dev Standard ERC-721 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.\n */\ninterface IERC721Errors {\n    /**\n     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.\n     * Used in balance queries.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721InvalidOwner(address owner);\n\n    /**\n     * @dev Indicates a `tokenId` whose `owner` is the zero address.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721NonexistentToken(uint256 tokenId);\n\n    /**\n     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param tokenId Identifier number of a token.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC721InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC721InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC721InsufficientApproval(address operator, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC721InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC721InvalidOperator(address operator);\n}\n\n/**\n * @dev Standard ERC-1155 Errors\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.\n */\ninterface IERC1155Errors {\n    /**\n     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     * @param balance Current balance for the interacting account.\n     * @param needed Minimum amount required to perform a transfer.\n     * @param tokenId Identifier number of a token.\n     */\n    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\n\n    /**\n     * @dev Indicates a failure with the token `sender`. Used in transfers.\n     * @param sender Address whose tokens are being transferred.\n     */\n    error ERC1155InvalidSender(address sender);\n\n    /**\n     * @dev Indicates a failure with the token `receiver`. Used in transfers.\n     * @param receiver Address to which tokens are being transferred.\n     */\n    error ERC1155InvalidReceiver(address receiver);\n\n    /**\n     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     * @param owner Address of the current owner of a token.\n     */\n    error ERC1155MissingApprovalForAll(address operator, address owner);\n\n    /**\n     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\n     * @param approver Address initiating an approval operation.\n     */\n    error ERC1155InvalidApprover(address approver);\n\n    /**\n     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\n     * @param operator Address that may be allowed to operate on tokens without being their owner.\n     */\n    error ERC1155InvalidOperator(address operator);\n\n    /**\n     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\n     * Used in batch transfers.\n     * @param idsLength Length of the array of token identifiers\n     * @param valuesLength Length of the array of token amounts\n     */\n    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"}},"language":"Solidity","settings":{"metadata":{"bytecodeHash":"none"},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":[":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",":solmate/=lib/solmate/",":v4-core/=lib/v4-core/"]}},"stdJsonOutput":{"sources":{"src/Swarm.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"id":4},"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol":{"id":1},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":2},"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol":{"id":0},"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"contracts":{"src/Swarm.sol":{"Swarm":{"abi":[{"type":"constructor","inputs":[{"name":"factory_","type":"address","internalType":"address"},{"name":"poolManager_","type":"address","internalType":"address"},{"name":"launchNumber_","type":"uint64","internalType":"uint64"}],"stateMutability":"nonpayable"},{"name":"ERC20InsufficientAllowance","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"allowance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InsufficientBalance","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"name":"ERC20InvalidApprover","type":"error","inputs":[{"name":"approver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidReceiver","type":"error","inputs":[{"name":"receiver","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSender","type":"error","inputs":[{"name":"sender","type":"address","internalType":"address"}]},{"name":"ERC20InvalidSpender","type":"error","inputs":[{"name":"spender","type":"address","internalType":"address"}]},{"name":"InvalidLaunchConfiguration","type":"error","inputs":[]},{"name":"MainnetOnly","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"DEAD","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"INITIAL_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"factory","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"launchNumber","type":"function","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"poolManager","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalBurned","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.26+commit.8a97fa7a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"factory_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"poolManager_\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"launchNumber_\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"allowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"ERC20InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"approver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidApprover\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"ERC20InvalidReceiver\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSender\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"ERC20InvalidSpender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLaunchConfiguration\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MainnetOnly\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEAD\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIAL_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"launchNumber\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"poolManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalBurned\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Launch distribution and PoolManager settlement are exempt to preserve exact amounts.\",\"errors\":{\"ERC20InsufficientAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failure with the `spender`’s `allowance`. Used in transfers.\",\"params\":{\"allowance\":\"Amount of tokens a `spender` is allowed to operate with.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}],\"ERC20InsufficientBalance(address,uint256,uint256)\":[{\"details\":\"Indicates an error related to the current `balance` of a `sender`. Used in transfers.\",\"params\":{\"balance\":\"Current balance for the interacting account.\",\"needed\":\"Minimum amount required to perform a transfer.\",\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidApprover(address)\":[{\"details\":\"Indicates a failure with the `approver` of a token to be approved. Used in approvals.\",\"params\":{\"approver\":\"Address initiating an approval operation.\"}}],\"ERC20InvalidReceiver(address)\":[{\"details\":\"Indicates a failure with the token `receiver`. Used in transfers.\",\"params\":{\"receiver\":\"Address to which tokens are being transferred.\"}}],\"ERC20InvalidSender(address)\":[{\"details\":\"Indicates a failure with the token `sender`. Used in transfers.\",\"params\":{\"sender\":\"Address whose tokens are being transferred.\"}}],\"ERC20InvalidSpender(address)\":[{\"details\":\"Indicates a failure with the `spender` to be approved. Used in approvals.\",\"params\":{\"spender\":\"Address that may be allowed to operate on tokens without being their owner.\"}}]},\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"name()\":{\"details\":\"Returns the name of the token.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`.\"}},\"stateVariables\":{\"LOOKUP_GAS\":{\"details\":\"Gas forwarded to the factory's distributor lookup. A plain mapping getter costs about 3,000 gas; this budget also covers a proxy hop and a few dozen cold storage reads, so a legitimate registry cannot silently fall into the burn path by exceeding it.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"totalBurned()\":{\"notice\":\"Accumulated automatic 1% charges; excludes voluntary transfers to DEAD.\"}},\"notice\":\"Fixed-supply mainnet token. Ordinary transfers send floor(amount / 100) to DEAD.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/Swarm.sol\":\"Swarm\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":forge-std/=lib/forge-std/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/\",\":solmate/=lib/solmate/\",\":v4-core/=lib/v4-core/\"]},\"sources\":{\"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol\":{\"keccak256\":\"0x880da465c203cec76b10d72dbd87c80f387df4102274f23eea1f9c9b0918792b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://399594cd8bb0143bc9e55e0f1d071d0d8c850a394fb7a319d50edd55d9ed822b\",\"dweb:/ipfs/QmbPZzgtT6LEm9CMqWfagQFwETbV1ztpECBB1DtQHrKiRz\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0x6ef9389a2c07bc40d8a7ba48914724ab2c108fac391ce12314f01321813e6368\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7a5cb39b1e6df68f4dd9a5e76e853d745a74ffb3dfd7df4ae4d2ace6992a171\",\"dweb:/ipfs/QmPbzKR19rdM8X3PLQjsmHRepUKhvoZnedSR63XyGtXZib\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf\",\"dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r\"]},\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"src/Swarm.sol\":{\"keccak256\":\"0xb50b2ab2d2fe12475dc50d25dbee00a3145fb1780b6f0dc6f546d60049dac54f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b0faf7490feb0a4b2013ebe5ad83e019489da3d309153a67e5f63a6b824eadf4\",\"dweb:/ipfs/QmT1rem8m54U7hy7dLmej1L2YiJivwixFxbGksZoK445uP\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Fixed-supply mainnet token. Ordinary transfers send floor(amount / 100) to DEAD.","methods":{"totalBurned()":{"notice":"Accumulated automatic 1% charges; excludes voluntary transfers to DEAD."}},"version":1},"devdoc":{"kind":"dev","errors":{"ERC20InvalidSender(address)":[{"params":{"sender":"Address whose tokens are being transferred."},"details":"Indicates a failure with the token `sender`. Used in transfers."}],"ERC20InvalidSpender(address)":[{"params":{"spender":"Address that may be allowed to operate on tokens without being their owner."},"details":"Indicates a failure with the `spender` to be approved. Used in approvals."}],"ERC20InvalidApprover(address)":[{"params":{"approver":"Address initiating an approval operation."},"details":"Indicates a failure with the `approver` of a token to be approved. Used in approvals."}],"ERC20InvalidReceiver(address)":[{"params":{"receiver":"Address to which tokens are being transferred."},"details":"Indicates a failure with the token `receiver`. Used in transfers."}],"ERC20InsufficientBalance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","sender":"Address whose tokens are being transferred.","balance":"Current balance for the interacting account."},"details":"Indicates an error related to the current `balance` of a `sender`. Used in transfers."}],"ERC20InsufficientAllowance(address,uint256,uint256)":[{"params":{"needed":"Minimum amount required to perform a transfer.","spender":"Address that may be allowed to operate on tokens without being their owner.","allowance":"Amount of tokens a `spender` is allowed to operate with."},"details":"Indicates a failure with the `spender`’s `allowance`. Used in transfers."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"details":"Launch distribution and PoolManager settlement are exempt to preserve exact amounts.","methods":{"name()":{"details":"Returns the name of the token."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`."}},"version":1,"stateVariables":{"LOOKUP_GAS":{"details":"Gas forwarded to the factory's distributor lookup. A plain mapping getter costs about 3,000 gas; this budget also covers a proxy hop and a few dozen cold storage reads, so a legitimate registry cannot silently fall into the burn path by exceeding it."}}},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":159,"label":"_balances","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":165,"label":"_allowances","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"2","type":"t_uint256","astId":167,"label":"_totalSupply","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"3","type":"t_string_storage","astId":169,"label":"_name","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"4","type":"t_string_storage","astId":171,"label":"_symbol","offset":0,"contract":"src/Swarm.sol:Swarm"},{"slot":"5","type":"t_uint256","astId":815,"label":"totalBurned","offset":0,"contract":"src/Swarm.sol:Swarm"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"425:3178:5:-:0;;;1240:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1601:113:1;;;;;;;;;;;;;-1:-1:-1;;;1601:113:1;;;;;;;;;;;;;;;;-1:-1:-1;;;1601:113:1;;;1675:5;1667;:13;;;;;;:::i;:::-;-1:-1:-1;1690:7:1;:17;1700:7;1690;:17;:::i;:::-;;1601:113;;1352:13:5::1;1369:1;1352:18;1348:44;;1379:13;;-1:-1:-1::0;;;1379:13:5::1;;;;;;;;;;;1348:44;-1:-1:-1::0;;;;;1419:22:5;::::1;1431:10;1419:22;;::::0;:51:::1;;-1:-1:-1::0;;;;;;1445:20:5;::::1;;:25:::0;1419:51:::1;:84;;;-1:-1:-1::0;;;;;;1474:24:5;::::1;;:29:::0;1419:84:::1;:128;;;;1535:12;-1:-1:-1::0;;;;;1523:24:5::1;:8;-1:-1:-1::0;;;;;1523:24:5::1;;1419:128;:152;;;-1:-1:-1::0;;;;;;1551:20:5;::::1;552:42;1551:20;1419:152;1402:215;;;1589:28;;-1:-1:-1::0;;;1589:28:5::1;;;;;;;;;;;1402:215;-1:-1:-1::0;;;;;1627:18:5;;::::1;;::::0;1655:26;::::1;;::::0;-1:-1:-1;;;;;1691:28:5;::::1;;::::0;1729:33:::1;1735:10;496:19;1729:5;:33::i;:::-;1240:529:::0;;;425:3178;;7458:208:1;-1:-1:-1;;;;;7528:21:1;;7524:91;;7572:32;;-1:-1:-1;;;7572:32:1;;7601:1;7572:32;;;3446:51:6;3419:18;;7572:32:1;;;;;;;;7524:91;7624:35;7640:1;7644:7;7653:5;7624:7;:35::i;:::-;7458:208;;:::o;1775:403:5:-;-1:-1:-1;;;;;1866:18:5;;;;;;:40;;-1:-1:-1;1889:17:5;1897:4;1903:2;1889:7;:17::i;:::-;1888:18;1866:40;1862:269;;;1922:14;1939:12;1948:3;1939:6;:12;:::i;:::-;1922:29;-1:-1:-1;1969:11:5;;1965:156;;2015:6;2000:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;2039:33:5;;-1:-1:-1;2053:4:5;552:42;2065:6;2039:13;:33::i;:::-;2090:16;2100:6;2090:16;;:::i;:::-;;;1965:156;1908:223;1862:269;2140:31;2154:4;2160:2;2164:6;2140:13;:31::i;:::-;1775:403;;;:::o;2746:855::-;2811:4;2845:7;;-1:-1:-1;;;;;2831:21:5;:10;-1:-1:-1;;;;;2831:21:5;;:44;;;;2864:11;;-1:-1:-1;;;;;2856:19:5;:4;-1:-1:-1;;;;;2856:19:5;;2831:44;:65;;;;2885:11;;-1:-1:-1;;;;;2879:17:5;:2;-1:-1:-1;;;;;2879:17:5;;2831:65;2827:82;;;-1:-1:-1;2905:4:5;2898:11;;2827:82;3088:12;;3042:60;;-1:-1:-1;;;;;4287:31:6;;;3042:60:5;;;4269:50:6;3021:18:5;;4242::6;;3042:60:5;;;-1:-1:-1;;3042:60:5;;;;;;;;;;;;;;;-1:-1:-1;;;;;3042:60:5;-1:-1:-1;;;3042:60:5;;;3131:7;;3366:12;;3042:60;;-1:-1:-1;3131:7:5;-1:-1:-1;;;;3042:60:5;;-1:-1:-1;;3131:7:5;3328:10;3317:69;3472:1;3466:8;3416:16;3434:2;3413:24;3405:33;;;;-1:-1:-1;3466:8:5;-1:-1:-1;3405:33:5;3493:21;;3509:5;3502:12;;;;;;;;3493:21;3531:16;;;;;:63;;-1:-1:-1;3582:10:5;3551:43;;3531:63;3524:70;;;;;;2746:855;;;;;:::o;6008:1107:1:-;-1:-1:-1;;;;;6097:18:1;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:1;;-1:-1:-1;6093:540:1;;-1:-1:-1;;;;;6307:15:1;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;-1:-1:-1;;;6386:50:1;;-1:-1:-1;;;;;4550:32:6;;6386:50:1;;;4532:51:6;4599:18;;;4592:34;;;4642:18;;;4635:34;;;4505:18;;6386:50:1;4330:345:6;6336:115:1;-1:-1:-1;;;;;6571:15:1;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;-1:-1:-1;;;;;6647:16:1;;6643:425;;6810:12;:21;;;;;;;6643:425;;;-1:-1:-1;;;;;7021:13:1;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;-1:-1:-1;;;;;7083:25:1;7092:4;-1:-1:-1;;;;;7083:25:1;;7102:5;7083:25;;;;4826::6;;4814:2;4799:18;;4680:177;7083:25:1;;;;;;;;6008:1107;;;:::o;14:177:6:-;93:13;;-1:-1:-1;;;;;135:31:6;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:458::-;283:6;291;299;352:2;340:9;331:7;327:23;323:32;320:52;;;368:1;365;358:12;320:52;391:40;421:9;391:40;:::i;:::-;381:50;;450:49;495:2;484:9;480:18;450:49;:::i;:::-;542:2;527:18;;521:25;440:59;;-1:-1:-1;;;;;;575:30:6;;565:41;;555:69;;620:1;617;610:12;555:69;643:5;633:15;;;196:458;;;;;:::o;659:127::-;720:10;715:3;711:20;708:1;701:31;751:4;748:1;741:15;775:4;772:1;765:15;791:380;870:1;866:12;;;;913;;;934:61;;988:4;980:6;976:17;966:27;;934:61;1041:2;1033:6;1030:14;1010:18;1007:38;1004:161;;1087:10;1082:3;1078:20;1075:1;1068:31;1122:4;1119:1;1112:15;1150:4;1147:1;1140:15;1004:161;;791:380;;;:::o;1302:518::-;1404:2;1399:3;1396:11;1393:421;;;1440:5;1437:1;1430:16;1484:4;1481:1;1471:18;1554:2;1542:10;1538:19;1535:1;1531:27;1525:4;1521:38;1590:4;1578:10;1575:20;1572:47;;;-1:-1:-1;1613:4:6;1572:47;1668:2;1663:3;1659:12;1656:1;1652:20;1646:4;1642:31;1632:41;;1723:81;1741:2;1734:5;1731:13;1723:81;;;1800:1;1786:16;;1767:1;1756:13;1723:81;;;1727:3;;1302:518;;;:::o;1996:1299::-;2116:10;;-1:-1:-1;;;;;2138:30:6;;2135:56;;;2171:18;;:::i;:::-;2200:97;2290:6;2250:38;2282:4;2276:11;2250:38;:::i;:::-;2244:4;2200:97;:::i;:::-;2346:4;2377:2;2366:14;;2394:1;2389:649;;;;3082:1;3099:6;3096:89;;;-1:-1:-1;3151:19:6;;;3145:26;3096:89;-1:-1:-1;;1953:1:6;1949:11;;;1945:24;1941:29;1931:40;1977:1;1973:11;;;1928:57;3198:81;;2359:930;;2389:649;1249:1;1242:14;;;1286:4;1273:18;;-1:-1:-1;;2425:20:6;;;2543:222;2557:7;2554:1;2551:14;2543:222;;;2639:19;;;2633:26;2618:42;;2746:4;2731:20;;;;2699:1;2687:14;;;;2573:12;2543:222;;;2547:3;2793:6;2784:7;2781:19;2778:201;;;2854:19;;;2848:26;-1:-1:-1;;2937:1:6;2933:14;;;2949:3;2929:24;2925:37;2921:42;2906:58;2891:74;;2778:201;-1:-1:-1;;;;3025:1:6;3009:14;;;3005:22;2992:36;;-1:-1:-1;1996:1299:6:o;3508:127::-;3569:10;3564:3;3560:20;3557:1;3550:31;3600:4;3597:1;3590:15;3624:4;3621:1;3614:15;3640:217;3680:1;3706;3696:132;;3750:10;3745:3;3741:20;3738:1;3731:31;3785:4;3782:1;3775:15;3813:4;3810:1;3803:15;3696:132;-1:-1:-1;3842:9:6;;3640:217::o;3862:125::-;3927:9;;;3948:10;;;3945:36;;;3961:18;;:::i;3992:128::-;4059:9;;;4080:11;;;4077:37;;;4094:18;;:::i;4680:177::-;425:3178:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"608060405234801561000f575f80fd5b50600436106100f0575f3560e01c806370a0823111610093578063c45a015511610063578063c45a01551461021c578063d89135cd14610243578063dc4c90d31461024c578063dd62ed3e14610273575f80fd5b806370a08231146101995780637b21f5b0146101c157806395d89b4114610201578063a9059cbb14610209575f80fd5b806318160ddd116100ce57806318160ddd1461015257806323b872dd146101645780632ff2e9dc14610177578063313ce5671461018a575f80fd5b806303fd2a45146100f457806306fdde031461011a578063095ea7b31461012f575b5f80fd5b6100fd61dead81565b6040516001600160a01b0390911681526020015b60405180910390f35b6101226102ab565b6040516101119190610872565b61014261013d3660046108c2565b61033b565b6040519015158152602001610111565b6002545b604051908152602001610111565b6101426101723660046108ea565b610354565b6101566b033b2e3c9fd0803ce800000081565b60405160128152602001610111565b6101566101a7366004610924565b6001600160a01b03165f9081526020819052604090205490565b6101e87f000000000000000000000000000000000000000000000000000000000000000081565b60405167ffffffffffffffff9091168152602001610111565b610122610377565b6101426102173660046108c2565b610386565b6100fd7f000000000000000000000000000000000000000000000000000000000000000081565b61015660055481565b6100fd7f000000000000000000000000000000000000000000000000000000000000000081565b610156610281366004610944565b6001600160a01b039182165f90815260016020908152604080832093909416825291909152205490565b6060600380546102ba90610975565b80601f01602080910402602001604051908101604052809291908181526020018280546102e690610975565b80156103315780601f1061030857610100808354040283529160200191610331565b820191905f5260205f20905b81548152906001019060200180831161031457829003601f168201915b5050505050905090565b5f33610348818585610393565b60019150505b92915050565b5f336103618582856103a5565b61036c858585610426565b506001949350505050565b6060600480546102ba90610975565b5f33610348818585610426565b6103a08383836001610483565b505050565b6001600160a01b038381165f908152600160209081526040808320938616835292905220545f19811015610420578181101561041257604051637dc7a0d960e11b81526001600160a01b038416600482015260248101829052604481018390526064015b60405180910390fd5b61042084848484035f610483565b50505050565b6001600160a01b03831661044f57604051634b637e8f60e11b81525f6004820152602401610409565b6001600160a01b0382166104785760405163ec442f0560e01b81525f6004820152602401610409565b6103a0838383610555565b6001600160a01b0384166104ac5760405163e602df0560e01b81525f6004820152602401610409565b6001600160a01b0383166104d557604051634a1406b160e11b81525f6004820152602401610409565b6001600160a01b038085165f908152600160209081526040808320938716835292905220829055801561042057826001600160a01b0316846001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258460405161054791815260200190565b60405180910390a350505050565b6001600160a01b03831615801590610574575061057283836105cb565b155b156105c0575f6105856064836109c1565b905080156105be578060055f82825461059e91906109e0565b909155506105b190508461dead8361074c565b6105bb81836109f3565b91505b505b6103a083838361074c565b5f336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016148061063457507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316836001600160a01b0316145b8061067057507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316826001600160a01b0316145b1561067d5750600161034e565b60405167ffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001660248201525f9060440160408051601f19818403018152919052602080820180516001600160e01b0316633631ba4960e11b17815282519293507f0000000000000000000000000000000000000000000000000000000000000000925f9283929091839186620186a0fa5f513d6020149091169250905081610733575f94505050505061034e565b801580159061074157503381145b979650505050505050565b6001600160a01b038316610776578060025f82825461076b91906109e0565b909155506107e69050565b6001600160a01b0383165f90815260208190526040902054818110156107c85760405163391434e360e21b81526001600160a01b03851660048201526024810182905260448101839052606401610409565b6001600160a01b0384165f9081526020819052604090209082900390555b6001600160a01b03821661080257600280548290039055610820565b6001600160a01b0382165f9081526020819052604090208054820190555b816001600160a01b0316836001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161086591815260200190565b60405180910390a3505050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b80356001600160a01b03811681146108bd575f80fd5b919050565b5f80604083850312156108d3575f80fd5b6108dc836108a7565b946020939093013593505050565b5f805f606084860312156108fc575f80fd5b610905846108a7565b9250610913602085016108a7565b929592945050506040919091013590565b5f60208284031215610934575f80fd5b61093d826108a7565b9392505050565b5f8060408385031215610955575f80fd5b61095e836108a7565b915061096c602084016108a7565b90509250929050565b600181811c9082168061098957607f821691505b6020821081036109a757634e487b7160e01b5f52602260045260245ffd5b50919050565b634e487b7160e01b5f52601160045260245ffd5b5f826109db57634e487b7160e01b5f52601260045260245ffd5b500490565b8082018082111561034e5761034e6109ad565b8181038181111561034e5761034e6109ad56fea164736f6c634300081a000a","sourceMap":"425:3178:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;521:73;;552:42;521:73;;;;;-1:-1:-1;;;;;178:32:6;;;160:51;;148:2;133:18;521:73:5;;;;;;;;1779:89:1;;;:::i;:::-;;;;;;;:::i;3998:186::-;;;;;;:::i;:::-;;:::i;:::-;;;1293:14:6;;1286:22;1268:41;;1256:2;1241:18;3998:186:1;1128:187:6;2849:97:1;2927:12;;2849:97;;;1466:25:6;;;1454:2;1439:18;2849:97:1;1320:177:6;4776:244:1;;;;;;:::i;:::-;;:::i;455:60:5:-;;496:19;455:60;;2707:82:1;;;2780:2;2023:36:6;;2011:2;1996:18;2707:82:1;1881:184:6;3004:116:1;;;;;;:::i;:::-;-1:-1:-1;;;;;3095:18:1;3069:7;3095:18;;;;;;;;;;;;3004:116;680:36:5;;;;;;;;2435:18:6;2423:31;;;2405:50;;2393:2;2378:18;680:36:5;2261:200:6;1981:93:1;;;:::i;3315:178::-;;;;;;:::i;:::-;;:::i;600:32:5:-;;;;;810:26;;;;;;638:36;;;;;3551:140:1;;;;;;:::i;:::-;-1:-1:-1;;;;;3657:18:1;;;3631:7;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3551:140;1779:89;1824:13;1856:5;1849:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1779:89;:::o;3998:186::-;4071:4;735:10:4;4125:31:1;735:10:4;4141:7:1;4150:5;4125:8;:31::i;:::-;4173:4;4166:11;;;3998:186;;;;;:::o;4776:244::-;4863:4;735:10:4;4919:37:1;4935:4;735:10:4;4950:5:1;4919:15;:37::i;:::-;4966:26;4976:4;4982:2;4986:5;4966:9;:26::i;:::-;-1:-1:-1;5009:4:1;;4776:244;-1:-1:-1;;;;4776:244:1:o;1981:93::-;2028:13;2060:7;2053:14;;;;;:::i;3315:178::-;3384:4;735:10:4;3438:27:1;735:10:4;3455:2:1;3459:5;3438:9;:27::i;8726:128::-;8810:37;8819:5;8826:7;8835:5;8842:4;8810:8;:37::i;:::-;8726:128;;;:::o;10415:476::-;-1:-1:-1;;;;;3657:18:1;;;10514:24;3657:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;10580:36:1;;10576:309;;;10655:5;10636:16;:24;10632:130;;;10687:60;;-1:-1:-1;;;10687:60:1;;-1:-1:-1;;;;;3336:32:6;;10687:60:1;;;3318:51:6;3385:18;;;3378:34;;;3428:18;;;3421:34;;;3291:18;;10687:60:1;;;;;;;;10632:130;10803:57;10812:5;10819:7;10847:5;10828:16;:24;10854:5;10803:8;:57::i;:::-;10504:387;10415:476;;;:::o;5393:300::-;-1:-1:-1;;;;;5476:18:1;;5472:86;;5517:30;;-1:-1:-1;;;5517:30:1;;5544:1;5517:30;;;160:51:6;133:18;;5517:30:1;14:203:6;5472:86:1;-1:-1:-1;;;;;5571:16:1;;5567:86;;5610:32;;-1:-1:-1;;;5610:32:1;;5639:1;5610:32;;;160:51:6;133:18;;5610:32:1;14:203:6;5567:86:1;5662:24;5670:4;5676:2;5680:5;5662:7;:24::i;9701:432::-;-1:-1:-1;;;;;9813:19:1;;9809:89;;9855:32;;-1:-1:-1;;;9855:32:1;;9884:1;9855:32;;;160:51:6;133:18;;9855:32:1;14:203:6;9809:89:1;-1:-1:-1;;;;;9911:21:1;;9907:90;;9955:31;;-1:-1:-1;;;9955:31:1;;9983:1;9955:31;;;160:51:6;133:18;;9955:31:1;14:203:6;9907:90:1;-1:-1:-1;;;;;10006:18:1;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;10051:76;;;;10101:7;-1:-1:-1;;;;;10085:31:1;10094:5;-1:-1:-1;;;;;10085:31:1;;10110:5;10085:31;;;;1466:25:6;;1454:2;1439:18;;1320:177;10085:31:1;;;;;;;;9701:432;;;;:::o;1775:403:5:-;-1:-1:-1;;;;;1866:18:5;;;;;;:40;;;1889:17;1897:4;1903:2;1889:7;:17::i;:::-;1888:18;1866:40;1862:269;;;1922:14;1939:12;1948:3;1939:6;:12;:::i;:::-;1922:29;-1:-1:-1;1969:11:5;;1965:156;;2015:6;2000:11;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;2039:33:5;;-1:-1:-1;2053:4:5;552:42;2065:6;2039:13;:33::i;:::-;2090:16;2100:6;2090:16;;:::i;:::-;;;1965:156;1908:223;1862:269;2140:31;2154:4;2160:2;2164:6;2140:13;:31::i;2746:855::-;2811:4;2831:10;-1:-1:-1;;;;;2845:7:5;2831:21;;;:44;;;2864:11;-1:-1:-1;;;;;2856:19:5;:4;-1:-1:-1;;;;;2856:19:5;;2831:44;:65;;;;2885:11;-1:-1:-1;;;;;2879:17:5;:2;-1:-1:-1;;;;;2879:17:5;;2831:65;2827:82;;;-1:-1:-1;2905:4:5;2898:11;;2827:82;3042:60;;2435:18:6;3088:12:5;2423:31:6;3042:60:5;;;2405:50:6;3021:18:5;;2378::6;;3042:60:5;;;-1:-1:-1;;3042:60:5;;;;;;;;;;;;;;;-1:-1:-1;;;;;3042:60:5;-1:-1:-1;;;3042:60:5;;;3366:12;;3042:60;;-1:-1:-1;3131:7:5;;-1:-1:-1;;;;3042:60:5;;-1:-1:-1;;3131:7:5;3328:10;3317:69;3472:1;3466:8;3416:16;3434:2;3413:24;3405:33;;;;-1:-1:-1;3466:8:5;-1:-1:-1;3405:33:5;3493:21;;3509:5;3502:12;;;;;;;;3493:21;3531:16;;;;;:63;;-1:-1:-1;3582:10:5;3551:43;;3531:63;3524:70;2746:855;-1:-1:-1;;;;;;;2746:855:5:o;6008:1107:1:-;-1:-1:-1;;;;;6097:18:1;;6093:540;;6249:5;6233:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;6093:540:1;;-1:-1:-1;6093:540:1;;-1:-1:-1;;;;;6307:15:1;;6285:19;6307:15;;;;;;;;;;;6340:19;;;6336:115;;;6386:50;;-1:-1:-1;;;6386:50:1;;-1:-1:-1;;;;;3336:32:6;;6386:50:1;;;3318:51:6;3385:18;;;3378:34;;;3428:18;;;3421:34;;;3291:18;;6386:50:1;3116:345:6;6336:115:1;-1:-1:-1;;;;;6571:15:1;;:9;:15;;;;;;;;;;6589:19;;;;6571:37;;6093:540;-1:-1:-1;;;;;6647:16:1;;6643:425;;6810:12;:21;;;;;;;6643:425;;;-1:-1:-1;;;;;7021:13:1;;:9;:13;;;;;;;;;;:22;;;;;;6643:425;7098:2;-1:-1:-1;;;;;7083:25:1;7092:4;-1:-1:-1;;;;;7083:25:1;;7102:5;7083:25;;;;1466::6;;1454:2;1439:18;;1320:177;7083:25:1;;;;;;;;6008:1107;;;:::o;222:418:6:-;371:2;360:9;353:21;334:4;403:6;397:13;446:6;441:2;430:9;426:18;419:34;505:6;500:2;492:6;488:15;483:2;472:9;468:18;462:50;561:1;556:2;547:6;536:9;532:22;528:31;521:42;631:2;624;620:7;615:2;607:6;603:15;599:29;588:9;584:45;580:54;572:62;;;222:418;;;;:::o;645:173::-;713:20;;-1:-1:-1;;;;;762:31:6;;752:42;;742:70;;808:1;805;798:12;742:70;645:173;;;:::o;823:300::-;891:6;899;952:2;940:9;931:7;927:23;923:32;920:52;;;968:1;965;958:12;920:52;991:29;1010:9;991:29;:::i;:::-;981:39;1089:2;1074:18;;;;1061:32;;-1:-1:-1;;;823:300:6:o;1502:374::-;1579:6;1587;1595;1648:2;1636:9;1627:7;1623:23;1619:32;1616:52;;;1664:1;1661;1654:12;1616:52;1687:29;1706:9;1687:29;:::i;:::-;1677:39;;1735:38;1769:2;1758:9;1754:18;1735:38;:::i;:::-;1502:374;;1725:48;;-1:-1:-1;;;1842:2:6;1827:18;;;;1814:32;;1502:374::o;2070:186::-;2129:6;2182:2;2170:9;2161:7;2157:23;2153:32;2150:52;;;2198:1;2195;2188:12;2150:52;2221:29;2240:9;2221:29;:::i;:::-;2211:39;2070:186;-1:-1:-1;;;2070:186:6:o;2466:260::-;2534:6;2542;2595:2;2583:9;2574:7;2570:23;2566:32;2563:52;;;2611:1;2608;2601:12;2563:52;2634:29;2653:9;2634:29;:::i;:::-;2624:39;;2682:38;2716:2;2705:9;2701:18;2682:38;:::i;:::-;2672:48;;2466:260;;;;;:::o;2731:380::-;2810:1;2806:12;;;;2853;;;2874:61;;2928:4;2920:6;2916:17;2906:27;;2874:61;2981:2;2973:6;2970:14;2950:18;2947:38;2944:161;;3027:10;3022:3;3018:20;3015:1;3008:31;3062:4;3059:1;3052:15;3090:4;3087:1;3080:15;2944:161;;2731:380;;;:::o;3466:127::-;3527:10;3522:3;3518:20;3515:1;3508:31;3558:4;3555:1;3548:15;3582:4;3579:1;3572:15;3598:217;3638:1;3664;3654:132;;3708:10;3703:3;3699:20;3696:1;3689:31;3743:4;3740:1;3733:15;3771:4;3768:1;3761:15;3654:132;-1:-1:-1;3800:9:6;;3598:217::o;3820:125::-;3885:9;;;3906:10;;;3903:36;;;3919:18;;:::i;3950:128::-;4017:9;;;4038:11;;;4035:37;;;4052:18;;:::i","linkReferences":{},"immutableReferences":{"808":[{"start":545,"length":32},{"start":1495,"length":32},{"start":1767,"length":32}],"810":[{"start":593,"length":32},{"start":1536,"length":32},{"start":1596,"length":32}],"812":[{"start":454,"length":32},{"start":1675,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"DEAD()","signatureHash4":"0x03fd2a45","signatureHash32":"0x03fd2a45e4e9a30abc8ac3256509917cadcd5e1844b2f19e7167e41b8181284b"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"factory()","signatureHash4":"0xc45a0155","signatureHash32":"0xc45a01550ceb4bc5c6b2e6f722b5033a03078f9bd6673457375ba94c26ac1cf0"},{"signature":"INITIAL_SUPPLY()","signatureHash4":"0x2ff2e9dc","signatureHash32":"0x2ff2e9dcae8124f88d34283cabc114b008e0e13a482cd0480c50a56cafcd3a7d"},{"signature":"launchNumber()","signatureHash4":"0x7b21f5b0","signatureHash32":"0x7b21f5b0b0ca2404cd4a5abc9eaf6688972b5d6881017b0eea155f3736fb5a05"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"poolManager()","signatureHash4":"0xdc4c90d3","signatureHash32":"0xdc4c90d3c2342c5afe26871a21a4ecf482fcb45ae1ac8294d1dcff7a134352c0"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"totalBurned()","signatureHash4":"0xd89135cd","signatureHash32":"0xd89135cddb3b6c41c0720c8d7275cdd8b5478920e58bcf7bd96e92e3c514ddb2"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[{"signature":"ERC20InsufficientAllowance(address,uint256,uint256)","signatureHash4":"0xfb8f41b2","signatureHash32":"0xfb8f41b23e99d2101d86da76cdfa87dd51c82ed07d3cb62cbc473e469dbc75c3"},{"signature":"ERC20InsufficientBalance(address,uint256,uint256)","signatureHash4":"0xe450d38c","signatureHash32":"0xe450d38cd8d9f7d95077d567d60ed49c7254716e6ad08fc9872816c97e0ffec6"},{"signature":"ERC20InvalidApprover(address)","signatureHash4":"0xe602df05","signatureHash32":"0xe602df05cc75712490294c6c104ab7c17f4030363910a7a2626411c6d3118847"},{"signature":"ERC20InvalidReceiver(address)","signatureHash4":"0xec442f05","signatureHash32":"0xec442f055133b72f3b2f9f0bb351c406b178527de2040a7d1feb4e058771f613"},{"signature":"ERC20InvalidSender(address)","signatureHash4":"0x96c6fd1e","signatureHash32":"0x96c6fd1edd0cd6ef7ff0ecc0facdf53148dc0048b57fe58af65755250a7a96bd"},{"signature":"ERC20InvalidSpender(address)","signatureHash4":"0x94280d62","signatureHash32":"0x94280d62c347d8d9f4d59a76ea321452406db88df38e0c9da304f58b57b373a2"},{"signature":"InvalidLaunchConfiguration()","signatureHash4":"0xbb961ec0","signatureHash32":"0xbb961ec046fd0c0daeea5f690bea3cc7ed48459202779c72f8884d63bec5efb7"},{"signature":"MainnetOnly()","signatureHash4":"0xb5058b61","signatureHash32":"0xb5058b61f886243fe6d5a74e0d10756d055f1f42f1df84d48cb51fb762098f27"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0xd2aEF07B4A807062C1C9f01713def52172548ECA"}