{"matchId":"42752518","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-07-22T20:26:49Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"928:2808:20:-:0;;;1171:4:2;1128:48;;1042:53:20;;;;;;;;;-1:-1:-1;1066:22:20;:20;:22::i;:::-;928:2808;;7709:422:1;3147:66;7898:15;;;;;;;7894:76;;;7936:23;;-1:-1:-1;;;7936:23:1;;;;;;;;;;;7894:76;7983:14;;-1:-1:-1;;;;;7983:14:1;;;:34;7979:146;;8033:33;;-1:-1:-1;;;;;;8033:33:1;-1:-1:-1;;;;;8033:33:1;;;;;8085:29;;158:50:29;;;8085:29:1;;146:2:29;131:18;8085:29:1;;;;;;;7979:146;7758:373;7709:422::o;14:200:29:-;928:2808:20;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220849ece13109b49479d33c8874f88fa2b175859b9e781a27b931d82cb09d43ad864736f6c63430008160033","offset":8094}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"928:2808:20:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5074:220:24;;;;;;;;;;-1:-1:-1;5074:220:24;;;;;:::i;:::-;;:::i;:::-;;;616:14:29;;609:22;591:41;;579:2;564:18;5074:220:24;;;;;;;;2015:109;;;;;;;;;;;;;:::i;:::-;;1369:124:27;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;807:32:29;;;789:51;;777:2;762:18;1369:124:27;643:203:29;4943:125:24;;;;;;;;;;-1:-1:-1;4943:125:24;;;;;:::i;:::-;5015:7;5041:20;;;;;;;;;;;-1:-1:-1;;;;;5041:20:24;;4943:125;1817:48:23;;;;;;;;;;;;1861:4;1817:48;;;;;1182:25:29;;;1170:2;1155:18;1817:48:23;1036:177:29;779:36:23;;;;;;;;;;;;814:1;779:36;;1832:37:24;;;;;;;;;;;;1868:1;1832:37;;;;;1390:4:29;1378:17;;;1360:36;;1348:2;1333:18;1832:37:24;1218:184:29;1469:59:23;;;;;;;;;;;;1524:4;1469:59;;1763:48;;;;;;;;;;;;1807:4;1763:48;;1243:47;;;;;;;;;;;;1286:4;1243:47;;4161:214:2;;;;;;:::i;:::-;;:::i;3708:134::-;;;;;;;;;;;;;:::i;3155:101:0:-;;;;;;;;;;;;;:::i;1791:35:24:-;;;;;;;;;;;;1825:1;1791:35;;1875:37;;;;;;;;;;;;1911:1;1875:37;;1015:41:23;;;;;;;;;;;;1054:2;1015:41;;1101:100:20;;;;;;;;;;;;;:::i;1207:1198::-;;;;;;;;;;-1:-1:-1;1207:1198:20;;;;;:::i;:::-;;:::i;821:44:23:-;;;;;;;;;;;;864:1;821:44;;2441:144:0;;;;;;;;;;;;;:::i;966:43:23:-;;;;;;;;;;;;1007:2;966:43;;1819:58:2;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1819:58:2;;;;;;;;;;;;:::i;1195:42:23:-;;;;;;;;;;;;1234:3;1195:42;;1413:50;;;;;;;;;;;;1459:4;1413:50;;1642:51;;;;;;;;;;;;1692:1;1642:51;;1603:112:27;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;8444:31:29;;;8426:50;;8414:2;8399:18;1603:112:27;8282:200:29;732:41:23;;;;;;;;;;;;772:1;732:41;;1016:142:27;;;;;;;;;;;;;:::i;871:46:23:-;;;;;;;;;;;;916:1;871:46;;923:37;;;;;;;;;;;;958:2;923:37;;1127:62;;;;;;;;;;;;1186:3;1127:62;;1062:59;;;;;;;;;;;;1118:3;1062:59;;1918:39:24;;;;;;;;;;;;1956:1;1918:39;;1963:45;;;;;;;;;;;;2007:1;1963:45;;1296:64:23;;;;;;;;;;;;1356:4;1296:64;;1699:58;;;;;;;;;;;;1752:5;1699:58;;3405:215:0;;;;;;;;;;-1:-1:-1;3405:215:0;;;;;:::i;:::-;;:::i;5074:220:24:-;5170:4;2175:10;2164:7;:5;:7::i;:::-;-1:-1:-1;;;;;2164:21:24;;2160:116;;1868:1;2195:17;:15;:17::i;:::-;:37;;-1:-1:-1;;;2195:37:24;;2221:10;2195:37;;;789:51:29;-1:-1:-1;;;;;2195:25:24;;;;;;;762:18:29;;2195:37:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;;2187:89;;;;-1:-1:-1;;;2187:89:24;;;;;;;:::i;:::-;;;;;;;;;5186:8:::1;:20:::0;;;::::1;::::0;;;;;;;;:31;;-1:-1:-1;;;;;;5186:31:24::1;-1:-1:-1::0;;;;;5186:31:24;::::1;::::0;;::::1;::::0;;;5232:34;;9483:25:29;;;9524:18;;;9517:60;5232:34:24::1;::::0;9456:18:29;5232:34:24::1;;;;;;;-1:-1:-1::0;5283:4:24::1;5074:220:::0;;;;:::o;2015:109::-;6929:20:1;:18;:20::i;:::-;2091:26:24::1;2106:10;2091:14;:26::i;:::-;2015:109::o:0;1369:124:27:-;1428:7;1454:32;-1:-1:-1;;;;;;;;;;;1519:53:7;-1:-1:-1;;;;;1519:53:7;;1441:138;1454:32:27;1447:39;;1369:124;:::o;4161:214:2:-;2655:13;:11;:13::i;:::-;4276:36:::1;4294:17;4276;:36::i;:::-;4322:46;4344:17;4363:4;4322:21;:46::i;:::-;4161:214:::0;;:::o;3708:134::-;3777:7;2926:20;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;;3708:134:2;:::o;3155:101:0:-;2334:13;:11;:13::i;:::-;3219:30:::1;3246:1;3219:18;:30::i;1101:100:20:-:0;2655:13:2;:11;:13::i;:::-;3147:66:1;4302:15;;-1:-1:-1;;;4302:15:1;::::1;;;4301:16;::::0;-1:-1:-1;;;;;4348:14:1::1;4158:30;4724:16:::0;;:34;::::1;;;;4744:14;4724:34;4704:54;;4768:17;4788:11;-1:-1:-1::0;;;;;4788:16:1::1;4803:1;4788:16;:50;;;;-1:-1:-1::0;4816:4:1::1;4808:25;:30:::0;4788:50:::1;4768:70;;4854:12;4853:13;:30;;;;;4871:12;4870:13;4853:30;4849:91;;;4906:23;;-1:-1:-1::0;;;4906:23:1::1;;;;;;;;;;;4849:91;4949:18:::0;;-1:-1:-1;;4949:18:1::1;4966:1;4949:18;::::0;;4977:67;::::1;;;5011:22:::0;;-1:-1:-1;;;;5011:22:1::1;-1:-1:-1::0;;;5011:22:1::1;::::0;;4977:67:::1;1171:23:20::2;:21;:23::i;:::-;5068:14:1::1;5064:101;;;5098:23:::0;;-1:-1:-1;;;;5098:23:1::1;::::0;;5140:14:::1;::::0;-1:-1:-1;8426:50:29;;5140:14:1::1;::::0;8414:2:29;8399:18;5140:14:1::1;;;;;;;5064:101;4092:1079;;;;;1101:100:20:o:0;1207:1198::-;1643:4;2781:28:24;2812:17;:15;:17::i;:::-;2852:32;;-1:-1:-1;;;2852:32:24;;2873:10;2852:32;;;789:51:29;2781:48:24;;-1:-1:-1;2839:10:24;;-1:-1:-1;;;;;2852:20:24;;;;;762:18:29;;2852:32:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2839:45;-1:-1:-1;2902:19:24;;;1911:1;2902:19;;:42;;-1:-1:-1;2925:19:24;;;1868:1;2925:19;2902:42;2894:79;;;;-1:-1:-1;;;2894:79:24;;;;;;;:::i;:::-;1667:15:20::1;:22;1693:1;1667:27;1659:66;;;;-1:-1:-1::0;;;1659:66:20::1;;;;;;;:::i;:::-;1770:21;:28;1743:16;:23;:55;1735:94;;;;-1:-1:-1::0;;;1735:94:20::1;;;;;;;:::i;:::-;1870:17;:24;1847:12;:19;:47;1839:86;;;;-1:-1:-1::0;;;1839:86:20::1;;;;;;;:::i;:::-;1939:20;:18;:20::i;:::-;:34;::::0;-1:-1:-1;;;1939:34:20;;-1:-1:-1;;;;;807:32:29;;;1939:34:20::1;::::0;::::1;789:51:29::0;1939:29:20;;;::::1;::::0;::::1;::::0;762:18:29;;1939:34:20::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1935:305;;;1997:69;2023:20;:18;:20::i;:::-;:37;::::0;-1:-1:-1;;;2023:37:20;;-1:-1:-1;;;;;807:32:29;;;2023:37:20::1;::::0;::::1;789:51:29::0;2023:32:20;;;::::1;::::0;::::1;::::0;762:18:29;;2023:37:20::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;2023:37:20::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;2062:3;;1997:69;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;1997:25:20::1;::::0;-1:-1:-1;;;1997:69:20:i:1;:::-;1989:116;;;::::0;-1:-1:-1;;;1989:116:20;;11294:2:29;1989:116:20::1;::::0;::::1;11276:21:29::0;11333:2;11313:18;;;11306:30;11372:34;11352:18;;;11345:62;-1:-1:-1;;;11423:18:29;;;11416:32;11465:19;;1989:116:20::1;11092:398:29::0;1989:116:20::1;1935:305;;;2136:93;2153:3;;2136:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2158:3;2163:14;2179:8;2189:16;2207:21;2136:16;:93::i;:::-;814:1:23::0;5343:8:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;-1:-1:-1;;;;;2250:39:20::1;;2290:3;2295:15;2311:1;2295:18;;;;;;;;:::i;:::-;;;;;;;2315:15;2331:1;2315:18;;;;;;;;:::i;:::-;;;;;;;2335:12;2349:7;2358:17;2250:126;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;2394:4:20::1;::::0;1207:1198;-1:-1:-1;;;;;;;;;;;;;;1207:1198:20:o;2441:144:0:-;1313:22;2570:8;-1:-1:-1;;;;;2570:8:0;;2441:144::o;1603:112:27:-;1659:6;1684:24;3147:66:1;8323:39;-1:-1:-1;;;;;8323:39:1;;8241:128;1016:142:27;2655:13:2;:11;:13::i;:::-;6929:20:1::1;:18;:20::i;:::-;1093:24:27::2;:22;:24::i;:::-;1127;:22;:24::i;3405:215:0:-:0;2334:13;:11;:13::i;:::-;-1:-1:-1;;;;;3489:22:0;::::1;3485:91;;3534:31;::::0;-1:-1:-1;;;3534:31:0;;3562:1:::1;3534:31;::::0;::::1;789:51:29::0;762:18;;3534:31:0::1;643:203:29::0;3485:91:0::1;3585:28;3604:8;3585:18;:28::i;:::-;3405:215:::0;:::o;5415:135:24:-;772:1:23;5465:15:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;;1369:124:27:o;7082:141:1:-;3147:66;8558:40;-1:-1:-1;;;8558:40:1;;;;7144:73;;7189:17;;-1:-1:-1;;;7189:17:1;;;;;;;;;;;1847:127:0;6929:20:1;:18;:20::i;:::-;1929:38:0::1;1954:12;1929:24;:38::i;4578:312:2:-:0;4658:4;-1:-1:-1;;;;;4667:6:2;4650:23;;;:120;;;4764:6;-1:-1:-1;;;;;4728:42:2;:32;-1:-1:-1;;;;;;;;;;;1519:53:7;-1:-1:-1;;;;;1519:53:7;;1441:138;4728:32:2;-1:-1:-1;;;;;4728:42:2;;;4650:120;4633:251;;;4844:29;;-1:-1:-1;;;4844:29:2;;;;;;;;;;;1223:67:27;2175:10:24;2164:7;:5;:7::i;:::-;-1:-1:-1;;;;;2164:21:24;;2160:116;;1868:1;2195:17;:15;:17::i;:::-;:37;;-1:-1:-1;;;2195:37:24;;2221:10;2195:37;;;789:51:29;-1:-1:-1;;;;;2195:25:24;;;;;;;762:18:29;;2195:37:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;;2187:89;;;;-1:-1:-1;;;2187:89:24;;;;;;;:::i;6032:538:2:-;6149:17;-1:-1:-1;;;;;6131:50:2;;:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6131:52:2;;;;;;;;-1:-1:-1;;6131:52:2;;;;;;;;;;;;:::i;:::-;;;6127:437;;6493:60;;-1:-1:-1;;;6493:60:2;;-1:-1:-1;;;;;807:32:29;;6493:60:2;;;789:51:29;762:18;;6493:60:2;643:203:29;6127:437:2;-1:-1:-1;;;;;;;;;;;6225:40:2;;6221:120;;6292:34;;-1:-1:-1;;;6292:34:2;;;;;1182:25:29;;;1155:18;;6292:34:2;1036:177:29;6221:120:2;6354:54;6384:17;6403:4;6354:29;:54::i;:::-;6184:235;6032:538;;:::o;5007:213::-;5081:4;-1:-1:-1;;;;;5090:6:2;5073:23;;5069:145;;5174:29;;-1:-1:-1;;;5174:29:2;;;;;;;;;;;2658:162:0;966:10:3;2717:7:0;:5;:7::i;:::-;-1:-1:-1;;;;;2717:23:0;;2713:101;;2763:40;;-1:-1:-1;;;2763:40:0;;966:10:3;2763:40:0;;;789:51:29;762:18;;2763:40:0;643:203:29;3774:248:0;1313:22;3923:8;;-1:-1:-1;;;;;;3941:19:0;;-1:-1:-1;;;;;3941:19:0;;;;;;;;3975:40;;3923:8;;;;;3975:40;;3847:24;;3975:40;3837:185;;3774:248;:::o;5999:147:24:-;864:1:23;6052:18:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;;1369:124:27:o;880:154:28:-;968:4;1010:19;1023:5;1010:12;:19::i;:::-;987;1000:5;987:12;:19::i;:::-;:42;;880:154;-1:-1:-1;;;880:154:28:o;2411:1323:20:-;2674:34;2711:20;:18;:20::i;:::-;2852:23;;2674:57;;-1:-1:-1;2773:1:20;;2852:28;;:82;;;2911:23;2884:50;;:16;:23;:50;2852:82;2844:121;;;;-1:-1:-1;;;2844:121:20;;;;;;;:::i;:::-;2975:28;3044:23;3017:50;;:16;:23;:50;3013:378;;3111:23;3099:36;;-1:-1:-1;;;;;3099:36:20;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3099:36:20;;3083:52;;3168:15;-1:-1:-1;;;;;3168:28:20;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3149:13;3163:1;3149:16;;;;;;;;:::i;:::-;;;;;;:49;;;;;;;;;;;3231:15;-1:-1:-1;;;;;3231:26:20;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3212:13;3226:1;3212:16;;;;;;;;:::i;:::-;;;;;;:47;;;;;;;;;;;3292:15;-1:-1:-1;;;;;3292:25:20;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3273:13;3287:1;3273:16;;;;;;;;:::i;:::-;;;;;;:46;;;;;;;;;;;3013:378;;;-1:-1:-1;3366:14:20;;;3378:1;3366:14;;;;;;;;3013:378;3435:16;;;3449:1;3435:16;;;;;;;;;3400:32;;3435:16;;;;;;;;;;;-1:-1:-1;3435:16:20;3400:51;;3482:7;3461:15;3477:1;3461:18;;;;;;;;:::i;:::-;-1:-1:-1;;;;;3461:28:20;;;:18;;;;;;;;;:28;3499:228;;-1:-1:-1;;;3499:228:20;;:30;;;;;;:228;;3543:3;;3560:14;;3588:8;;3610:15;;3639:13;;3666:16;;3696:21;;3499:228;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2664:1070;;;;2411:1323;;;;;;:::o;2970:67:2:-;6929:20:1;:18;:20::i;1980:235:0:-;6929:20:1;:18;:20::i;2264:344:7:-;2355:37;2374:17;2355:18;:37::i;:::-;2407:36;;-1:-1:-1;;;;;2407:36:7;;;;;;;;2458:11;;:15;2454:148;;2489:53;2518:17;2537:4;2489:28;:53::i;2454:148::-;2573:18;:16;:18::i;751:125:28:-;816:7;865:4;848:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;838:33;;;;;;831:40;;751:125;;;:::o;1671:281:7:-;1748:17;-1:-1:-1;;;;;1748:29:7;;1781:1;1748:34;1744:119;;1805:47;;-1:-1:-1;;;1805:47:7;;-1:-1:-1;;;;;807:32:29;;1805:47:7;;;789:51:29;762:18;;1805:47:7;643:203:29;1744:119:7;-1:-1:-1;;;;;;;;;;;1872:73:7;;-1:-1:-1;;;;;;1872:73:7;-1:-1:-1;;;;;1872:73:7;;;;;;;;;;1671:281::o;3916:253:10:-;3999:12;4024;4038:23;4065:6;-1:-1:-1;;;;;4065:19:10;4085:4;4065:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4023:67;;;;4107:55;4134:6;4142:7;4151:10;4107:26;:55::i;:::-;4100:62;3916:253;-1:-1:-1;;;;;3916:253:10:o;6113:122:7:-;6163:9;:13;6159:70;;6199:19;;-1:-1:-1;;;6199:19:7;;;;;;;;;;;4437:582:10;4581:12;4610:7;4605:408;;4633:19;4641:10;4633:7;:19::i;:::-;4605:408;;;4857:17;;:22;:49;;;;-1:-1:-1;;;;;;4883:18:10;;;:23;4857:49;4853:119;;;4933:24;;-1:-1:-1;;;4933:24:10;;-1:-1:-1;;;;;807:32:29;;4933:24:10;;;789:51:29;762:18;;4933:24:10;643:203:29;4853:119:10;-1:-1:-1;4992:10:10;4605:408;4437:582;;;;;:::o;5559:434::-;5690:17;;:21;5686:301;;5894:10;5888:17;5881:4;5869:10;5865:21;5858:48;5686:301;5957:19;;-1:-1:-1;;;5957:19:10;;;;;;;;;;;14:173:29;82:20;;-1:-1:-1;;;;;131:31:29;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;373:9;360:23;350:33;;402:38;436:2;425:9;421:18;402:38;:::i;:::-;392:48;;192:254;;;;;:::o;851:180::-;910:6;963:2;951:9;942:7;938:23;934:32;931:52;;;979:1;976;969:12;931:52;-1:-1:-1;1002:23:29;;851:180;-1:-1:-1;851:180:29:o;1407:127::-;1468:10;1463:3;1459:20;1456:1;1449:31;1499:4;1496:1;1489:15;1523:4;1520:1;1513:15;1539:275;1610:2;1604:9;1675:2;1656:13;;-1:-1:-1;;1652:27:29;1640:40;;-1:-1:-1;;;;;1695:34:29;;1731:22;;;1692:62;1689:88;;;1757:18;;:::i;:::-;1793:2;1786:22;1539:275;;-1:-1:-1;1539:275:29:o;1819:186::-;1867:4;-1:-1:-1;;;;;1892:6:29;1889:30;1886:56;;;1922:18;;:::i;:::-;-1:-1:-1;1988:2:29;1967:15;-1:-1:-1;;1963:29:29;1994:4;1959:40;;1819:186::o;2010:336::-;2074:5;2103:52;2119:35;2147:6;2119:35;:::i;:::-;2103:52;:::i;:::-;2094:61;;2178:6;2171:5;2164:21;2218:3;2209:6;2204:3;2200:16;2197:25;2194:45;;;2235:1;2232;2225:12;2194:45;2284:6;2279:3;2272:4;2265:5;2261:16;2248:43;2338:1;2331:4;2322:6;2315:5;2311:18;2307:29;2300:40;2010:336;;;;;:::o;2351:523::-;2428:6;2436;2489:2;2477:9;2468:7;2464:23;2460:32;2457:52;;;2505:1;2502;2495:12;2457:52;2528:29;2547:9;2528:29;:::i;:::-;2518:39;;2608:2;2597:9;2593:18;2580:32;-1:-1:-1;;;;;2627:6:29;2624:30;2621:50;;;2667:1;2664;2657:12;2621:50;2690:22;;2743:4;2735:13;;2731:27;-1:-1:-1;2721:55:29;;2772:1;2769;2762:12;2721:55;2795:73;2860:7;2855:2;2842:16;2837:2;2833;2829:11;2795:73;:::i;:::-;2785:83;;;2351:523;;;;;:::o;3061:348::-;3113:8;3123:6;3177:3;3170:4;3162:6;3158:17;3154:27;3144:55;;3195:1;3192;3185:12;3144:55;-1:-1:-1;3218:20:29;;-1:-1:-1;;;;;3250:30:29;;3247:50;;;3293:1;3290;3283:12;3247:50;3330:4;3322:6;3318:17;3306:29;;3382:3;3375:4;3366:6;3358;3354:19;3350:30;3347:39;3344:59;;;3399:1;3396;3389:12;3344:59;3061:348;;;;;:::o;3414:183::-;3474:4;-1:-1:-1;;;;;3499:6:29;3496:30;3493:56;;;3529:18;;:::i;:::-;-1:-1:-1;3574:1:29;3570:14;3586:4;3566:25;;3414:183::o;3602:668::-;3656:5;3709:3;3702:4;3694:6;3690:17;3686:27;3676:55;;3727:1;3724;3717:12;3676:55;3763:6;3750:20;3789:4;3813:60;3829:43;3869:2;3829:43;:::i;3813:60::-;3895:3;3919:2;3914:3;3907:15;3947:4;3942:3;3938:14;3931:21;;4004:4;3998:2;3995:1;3991:10;3983:6;3979:23;3975:34;3961:48;;4032:3;4024:6;4021:15;4018:35;;;4049:1;4046;4039:12;4018:35;4085:4;4077:6;4073:17;4099:142;4115:6;4110:3;4107:15;4099:142;;;4181:17;;4169:30;;4219:12;;;;4132;;4099:142;;;-1:-1:-1;4259:5:29;3602:668;-1:-1:-1;;;;;;3602:668:29:o;4275:221::-;4318:5;4371:3;4364:4;4356:6;4352:17;4348:27;4338:55;;4389:1;4386;4379:12;4338:55;4411:79;4486:3;4477:6;4464:20;4457:4;4449:6;4445:17;4411:79;:::i;4501:850::-;4554:5;4607:3;4600:4;4592:6;4588:17;4584:27;4574:55;;4625:1;4622;4615:12;4574:55;4661:6;4648:20;4687:4;4711:60;4727:43;4767:2;4727:43;:::i;4711:60::-;4793:3;4817:2;4812:3;4805:15;4845:4;4840:3;4836:14;4829:21;;4902:4;4896:2;4893:1;4889:10;4881:6;4877:23;4873:34;4859:48;;4930:3;4922:6;4919:15;4916:35;;;4947:1;4944;4937:12;4916:35;4983:4;4975:6;4971:17;4997:325;5013:6;5008:3;5005:15;4997:325;;;5093:3;5080:17;-1:-1:-1;;;;;5134:5:29;5130:30;5123:5;5120:41;5110:139;;5203:1;5232:2;5228;5221:14;5110:139;5262:18;;5300:12;;;;5030;;4997:325;;5356:2165;5662:6;5670;5678;5686;5694;5702;5710;5718;5726;5734;5742:7;5796:3;5784:9;5775:7;5771:23;5767:33;5764:53;;;5813:1;5810;5803:12;5764:53;-1:-1:-1;;;;;5894:2:29;5882:9;5869:23;5866:31;5863:51;;;5910:1;5907;5900:12;5863:51;5949:76;6017:7;6004:9;5991:23;5980:9;5976:39;5949:76;:::i;:::-;6044:8;;-1:-1:-1;6071:8:29;-1:-1:-1;6098:38:29;6132:2;6117:18;;6098:38;:::i;:::-;6088:48;;6185:2;6179;6168:9;6164:18;6151:32;6148:40;6145:60;;;6201:1;6198;6191:12;6145:60;6224:87;6303:7;6296:2;6285:9;6281:18;6268:32;6257:9;6253:48;6224:87;:::i;:::-;6214:97;;6360:2;6354;6343:9;6339:18;6326:32;6323:40;6320:60;;;6376:1;6373;6366:12;6320:60;6399:76;6467:7;6460:2;6449:9;6445:18;6432:32;6421:9;6417:48;6399:76;:::i;:::-;6389:86;;6525:2;6518:3;6507:9;6503:19;6490:33;6487:41;6484:61;;;6541:1;6538;6531:12;6484:61;6564:88;6644:7;6636:3;6625:9;6621:19;6608:33;6597:9;6593:49;6564:88;:::i;:::-;6554:98;;6702:2;6695:3;6684:9;6680:19;6667:33;6664:41;6661:61;;;6718:1;6715;6708:12;6661:61;6741:87;6820:7;6812:3;6801:9;6797:19;6784:33;6773:9;6769:49;6741:87;:::i;:::-;6731:97;;6878:2;6871:3;6860:9;6856:19;6843:33;6840:41;6837:61;;;6894:1;6891;6884:12;6837:61;6917:77;6986:7;6978:3;6967:9;6963:19;6950:33;6939:9;6935:49;6917:77;:::i;:::-;6907:87;;7044:2;7037:3;7026:9;7022:19;7009:33;7006:41;7003:61;;;7060:1;7057;7050:12;7003:61;7083:77;7152:7;7144:3;7133:9;7129:19;7116:33;7105:9;7101:49;7083:77;:::i;:::-;7073:87;;7210:2;7203:3;7192:9;7188:19;7175:33;7172:41;7169:61;;;7226:1;7223;7216:12;7169:61;7249:88;7329:7;7321:3;7310:9;7306:19;7293:33;7282:9;7278:49;7249:88;:::i;:::-;7239:98;;7387:2;7380:3;7369:9;7365:19;7352:33;7349:41;7346:61;;;7403:1;7400;7393:12;7346:61;;7427:88;7507:7;7499:3;7488:9;7484:19;7471:33;7460:9;7456:49;7427:88;:::i;:::-;7416:99;;5356:2165;;;;;;;;;;;;;;:::o;7526:250::-;7611:1;7621:113;7635:6;7632:1;7629:13;7621:113;;;7711:11;;;7705:18;7692:11;;;7685:39;7657:2;7650:10;7621:113;;;-1:-1:-1;;7768:1:29;7750:16;;7743:27;7526:250::o;7781:271::-;7823:3;7861:5;7855:12;7888:6;7883:3;7876:19;7904:76;7973:6;7966:4;7961:3;7957:14;7950:4;7943:5;7939:16;7904:76;:::i;:::-;8034:2;8013:15;-1:-1:-1;;8009:29:29;8000:39;;;;8041:4;7996:50;;7781:271;-1:-1:-1;;7781:271:29:o;8057:220::-;8206:2;8195:9;8188:21;8169:4;8226:45;8267:2;8256:9;8252:18;8244:6;8226:45;:::i;8487:186::-;8546:6;8599:2;8587:9;8578:7;8574:23;8570:32;8567:52;;;8615:1;8612;8605:12;8567:52;8638:29;8657:9;8638:29;:::i;8678:273::-;8746:6;8799:2;8787:9;8778:7;8774:23;8770:32;8767:52;;;8815:1;8812;8805:12;8767:52;8847:9;8841:16;8897:4;8890:5;8886:16;8879:5;8876:27;8866:55;;8917:1;8914;8907:12;8956:348;9158:2;9140:21;;;9197:2;9177:18;;;9170:30;9236:26;9231:2;9216:18;;9209:54;9295:2;9280:18;;8956:348::o;9802:350::-;10004:2;9986:21;;;10043:2;10023:18;;;10016:30;10082:28;10077:2;10062:18;;10055:56;10143:2;10128:18;;9802:350::o;10157:277::-;10224:6;10277:2;10265:9;10256:7;10252:23;10248:32;10245:52;;;10293:1;10290;10283:12;10245:52;10325:9;10319:16;10378:5;10371:13;10364:21;10357:5;10354:32;10344:60;;10400:1;10397;10390:12;10439:648;10519:6;10572:2;10560:9;10551:7;10547:23;10543:32;10540:52;;;10588:1;10585;10578:12;10540:52;10621:9;10615:16;-1:-1:-1;;;;;10646:6:29;10643:30;10640:50;;;10686:1;10683;10676:12;10640:50;10709:22;;10762:4;10754:13;;10750:27;-1:-1:-1;10740:55:29;;10791:1;10788;10781:12;10740:55;10820:2;10814:9;10845:48;10861:31;10889:2;10861:31;:::i;10845:48::-;10916:2;10909:5;10902:17;10956:7;10951:2;10946;10942;10938:11;10934:20;10931:33;10928:53;;;10977:1;10974;10967:12;10928:53;10990:67;11054:2;11049;11042:5;11038:14;11033:2;11029;11025:11;10990:67;:::i;11495:127::-;11556:10;11551:3;11547:20;11544:1;11537:31;11587:4;11584:1;11577:15;11611:4;11608:1;11601:15;11627:439;11680:3;11718:5;11712:12;11745:6;11740:3;11733:19;11771:4;11800;11795:3;11791:14;11784:21;;11839:4;11832:5;11828:16;11862:1;11872:169;11886:6;11883:1;11880:13;11872:169;;;11947:13;;11935:26;;11981:12;;;;12016:15;;;;11908:1;11901:9;11872:169;;;-1:-1:-1;12057:3:29;;11627:439;-1:-1:-1;;;;;11627:439:29:o;12071:1233::-;12487:1;12483;12478:3;12474:11;12470:19;12462:6;12458:32;12447:9;12440:51;12421:4;12510:2;12548:6;12543:2;12532:9;12528:18;12521:34;12591:6;12586:2;12575:9;12571:18;12564:34;12634:3;12629:2;12618:9;12614:18;12607:31;12661:57;12713:3;12702:9;12698:19;12690:6;12661:57;:::i;:::-;12767:9;12759:6;12755:22;12749:3;12738:9;12734:19;12727:51;12801:33;12827:6;12819;12801:33;:::i;:::-;12871:22;;;12865:3;12850:19;;12843:51;12943:13;;12965:22;;;13015:2;13041:15;;;;-1:-1:-1;13003:15:29;;;;13074:1;13084:194;13098:6;13095:1;13092:13;13084:194;;;13163:13;;-1:-1:-1;;;;;13159:38:29;13147:51;;13253:15;;;;13218:12;;;;13120:1;13113:9;13084:194;;;-1:-1:-1;13295:3:29;;12071:1233;-1:-1:-1;;;;;;;;;;;12071:1233:29:o;13309:184::-;13379:6;13432:2;13420:9;13411:7;13407:23;13403:32;13400:52;;;13448:1;13445;13438:12;13400:52;-1:-1:-1;13471:16:29;;13309:184;-1:-1:-1;13309:184:29:o;13498:448::-;13549:3;13587:5;13581:12;13614:6;13609:3;13602:19;13640:4;13669;13664:3;13660:14;13653:21;;13708:4;13701:5;13697:16;13731:1;13741:180;13755:6;13752:1;13749:13;13741:180;;;13820:13;;13835:4;13816:24;13804:37;;13861:12;;;;13896:15;;;;13777:1;13770:9;13741:180;;13951:1694;14504:3;14493:9;14486:22;14467:4;14531:46;14572:3;14561:9;14557:19;14549:6;14531:46;:::i;:::-;14596:2;14646:9;14638:6;14634:22;14629:2;14618:9;14614:18;14607:50;14680:33;14706:6;14698;14680:33;:::i;:::-;14666:47;;14761:9;14753:6;14749:22;14744:2;14733:9;14729:18;14722:50;14795:33;14821:6;14813;14795:33;:::i;:::-;14864:22;;;14859:2;14844:18;;14837:50;14936:13;;14958:22;;;15008:2;15034:15;;;;-1:-1:-1;14996:15:29;;;;15067:1;15077:195;15091:6;15088:1;15085:13;15077:195;;;15156:13;;-1:-1:-1;;;;;15152:39:29;15140:52;;15247:15;;;;15212:12;;;;15188:1;15106:9;15077:195;;;15081:3;;15318:9;15313:3;15309:19;15303:3;15292:9;15288:19;15281:48;15352:39;15387:3;15379:6;15352:39;:::i;:::-;15338:53;;;;15440:9;15432:6;15428:22;15422:3;15411:9;15407:19;15400:51;15474:44;15511:6;15503;15474:44;:::i;:::-;15460:58;;15567:9;15559:6;15555:22;15549:3;15538:9;15534:19;15527:51;15595:44;15632:6;15624;15595:44;:::i;:::-;15587:52;13951:1694;-1:-1:-1;;;;;;;;;;13951:1694:29:o;15650:289::-;15781:3;15819:6;15813:13;15835:66;15894:6;15889:3;15882:4;15874:6;15870:17;15835:66;:::i;:::-;15917:16;;;;;15650:289;-1:-1:-1;;15650:289:29:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220849ece13109b49479d33c8874f88fa2b175859b9e781a27b931d82cb09d43ad864736f6c63430008160033","offset":7841}},"immutableReferences":{"482":[{"start":3589,"length":32},{"start":3630,"length":32},{"start":4119,"length":32}]},"transformations":[{"id":"482","type":"replace","offset":3589,"reason":"immutable"},{"id":"482","type":"replace","offset":3630,"reason":"immutable"},{"id":"482","type":"replace","offset":4119,"reason":"immutable"}],"transformationValues":{"immutables":{"482":"0x0000000000000000000000004ef34664ccbf1979180a9f3cb21f033e069713ba"}}},"deployment":{"transactionHash":"0xf419b941b39c6d338f0805343e2575fb73c6782a2701be9e13f5bf9dde454bbb","blockNumber":"25590645","transactionIndex":"49","deployer":"0x0c81357A047581bF078a323821226698d39618b8"},"sources":{"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable\n    struct OwnableStorage {\n        address _owner;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Ownable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;\n\n    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {\n        assembly {\n            $.slot := OwnableStorageLocation\n        }\n    }\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    function __Ownable_init(address initialOwner) internal onlyInitializing {\n        __Ownable_init_unchained(initialOwner);\n    }\n\n    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        OwnableStorage storage $ = _getOwnableStorage();\n        return $._owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        OwnableStorage storage $ = _getOwnableStorage();\n        address oldOwner = $._owner;\n        $._owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Storage of the initializable contract.\n     *\n     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\n     * when using with upgradeable contracts.\n     *\n     * @custom:storage-location erc7201:openzeppelin.storage.Initializable\n     */\n    struct InitializableStorage {\n        /**\n         * @dev Indicates that the contract has been initialized.\n         */\n        uint64 _initialized;\n        /**\n         * @dev Indicates that the contract is in the process of being initialized.\n         */\n        bool _initializing;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Initializable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\n\n    /**\n     * @dev The contract is already initialized.\n     */\n    error InvalidInitialization();\n\n    /**\n     * @dev The contract is not initializing.\n     */\n    error NotInitializing();\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint64 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\n     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\n     * production.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        // Cache values to avoid duplicated sloads\n        bool isTopLevelCall = !$._initializing;\n        uint64 initialized = $._initialized;\n\n        // Allowed calls:\n        // - initialSetup: the contract is not in the initializing state and no previous version was\n        //                 initialized\n        // - construction: the contract is initialized at version 1 (no reinitialization) and the\n        //                 current contract is just being deployed\n        bool initialSetup = initialized == 0 && isTopLevelCall;\n        bool construction = initialized == 1 && address(this).code.length == 0;\n\n        if (!initialSetup && !construction) {\n            revert InvalidInitialization();\n        }\n        $._initialized = 1;\n        if (isTopLevelCall) {\n            $._initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            $._initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint64 version) {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing || $._initialized >= version) {\n            revert InvalidInitialization();\n        }\n        $._initialized = version;\n        $._initializing = true;\n        _;\n        $._initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        _checkInitializing();\n        _;\n    }\n\n    /**\n     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\n     */\n    function _checkInitializing() internal view virtual {\n        if (!_isInitializing()) {\n            revert NotInitializing();\n        }\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing) {\n            revert InvalidInitialization();\n        }\n        if ($._initialized != type(uint64).max) {\n            $._initialized = type(uint64).max;\n            emit Initialized(type(uint64).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint64) {\n        return _getInitializableStorage()._initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _getInitializableStorage()._initializing;\n    }\n\n    /**\n     * @dev Pointer to storage slot. Allows integrators to override it with a custom storage location.\n     *\n     * NOTE: Consider following the ERC-7201 formula to derive storage locations.\n     */\n    function _initializableStorageSlot() internal pure virtual returns (bytes32) {\n        return INITIALIZABLE_STORAGE;\n    }\n\n    /**\n     * @dev Returns a pointer to the storage namespace.\n     */\n    // solhint-disable-next-line var-name-mixedcase\n    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\n        bytes32 slot = _initializableStorageSlot();\n        assembly {\n            $.slot := slot\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.22;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\nimport {Initializable} from \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {\n    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n    address private immutable __self = address(this);\n\n    /**\n     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\n     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\n     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\n     * If the getter returns `\"5.0.0\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\n     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\n     * during an upgrade.\n     */\n    string public constant UPGRADE_INTERFACE_VERSION = \"5.0.0\";\n\n    /**\n     * @dev The call is from an unauthorized context.\n     */\n    error UUPSUnauthorizedCallContext();\n\n    /**\n     * @dev The storage `slot` is unsupported as a UUID.\n     */\n    error UUPSUnsupportedProxiableUUID(bytes32 slot);\n\n    /**\n     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n     * a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case\n     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n     * function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n     * fail.\n     */\n    modifier onlyProxy() {\n        _checkProxy();\n        _;\n    }\n\n    /**\n     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n     * callable on the implementing contract but not through proxies.\n     */\n    modifier notDelegated() {\n        _checkNotDelegated();\n        _;\n    }\n\n    function __UUPSUpgradeable_init() internal onlyInitializing {\n    }\n\n    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the\n     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n     */\n    function proxiableUUID() external view virtual notDelegated returns (bytes32) {\n        return ERC1967Utils.IMPLEMENTATION_SLOT;\n    }\n\n    /**\n     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n     * encoded in `data`.\n     *\n     * Calls {_authorizeUpgrade}.\n     *\n     * Emits an {Upgraded} event.\n     *\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\n        _authorizeUpgrade(newImplementation);\n        _upgradeToAndCallUUPS(newImplementation, data);\n    }\n\n    /**\n     * @dev Reverts if the execution is not performed via delegatecall or the execution\n     * context is not of a proxy with an ERC-1967 compliant implementation pointing to self.\n     */\n    function _checkProxy() internal view virtual {\n        if (\n            address(this) == __self || // Must be called through delegatecall\n            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\n        ) {\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Reverts if the execution is performed via delegatecall.\n     * See {notDelegated}.\n     */\n    function _checkNotDelegated() internal view virtual {\n        if (address(this) != __self) {\n            // Must not be called through delegatecall\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n     * {upgradeToAndCall}.\n     *\n     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n     *\n     * ```solidity\n     * function _authorizeUpgrade(address) internal onlyOwner {}\n     * ```\n     */\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /**\n     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\n     *\n     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\n     * is expected to be the implementation slot in ERC-1967.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\n        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\n                revert UUPSUnsupportedProxiableUUID(slot);\n            }\n            ERC1967Utils.upgradeToAndCall(newImplementation, data);\n        } catch {\n            // The implementation is not UUPS\n            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC1822.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n    /**\n     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n     * address.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy.\n     */\n    function proxiableUUID() external view returns (bytes32);\n}\n"},"@openzeppelin/contracts/interfaces/IERC1967.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1967.sol)\n\npragma solidity >=0.4.11;\n\n/**\n * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.\n */\ninterface IERC1967 {\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\n\n    /**\n     * @dev Emitted when the beacon is changed.\n     */\n    event BeaconUpgraded(address indexed beacon);\n}\n"},"@openzeppelin/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"@openzeppelin/contracts/proxy/beacon/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (proxy/beacon/IBeacon.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n    /**\n     * @dev Must return an address that can be used as a delegate call target.\n     *\n     * {UpgradeableBeacon} will check that this address is a contract.\n     */\n    function implementation() external view returns (address);\n}\n"},"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (proxy/ERC1967/ERC1967Utils.sol)\n\npragma solidity ^0.8.21;\n\nimport {IBeacon} from \"../beacon/IBeacon.sol\";\nimport {IERC1967} from \"../../interfaces/IERC1967.sol\";\nimport {Address} from \"../../utils/Address.sol\";\nimport {StorageSlot} from \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This library provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots.\n */\nlibrary ERC1967Utils {\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev The `implementation` of the proxy is invalid.\n     */\n    error ERC1967InvalidImplementation(address implementation);\n\n    /**\n     * @dev The `admin` of the proxy is invalid.\n     */\n    error ERC1967InvalidAdmin(address admin);\n\n    /**\n     * @dev The `beacon` of the proxy is invalid.\n     */\n    error ERC1967InvalidBeacon(address beacon);\n\n    /**\n     * @dev An upgrade function sees `msg.value > 0` that may be lost.\n     */\n    error ERC1967NonPayable();\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function getImplementation() internal view returns (address) {\n        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the ERC-1967 implementation slot.\n     */\n    function _setImplementation(address newImplementation) private {\n        if (newImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(newImplementation);\n        }\n        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\n    }\n\n    /**\n     * @dev Performs implementation upgrade with additional setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) internal {\n        _setImplementation(newImplementation);\n        emit IERC1967.Upgraded(newImplementation);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(newImplementation, data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Storage slot with the admin of the contract.\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Returns the current admin.\n     *\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using\n     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n     */\n    function getAdmin() internal view returns (address) {\n        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the ERC-1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        if (newAdmin == address(0)) {\n            revert ERC1967InvalidAdmin(address(0));\n        }\n        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {IERC1967-AdminChanged} event.\n     */\n    function changeAdmin(address newAdmin) internal {\n        emit IERC1967.AdminChanged(getAdmin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n     * This is the keccak-256 hash of \"eip1967.proxy.beacon\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n    /**\n     * @dev Returns the current beacon.\n     */\n    function getBeacon() internal view returns (address) {\n        return StorageSlot.getAddressSlot(BEACON_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new beacon in the ERC-1967 beacon slot.\n     */\n    function _setBeacon(address newBeacon) private {\n        if (newBeacon.code.length == 0) {\n            revert ERC1967InvalidBeacon(newBeacon);\n        }\n\n        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\n\n        address beaconImplementation = IBeacon(newBeacon).implementation();\n        if (beaconImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(beaconImplementation);\n        }\n    }\n\n    /**\n     * @dev Change the beacon and trigger a setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-BeaconUpgraded} event.\n     *\n     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\n     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\n     * efficiency.\n     */\n    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\n        _setBeacon(newBeacon);\n        emit IERC1967.BeaconUpgraded(newBeacon);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\n     * if an upgrade doesn't perform an initialization call.\n     */\n    function _checkNonPayable() private {\n        if (msg.value > 0) {\n            revert ERC1967NonPayable();\n        }\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n\n        (bool success, bytes memory returndata) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            _revert(returndata);\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {Errors.FailedCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\n     * of an unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {Errors.FailedCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            assembly (\"memory-safe\") {\n                revert(add(returndata, 0x20), mload(returndata))\n            }\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/Errors.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},"@openzeppelin/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct Int256Slot {\n        int256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"contracts/compliance/IDSBlackListManager.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\n/**\n * @title Interface for BlackListManager\n *\n * This interface defines functionality for managing blacklisted wallets.\n * Blacklisted wallets are prevented from receiving tokens through transfers or issuances.\n */\nabstract contract IDSBlackListManager {\n    function initialize() public virtual;\n\n    // Events\n    event WalletAddedToBlacklist(address indexed wallet, string reason, address indexed admin);\n    event WalletRemovedFromBlacklist(address indexed wallet, address indexed admin);\n\n    // Custom errors\n    /// @dev Thrown when a wallet is already blacklisted\n    /// @custom:selector 0xb59c1958\n    error WalletAlreadyBlacklisted();\n    /// @dev Thrown when a wallet is not blacklisted\n    /// @custom:selector 0xfae0e716\n    error WalletNotBlacklisted();\n    /// @dev Thrown when the zero address is used\n    /// @custom:selector 0x14c880ca\n    error ZeroAddressInvalid();\n    /// @dev Thrown when the lengths of the arrays do not match\n    /// @custom:selector 0xfc235960\n    error ArraysLengthMismatch();\n\n    // View functions\n    function isBlacklisted(address _wallet) external view virtual returns (bool);\n\n    function getBlacklistedWalletsCount() external view virtual returns (uint256);\n\n    function getBlacklistedWallets() external view virtual returns (address[] memory);\n\n    function getBlacklistReason(address _wallet) external view virtual returns (string memory);\n\n    // State-changing functions\n    function addToBlacklist(address _wallet, string calldata _reason) external virtual returns (bool);\n\n    function removeFromBlacklist(address _wallet) external virtual returns (bool);\n}\n"},"contracts/compliance/IDSComplianceConfigurationService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSComplianceConfigurationService {\n\n    function initialize() public virtual;\n\n    event DSComplianceUIntRuleSet(string ruleName, uint256 prevValue, uint256 newValue);\n    event DSComplianceBoolRuleSet(string ruleName, bool prevValue, bool newValue);\n    event DSComplianceStringToUIntMapRuleSet(string ruleName, string keyValue, uint256 prevValue, uint256 newValue);\n\n    function getCountryCompliance(string calldata _country) public view virtual returns (uint256);\n\n    function setCountriesCompliance(string[] calldata _countries, uint256[] calldata _values) public virtual;\n\n    function setCountryCompliance(\n        string calldata _country,\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getTotalInvestorsLimit() public view virtual returns (uint256);\n\n    function setTotalInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinUSTokens() public view virtual returns (uint256);\n\n    function setMinUSTokens(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinEUTokens() public view virtual returns (uint256);\n\n    function setMinEUTokens(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getUSInvestorsLimit() public view virtual returns (uint256);\n\n    function setUSInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getJPInvestorsLimit() public view virtual returns (uint256);\n\n    function setJPInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getUSAccreditedInvestorsLimit() public view virtual returns (uint256);\n\n    function setUSAccreditedInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getNonAccreditedInvestorsLimit() public view virtual returns (uint256);\n\n    function setNonAccreditedInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMaxUSInvestorsPercentage() public view virtual returns (uint256);\n\n    function setMaxUSInvestorsPercentage(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getBlockFlowbackEndTime() public view virtual returns (uint256);\n\n    function setBlockFlowbackEndTime(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getNonUSLockPeriod() public view virtual returns (uint256);\n\n    function setNonUSLockPeriod(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinimumTotalInvestors() public view virtual returns (uint256);\n\n    function setMinimumTotalInvestors(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinimumHoldingsPerInvestor() public view virtual returns (uint256);\n\n    function setMinimumHoldingsPerInvestor(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMaximumHoldingsPerInvestor() public view virtual returns (uint256);\n\n    function setMaximumHoldingsPerInvestor(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getEURetailInvestorsLimit() public view virtual returns (uint256);\n\n    function setEURetailInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getUSLockPeriod() public view virtual returns (uint256);\n\n    function setUSLockPeriod(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getForceFullTransfer() public view virtual returns (bool);\n\n    function setForceFullTransfer(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getForceAccredited() public view virtual returns (bool);\n\n    function setForceAccredited(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function setForceAccreditedUS(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getForceAccreditedUS() public view virtual returns (bool);\n\n    function setWorldWideForceFullTransfer(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getWorldWideForceFullTransfer() public view virtual returns (bool);\n\n    function getAuthorizedSecurities() public view virtual returns (uint256);\n\n    function setAuthorizedSecurities(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getDisallowBackDating() public view virtual returns (bool);\n\n    function setDisallowBackDating(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function setAll(\n        uint256[] calldata _uint_values,\n        bool[] calldata _bool_values /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getAll() public view virtual returns (uint256[] memory, bool[] memory);\n}\n"},"contracts/compliance/IDSComplianceService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSComplianceService {\n\n    uint256 internal constant NONE = 0;\n    uint256 internal constant US = 1;\n    uint256 internal constant EU = 2;\n    uint256 internal constant FORBIDDEN = 4;\n    uint256 internal constant JP = 8;\n    string internal constant TOKEN_PAUSED = \"Token Paused\";\n    string internal constant NOT_ENOUGH_TOKENS = \"Not Enough Tokens\";\n    string internal constant TOKENS_LOCKED = \"Tokens Locked\";\n    string internal constant WALLET_NOT_IN_REGISTRY_SERVICE = \"Wallet not in registry Service\";\n    string internal constant DESTINATION_RESTRICTED = \"Destination restricted\";\n    string internal constant VALID = \"Valid\";\n    string internal constant HOLD_UP = \"Under lock-up\";\n    string internal constant ONLY_FULL_TRANSFER = \"Only Full Transfer\";\n    string internal constant FLOWBACK = \"Flowback\";\n    string internal constant MAX_INVESTORS_IN_CATEGORY = \"Max Investors in category\";\n    string internal constant AMOUNT_OF_TOKENS_UNDER_MIN = \"Amount of tokens under min\";\n    string internal constant AMOUNT_OF_TOKENS_ABOVE_MAX = \"Amount of tokens above max\";\n    string internal constant ONLY_ACCREDITED = \"Only accredited\";\n    string internal constant ONLY_US_ACCREDITED = \"Only us accredited\";\n    string internal constant NOT_ENOUGH_INVESTORS = \"Not enough investors\";\n    string internal constant MAX_AUTHORIZED_SECURITIES_EXCEEDED = \"Max authorized securities exceeded\";\n\n    function initialize() public virtual;\n\n    function adjustInvestorCountsAfterCountryChange(\n        string memory _id,\n        string memory _country,\n        string memory _prevCountry\n    ) public virtual returns (bool);\n\n    //*****************************************\n    // TOKEN ACTION VALIDATIONS\n    //*****************************************\n\n    function validateTransfer(\n        address _from,\n        address _to,\n        uint256 _value /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function validateTransfer(\n        address _from,\n        address _to,\n        uint256 _value, /*onlyToken*/\n        bool _pausedToken,\n        uint256 _balanceFrom\n    ) public virtual returns (bool);\n\n    function validateIssuance(\n        address _to,\n        uint256 _value,\n        uint256 _issuanceTime /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function validateBurn(\n        address _who,\n        uint256 _value /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function validateSeize(\n        address _from,\n        address _to,\n        uint256 _value /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function preIssuanceCheck(address _to, uint256 _value) public view virtual returns (uint256 code, string memory reason);\n\n    function preTransferCheck(\n        address _from,\n        address _to,\n        uint256 _value\n    ) public view virtual returns (uint256 code, string memory reason);\n\n    function newPreTransferCheck(\n        address _from,\n        address _to,\n        uint256 _value,\n        uint256 _balanceFrom,\n        bool _pausedToken\n    ) public view virtual returns (uint256 code, string memory reason);\n\n    function preInternalTransferCheck(\n        address _from,\n        address _to,\n        uint256 _value\n    ) public view virtual returns (uint256 code, string memory reason);\n\n    function validateIssuanceTime(uint256 _issuanceTime) public view virtual returns (uint256 issuanceTime);\n\n    function getComplianceTransferableTokens(\n        address _who,\n        uint256 _time,\n        uint64 _lockTime\n    ) public view virtual returns (uint256);\n}\n"},"contracts/compliance/IDSLockManager.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSLockManager {\n\n    function initialize() public virtual;\n\n    modifier validLock(uint256 _valueLocked, uint256 _releaseTime) {\n        require(_valueLocked > 0, \"Value is zero\");\n        require(_releaseTime == 0 || _releaseTime > uint256(block.timestamp), \"Release time is in the past\");\n        _;\n    }\n\n    event Locked(address indexed who, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n    event Unlocked(address indexed who, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n\n    event HolderLocked(string holderId, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n    event HolderUnlocked(string holderId, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n    /**\n     * @dev creates a lock record for wallet address\n     * @param _to address to lock the tokens at\n     * @param _valueLocked value of tokens to lock\n     * @param _reason reason for lock\n     * @param _releaseTime timestamp to release the lock (or 0 for locks which can only released by an unlockTokens call)\n     * Note: The user MAY have at a certain time more locked tokens than actual tokens\n     */\n\n    function addManualLockRecord(\n        address _to,\n        uint256 _valueLocked,\n        string calldata _reason,\n        uint256 _releaseTime /*issuerOrAboveOrToken*/\n    ) public virtual;\n\n    /**\n     * @dev creates a lock record for investor Id\n     * @param _investor investor id to lock the tokens at\n     * @param _valueLocked value of tokens to lock\n     * @param _reasonCode reason code for lock\n     * @param _reasonString reason for lock\n     * @param _releaseTime timestamp to release the lock (or 0 for locks which can only released by an unlockTokens call)\n     * Note: The user MAY have at a certain time more locked tokens than actual tokens\n     */\n\n    function createLockForInvestor(\n        string memory _investor,\n        uint256 _valueLocked,\n        uint256 _reasonCode,\n        string calldata _reasonString,\n        uint256 _releaseTime /*onlyIssuerOrAboveOrToken*/\n    ) public virtual;\n\n    /**\n     * @dev Releases a specific lock record for a wallet\n     * @param _to address to release the tokens for\n     * @param _lockIndex the index of the lock to remove\n     *\n     * note - this may change the order of the locks on an address, so if iterating the iteration should be restarted.\n     * @return true on success\n     */\n    function removeLockRecord(\n        address _to,\n        uint256 _lockIndex /*issuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Releases a specific lock record for a investor\n     * @param _investorId investor id to release the tokens for\n     * @param _lockIndex the index of the lock to remove\n     *\n     * note - this may change the order of the locks on an address, so if iterating the iteration should be restarted.\n     * @return true on success\n     */\n    function removeLockRecordForInvestor(\n        string memory _investorId,\n        uint256 _lockIndex /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Get number of locks currently associated with an address\n     * @param _who address to get count for\n     *\n     * @return number of locks\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n    function lockCount(address _who) public view virtual returns (uint256);\n\n    /**\n     * @dev Get number of locks currently associated with a investor\n     * @param _investorId investor id to get count for\n     *\n     * @return number of locks\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n\n    function lockCountForInvestor(string calldata _investorId) public view virtual returns (uint256);\n\n    /**\n     * @dev Get details of a specific lock associated with an address\n     * can be used to iterate through the locks of a user\n     * @param _who address to get token lock for\n     * @param _lockIndex the 0 based index of the lock.\n     * @return reasonCode the reason code\n     * @return reasonString the reason for the lock\n     * @return value the value of tokens locked\n     * @return autoReleaseTime the timestamp in which the lock will be inactive (or 0 if it's always active until removed)\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n    function lockInfo(address _who, uint256 _lockIndex) public view virtual returns (uint256 reasonCode, string memory reasonString, uint256 value, uint256 autoReleaseTime);\n\n    /**\n     * @dev Get details of a specific lock associated with a investor\n     * can be used to iterate through the locks of a user\n     * @param _investorId investorId to get token lock for\n     * @param _lockIndex the 0 based index of the lock.\n     * @return reasonCode the reason code\n     * @return reasonString the reason for the lock\n     * @return value the value of tokens locked\n     * @return autoReleaseTime the timestamp in which the lock will be inactive (or 0 if it's always active until removed)\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n    function lockInfoForInvestor(\n        string memory _investorId,\n        uint256 _lockIndex\n    ) public view virtual  returns (uint256 reasonCode, string memory reasonString, uint256 value, uint256 autoReleaseTime);\n\n    /**\n     * @dev get total number of transferable tokens for a wallet, at a certain time\n     * @param _who address to get number of transferable tokens for\n     * @param _time time to calculate for\n     */\n    function getTransferableTokens(address _who, uint256 _time) public view virtual returns (uint256);\n\n    /**\n     * @dev get total number of transferable tokens for a investor, at a certain time\n     * @param _investorId investor id\n     * @param _time time to calculate for\n     */\n    function getTransferableTokensForInvestor(string memory _investorId, uint256 _time) public view virtual returns (uint256);\n\n    /**\n     * @dev pause investor\n     * @param _investorId investor id\n     */\n    function lockInvestor(\n        string calldata _investorId /*issuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev unpauses investor\n     * @param _investorId investor id\n     */\n    function unlockInvestor(\n        string calldata _investorId /*issuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Returns true if paused, otherwise false\n     * @param _investorId investor id\n     */\n    function isInvestorLocked(string calldata _investorId) public view virtual returns (bool);\n\n    /**\n     * @dev set investor to liquidate only mode\n     * @param _investorId investor id\n     * @param _enabled true to enable, false to disable\n     */\n    function setInvestorLiquidateOnly(string memory _investorId, bool _enabled) public virtual returns (bool);\n\n    /**\n     * @dev Returns true if the investor is in liquidate only mode\n     * @param _investorId investor id\n     */\n    function isInvestorLiquidateOnly(string calldata _investorId) public view virtual returns (bool);\n}\n"},"contracts/compliance/IDSWalletManager.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSWalletManager {\n\n    function initialize() public virtual;\n\n    // Special wallets constants\n    uint8 public constant NONE = 0;\n    uint8 public constant ISSUER = 1;\n    uint8 public constant PLATFORM = 2;\n    uint8 public constant EXCHANGE = 4;\n\n    /**\n     * @dev should be emitted when a special wallet is added.\n     */\n    event DSWalletManagerSpecialWalletAdded(address wallet, uint8 walletType, address sender);\n    /**\n     * @dev should be emitted when a special wallet is removed.\n     */\n    event DSWalletManagerSpecialWalletRemoved(address wallet, uint8 walletType, address sender);\n    /**\n     * @dev should be emitted when the number of reserved slots is set for a wallet.\n     */\n    event DSWalletManagerReservedSlotsSet(address wallet, string country, uint8 accreditationStatus, uint256 slots, address sender);\n\n    /**\n     * @dev Sets a wallet to be an special wallet. (internal)\n     * @param _wallet The address of the wallet.\n     * @param _type The type of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setSpecialWallet(address _wallet, uint8 _type) internal virtual returns (bool);\n\n    /**\n     * @dev gets a wallet type\n     * @param _wallet the address of the wallet to check.\n     */\n    function getWalletType(address _wallet) public view virtual returns (uint8);\n\n    /**\n     * @dev Returns true if it is platform wallet\n     * @param _wallet the address of the wallet to check.\n     */\n    function isPlatformWallet(address _wallet) external view virtual returns (bool);\n\n    /**\n     * @dev Returns true if it is special wallet\n     * @param _wallet the address of the wallet to check.\n     */\n    function isSpecialWallet(address _wallet) external view virtual returns (bool);\n\n    /**\n     * @dev Returns true if it is issuer special wallet\n     * @param _wallet the address of the wallet to check.\n     */\n    function isIssuerSpecialWallet(address _wallet) external view virtual returns (bool);\n\n    /**\n     * @dev Sets a wallet to be an issuer wallet.\n     * @param _wallet The address of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addIssuerWallet(\n        address _wallet /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Sets an array of wallets to be issuer wallets.\n     * @param _wallets The address of the wallets.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addIssuerWallets(address[] calldata _wallets) public virtual returns (bool);\n\n    /**\n     * @dev Sets a wallet to be a platform wallet.\n     * @param _wallet The address of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addPlatformWallet(\n        address _wallet /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Sets an array of wallets to be platforms wallet.\n     * @param _wallets The address of the wallets.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addPlatformWallets(address[] calldata _wallets) public virtual returns (bool);\n\n    /**\n     * @dev Sets a wallet to be an exchange wallet.\n     * @param _wallet The address of the wallet.\n     * @param _owner The address of the owner.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addExchangeWallet(address _wallet, address _owner) public virtual returns (bool);\n\n    /**\n     * @dev Removes a special wallet.\n     * @param _wallet The address of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function removeSpecialWallet(\n        address _wallet /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n}\n"},"contracts/data-stores/ServiceConsumerDataStore.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\ncontract ServiceConsumerDataStore {\n\n    mapping(uint256 serviceId => address service) internal services;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"contracts/issuance/IDSTokenIssuer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSTokenIssuer {\n\n    function initialize() public virtual;\n\n    function issueTokens(\n        string calldata _id,\n        address _to,\n        uint256[] memory _issuanceValues,\n        string memory _reason,\n        uint256[] memory _locksValues,\n        uint64[] memory _lockReleaseTimes,\n        string memory _collisionHash,\n        string memory _country,\n        uint256[] memory attributeValues,\n        uint256[] memory attributeExpirations /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n}\n"},"contracts/issuance/TokenIssuer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {IDSTokenIssuer} from \"./IDSTokenIssuer.sol\";\nimport {IDSRegistryService} from \"../registry/IDSRegistryService.sol\";\nimport {BaseDSContract} from \"../utils/BaseDSContract.sol\";\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\ncontract TokenIssuer is IDSTokenIssuer, BaseDSContract {\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n\n    function initialize() public override onlyProxy initializer {\n        __BaseDSContract_init();\n    }\n\n    function issueTokens(\n        string calldata _id,\n        address _to,\n        uint256[] memory _issuanceValues,\n        string memory _reason,\n        uint256[] memory _locksValues,\n        uint64[] memory _lockReleaseTimes,\n        string memory _collisionHash,\n        string memory _country,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations\n    ) public override onlyIssuerOrAbove returns (bool) {\n        require(_issuanceValues.length == 2, \"Wrong length of parameters\");\n        require(_attributeValues.length == _attributeExpirations.length, \"Wrong length of parameters\");\n        require(_locksValues.length == _lockReleaseTimes.length, \"Wrong length of parameters\");\n        if (getRegistryService().isWallet(_to)) {\n            require(CommonUtils.isEqualString(getRegistryService().getInvestor(_to), _id), \"Wallet does not belong to investor\");\n        } else {\n            registerInvestor(_id, _to, _collisionHash, _country, _attributeValues, _attributeExpirations);\n        }\n\n        getToken().issueTokensWithMultipleLocks(_to, _issuanceValues[0], _issuanceValues[1], _locksValues, _reason, _lockReleaseTimes);\n\n        return true;\n    }\n\n    function registerInvestor(\n        string memory _id,\n        address _wallet,\n        string memory _collisionHash,\n        string memory _country,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations\n    ) private {\n        IDSRegistryService registryService = getRegistryService();\n        uint8 EXPECTED_NUM_ATTRIBUTES = 3;\n        // all parameters required or none for Token Issuer\n        require(_attributeValues.length == 0 || _attributeValues.length == EXPECTED_NUM_ATTRIBUTES, \"Wrong length of parameters\");\n        uint8[] memory attributesIds;\n        if (_attributeValues.length == EXPECTED_NUM_ATTRIBUTES) {\n            attributesIds = new uint8[](EXPECTED_NUM_ATTRIBUTES);\n            attributesIds[0] = registryService.KYC_APPROVED();\n            attributesIds[1] = registryService.ACCREDITED();\n            attributesIds[2] = registryService.QUALIFIED();\n        } else {\n            attributesIds = new uint8[](0);\n        }\n        address[] memory investorWallets = new address[](1);\n        investorWallets[0] = _wallet;\n        registryService.updateInvestor(\n            _id,\n            _collisionHash,\n            _country,\n            investorWallets,\n            attributesIds,\n            _attributeValues,\n            _attributeExpirations\n        );\n    }\n}\n"},"contracts/rebasing/ISecuritizeRebasingProvider.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\n/**\n * @title ISecuritizeRebasingProvider\n * @dev Defines a common interface to get Rebasing multiplier\n */\ninterface ISecuritizeRebasingProvider {\n    /**\n     * @dev Emitted when owner updates multiplier.\n     * @param oldValue Old multiplier value\n     * @param newValue New multiplier value\n     */\n    event RebasingRateUpdated(uint256 oldValue, uint256 newValue);\n\n    /**\n     * @dev Proxy Initializer.\n     * @param _multiplier the initial rebasing multiplier value\n     * @param _tokenDecimals the token decimals for conversion calculations\n    */\n    function initialize(uint256 _multiplier, uint8 _tokenDecimals) external;\n\n\n    /**\n     * @dev Set rebasing multiplier. It is expressed with the same decimal numbers as stable coin\n     */\n    function setMultiplier(uint256 _multiplier) external;\n\n    /**\n     * @dev The asset:rebasing multiplier.\n     * @return The asset:rebasing multiplier.\n     */\n    function multiplier() external view returns (uint256);\n\n    /**\n     * @dev Convert tokens to shares using the current multiplier and token decimals.\n     * @param _tokens The amount of tokens to convert\n     * @return shares The equivalent amount in shares\n     */\n    function convertTokensToShares(uint256 _tokens) external view returns (uint256 shares);\n\n    /**\n     * @dev Convert shares to tokens using the current multiplier and token decimals.\n     * @param _shares The amount of shares to convert\n     * @return tokens The equivalent amount in tokens\n     */\n    function convertSharesToTokens(uint256 _shares) external view returns (uint256 tokens);\n}\n"},"contracts/registry/IDSRegistryService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\nabstract contract IDSRegistryService {\n\n    function initialize() public virtual;\n\n    event DSRegistryServiceInvestorAdded(string investorId, address sender);\n    event DSRegistryServiceInvestorRemoved(string investorId, address sender);\n    event DSRegistryServiceInvestorCountryChanged(string investorId, string country, address sender);\n    event DSRegistryServiceInvestorAttributeChanged(string investorId, uint256 attributeId, uint256 value, uint256 expiry, string proofHash, address sender);\n    event DSRegistryServiceWalletAdded(address wallet, string investorId, address sender);\n    event DSRegistryServiceWalletRemoved(address wallet, string investorId, address sender);\n\n    uint8 public constant NONE = 0;\n    uint8 public constant KYC_APPROVED = 1;\n    uint8 public constant ACCREDITED = 2;\n    uint8 public constant QUALIFIED = 4;\n    uint8 public constant PROFESSIONAL = 8;\n\n    uint8 public constant PENDING = 0;\n    uint8 public constant APPROVED = 1;\n    uint8 public constant REJECTED = 2;\n\n    uint8 public constant EXCHANGE = 4;\n\n    modifier investorExists(string memory _id) {\n        require(isInvestor(_id), \"Unknown investor\");\n        _;\n    }\n\n    modifier newInvestor(string memory _id) {\n        require(!CommonUtils.isEmptyString(_id), \"Investor id must not be empty\");\n        require(!isInvestor(_id), \"Investor already exists\");\n        _;\n    }\n\n    modifier walletExists(address _address) {\n        require(isWallet(_address), \"Unknown wallet\");\n        _;\n    }\n\n    modifier newWallet(address _address) {\n        require(!isWallet(_address), \"Wallet already exists\");\n        _;\n    }\n\n    modifier walletBelongsToInvestor(address _address, string memory _id) {\n        require(CommonUtils.isEqualString(getInvestor(_address), _id), \"Wallet does not belong to investor\");\n        _;\n    }\n\n    function registerInvestor(\n        string calldata _id,\n        string calldata _collision_hash /*onlyExchangeOrAbove newInvestor(_id)*/\n    ) public virtual returns (bool);\n\n    function updateInvestor(\n        string calldata _id,\n        string calldata _collisionHash,\n        string memory _country,\n        address[] memory _wallets,\n        uint8[] memory _attributeIds,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    function removeInvestor(\n        string calldata _id /*onlyExchangeOrAbove investorExists(_id)*/\n    ) public virtual returns (bool);\n\n    function setCountry(\n        string calldata _id,\n        string memory _country /*onlyExchangeOrAbove investorExists(_id)*/\n    ) public virtual returns (bool);\n\n    function getCountry(string memory _id) public view virtual returns (string memory);\n\n    function getCollisionHash(string calldata _id) public view virtual returns (string memory);\n\n    function setAttribute(\n        string calldata _id,\n        uint8 _attributeId,\n        uint256 _value,\n        uint256 _expiry,\n        string memory _proofHash /*onlyExchangeOrAbove investorExists(_id)*/\n    ) public virtual returns (bool);\n\n    function getAttributeValue(string memory _id, uint8 _attributeId) public view virtual returns (uint256);\n\n    function getAttributeExpiry(string memory _id, uint8 _attributeId) public view virtual returns (uint256);\n\n    function getAttributeProofHash(string memory _id, uint8 _attributeId) public view virtual returns (string memory);\n\n    function addWallet(\n        address _address,\n        string memory _id /*onlyExchangeOrAbove newWallet(_address)*/\n    ) public virtual returns (bool);\n\n\n    function removeWallet(\n        address _address,\n        string memory _id /*onlyExchangeOrAbove walletExists walletBelongsToInvestor(_address, _id)*/\n    ) public virtual returns (bool);\n\n    function getInvestor(address _address) public view virtual returns (string memory);\n\n    function getInvestorDetails(address _address) public view virtual returns (string memory, string memory);\n\n    function getInvestorDetailsFull(string memory _id)\n        public\n        view\n        virtual\n        returns (string memory, uint256[] memory, uint256[] memory, string memory, string memory, string memory, string memory);\n\n    function isInvestor(string memory _id) public view virtual returns (bool);\n\n    function isWallet(address _address) public view virtual returns (bool);\n\n    function isAccreditedInvestor(string calldata _id) external view virtual returns (bool);\n\n    function isQualifiedInvestor(string calldata _id) external view virtual returns (bool);\n\n    function isAccreditedInvestor(address _wallet) external view virtual returns (bool);\n\n    function isQualifiedInvestor(address _wallet) external view virtual returns (bool);\n\n    function getInvestors(address _from, address _to) external view virtual returns (string memory, string memory);\n}\n"},"contracts/service/IDSServiceConsumer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSServiceConsumer {\n    uint256 public constant TRUST_SERVICE = 1;\n    uint256 public constant DS_TOKEN = 2;\n    uint256 public constant REGISTRY_SERVICE = 4;\n    uint256 public constant COMPLIANCE_SERVICE = 8;\n    uint256 public constant UNUSED_1 = 16;\n    uint256 public constant WALLET_MANAGER = 32;\n    uint256 public constant LOCK_MANAGER = 64;\n    uint256 public constant DEPRECATED_PARTITIONS_MANAGER = 128;\n    uint256 public constant COMPLIANCE_CONFIGURATION_SERVICE = 256;\n    uint256 public constant TOKEN_ISSUER = 512;\n    uint256 public constant WALLET_REGISTRAR = 1024;\n    uint256 public constant DEPRECATED_OMNIBUS_TBE_CONTROLLER = 2048; // Deprecated, keep for backward compatibility\n    uint256 public constant TRANSACTION_RELAYER = 4096;\n    uint256 public constant DEPRECATED_TOKEN_REALLOCATOR = 8192; // Deprecated, keep for backward compatibility\n    uint256 public constant DEPRECATED_ISSUER_MULTICALL = 0;\n    uint256 public constant DEPRECATED_TA_MULTICALL = 0;\n    uint256 public constant DEPRECATED_SECURITIZE_SWAP = 16384;\n    uint256 public constant REBASING_PROVIDER = 8196;\n    uint256 public constant BLACKLIST_MANAGER = 8197;\n\n    function getDSService(uint256 _serviceId) public view virtual returns (address);\n\n    function setDSService(uint256 _serviceId, address _address /*onlyMaster*/) public virtual returns (bool);\n\n    event DSServiceSet(uint256 serviceId, address serviceAddress);\n}\n"},"contracts/service/ServiceConsumer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {IDSServiceConsumer} from \"./IDSServiceConsumer.sol\";\nimport {ServiceConsumerDataStore} from \"../data-stores/ServiceConsumerDataStore.sol\";\nimport {IDSToken} from \"../token/IDSToken.sol\";\nimport {IDSWalletManager} from \"../compliance/IDSWalletManager.sol\";\nimport {IDSLockManager} from \"../compliance/IDSLockManager.sol\";\nimport {IDSComplianceService} from \"../compliance/IDSComplianceService.sol\";\nimport {IDSComplianceConfigurationService} from \"../compliance/IDSComplianceConfigurationService.sol\";\nimport {IDSRegistryService} from \"../registry/IDSRegistryService.sol\";\nimport {IDSTrustService} from \"../trust/IDSTrustService.sol\";\nimport {ISecuritizeRebasingProvider} from \"../rebasing/ISecuritizeRebasingProvider.sol\";\nimport {OwnableUpgradeable} from \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport {IDSBlackListManager} from \"../compliance/IDSBlackListManager.sol\";\n\nabstract contract ServiceConsumer is IDSServiceConsumer, ServiceConsumerDataStore, OwnableUpgradeable {\n    // Bring role constants to save gas both in deployment (less bytecode) and usage\n    uint8 public constant ROLE_NONE = 0;\n    uint8 public constant ROLE_MASTER = 1;\n    uint8 public constant ROLE_ISSUER = 2;\n    uint8 public constant ROLE_EXCHANGE = 4;\n    uint8 public constant ROLE_TRANSFER_AGENT = 8;\n\n    function __ServiceConsumer_init() public virtual onlyInitializing {\n        __Ownable_init(msg.sender);\n    }\n\n    modifier onlyMaster {\n        if (owner() != msg.sender) require(getTrustService().getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    /**\n     * @dev Allow invoking functions only by the users who have the MASTER role or the ISSUER role or the TRANSFER AGENT role.\n     */\n    modifier onlyIssuerOrTransferAgentOrAbove() {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_TRANSFER_AGENT || role == ROLE_ISSUER || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyIssuerOrAbove {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_ISSUER || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyTransferAgentOrAbove {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_TRANSFER_AGENT || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyExchangeOrAbove {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_EXCHANGE || role == ROLE_ISSUER || role == ROLE_TRANSFER_AGENT || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyToken {\n        require(msg.sender == getDSService(DS_TOKEN), \"This function can only called by the associated token\");\n        _;\n    }\n\n    modifier onlyRegistry {\n        require(msg.sender == getDSService(REGISTRY_SERVICE), \"This function can only called by the registry service\");\n        _;\n    }\n\n    modifier onlyIssuerOrAboveOrToken {\n        if (msg.sender != getDSService(DS_TOKEN)) {\n            IDSTrustService trustManager = IDSTrustService(getDSService(TRUST_SERVICE));\n            require(trustManager.getRole(msg.sender) == ROLE_ISSUER || trustManager.getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        }\n        _;\n    }\n\n    modifier onlyTransferAgentOrAboveOrToken {\n        if (msg.sender != getDSService(DS_TOKEN)) {\n            IDSTrustService trustManager = IDSTrustService(getDSService(TRUST_SERVICE));\n            require(trustManager.getRole(msg.sender) == ROLE_TRANSFER_AGENT || trustManager.getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        }\n        _;\n    }\n\n    modifier onlyOwnerOrIssuerOrAbove {\n        if(owner() != msg.sender) {\n            IDSTrustService trustManager = getTrustService();\n            require(trustManager.getRole(msg.sender) == ROLE_ISSUER || trustManager.getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        }\n        _;\n    }\n\n    function getDSService(uint256 _serviceId) public view override returns (address) {\n        return services[_serviceId];\n    }\n\n    function setDSService(uint256 _serviceId, address _address) public override onlyMaster returns (bool) {\n        services[_serviceId] = _address;\n        emit DSServiceSet(_serviceId, _address);\n        return true;\n    }\n\n    function getToken() internal view returns (IDSToken) {\n        return IDSToken(getDSService(DS_TOKEN));\n    }\n\n    function getTrustService() internal view returns (IDSTrustService) {\n        return IDSTrustService(getDSService(TRUST_SERVICE));\n    }\n\n    function getWalletManager() internal view returns (IDSWalletManager) {\n        return IDSWalletManager(getDSService(WALLET_MANAGER));\n    }\n\n    function getLockManager() internal view returns (IDSLockManager) {\n        return IDSLockManager(getDSService(LOCK_MANAGER));\n    }\n\n    function getComplianceService() internal view returns (IDSComplianceService) {\n        return IDSComplianceService(getDSService(COMPLIANCE_SERVICE));\n    }\n\n    function getRegistryService() internal view returns (IDSRegistryService) {\n        return IDSRegistryService(getDSService(REGISTRY_SERVICE));\n    }\n\n    function getComplianceConfigurationService() internal view returns (IDSComplianceConfigurationService) {\n        return IDSComplianceConfigurationService(getDSService(COMPLIANCE_CONFIGURATION_SERVICE));\n    }\n\n    function getRebasingProvider() internal view returns (ISecuritizeRebasingProvider) {\n        return ISecuritizeRebasingProvider(getDSService(REBASING_PROVIDER));\n    }\n\n    function getBlackListManager() internal view returns (IDSBlackListManager) {\n        return IDSBlackListManager(getDSService(BLACKLIST_MANAGER));\n    }\n}\n"},"contracts/token/IDSToken.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\nimport {Initializable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\nabstract contract IDSToken is IERC20, Initializable {\n    event Issue(address indexed to, uint256 value, uint256 valueLocked);\n    event TxShares(address indexed from, address indexed to, uint256 shares, uint256 multiplier);\n    event Burn(address indexed burner, uint256 value, string reason);\n    event Seize(address indexed from, address indexed to, uint256 value, string reason);\n\n    event WalletAdded(address wallet);\n    event WalletRemoved(address wallet);\n\n    function initialize(string calldata _name, string calldata _symbol, uint8 _decimals) public virtual;\n\n    /******************************\n       TOKEN ISSUANCE (MINTING)\n   *******************************/\n\n    /**\n     * @dev Issues unlocked tokens\n     * @param _to address The address which is going to receive the newly issued tokens\n     * @param _value uint256 the value of tokens to issue\n     * @return true if successful\n     */\n    function issueTokens(\n        address _to,\n        uint256 _value /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Issuing tokens from the fund\n     * @param _to address The address which is going to receive the newly issued tokens\n     * @param _value uint256 the value of tokens to issue\n     * @param _valueLocked uint256 value of tokens, from those issued, to lock immediately.\n     * @param _reason reason for token locking\n     * @param _releaseTime timestamp to release the lock (or 0 for locks which can only released by an unlockTokens call)\n     * @return true if successful\n     */\n    function issueTokensCustom(\n        address _to,\n        uint256 _value,\n        uint256 _issuanceTime,\n        uint256 _valueLocked,\n        string memory _reason,\n        uint64 _releaseTime /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    function issueTokensWithMultipleLocks(\n        address _to,\n        uint256 _value,\n        uint256 _issuanceTime,\n        uint256[] memory _valuesLocked,\n        string memory _reason,\n        uint64[] memory _releaseTimes /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    //*********************\n    // TOKEN BURNING\n    //*********************\n\n    function burn(\n        address _who,\n        uint256 _value,\n        string calldata _reason /*onlyIssuerOrAbove*/\n    ) public virtual;\n\n    //*********************\n    // TOKEN SIEZING\n    //*********************\n\n    function seize(\n        address _from,\n        address _to,\n        uint256 _value,\n        string calldata _reason /*onlyIssuerOrAbove*/\n    ) public virtual;\n\n    //*********************\n    // WALLET ENUMERATION\n    //*********************\n\n    function getWalletAt(uint256 _index) public view virtual returns (address);\n\n    function walletCount() public view virtual returns (uint256);\n\n    //**************************************\n    // MISCELLANEOUS FUNCTIONS\n    //**************************************\n    function isPaused() public view virtual returns (bool);\n\n    function balanceOfInvestor(string memory _id) public view virtual returns (uint256);\n\n    function updateInvestorBalance(address _wallet, uint256 _value, CommonUtils.IncDec _increase) internal virtual;\n\n    function preTransferCheck(address _from, address _to, uint256 _value) public view virtual returns (uint256 code, string memory reason);\n\n}\n"},"contracts/trust/IDSTrustService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\n/**\n * @title IDSTrustService\n * @dev An interface for a trust service which allows role-based access control for other contracts.\n */\n\nabstract contract IDSTrustService {\n\n    function initialize() public virtual;\n\n    /**\n     * @dev Should be emitted when a role is set for a user.\n     */\n    event DSTrustServiceRoleAdded(address targetAddress, uint8 role, address sender);\n    /**\n     * @dev Should be emitted when a role is removed for a user.\n     */\n    event DSTrustServiceRoleRemoved(address targetAddress, uint8 role, address sender);\n\n    // Role constants\n    uint8 public constant NONE = 0;\n    uint8 public constant MASTER = 1;\n    uint8 public constant ISSUER = 2;\n    uint8 public constant EXCHANGE = 4;\n    uint8 public constant TRANSFER_AGENT = 8;\n\n    /**\n     * @dev Transfers the ownership (MASTER role) of the contract.\n     * @param _address The address which the ownership needs to be transferred to.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setServiceOwner(\n        address _address /*onlyMaster*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Sets a role for an array of wallets.\n     * @dev Should not be used for setting MASTER (use setServiceOwner) or role removal (use removeRole).\n     * @param _addresses The array of wallet whose role needs to be set.\n     * @param _roles The array of role to be set. The length and order must match with _addresses\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setRoles(address[] calldata _addresses, uint8[] calldata _roles) public virtual returns (bool);\n\n    /**\n     * @dev Sets a role for a wallet.\n     * @dev Should not be used for setting MASTER (use setServiceOwner) or role removal (use removeRole).\n     * @param _address The wallet whose role needs to be set.\n     * @param _role The role to be set.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setRole(\n        address _address,\n        uint8 _role /*onlyMasterOrIssuer*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Removes the role for a wallet.\n     * @dev Should not be used to remove MASTER (use setServiceOwner).\n     * @param _address The wallet whose role needs to be removed.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function removeRole(\n        address _address /*onlyMasterOrIssuer*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Gets the role for a wallet.\n     * @param _address The wallet whose role needs to be fetched.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function getRole(address _address) public view virtual returns (uint8);\n\n}\n"},"contracts/utils/BaseDSContract.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {ServiceConsumer} from \"../service/ServiceConsumer.sol\";\nimport {UUPSUpgradeable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\n\nabstract contract BaseDSContract is UUPSUpgradeable, ServiceConsumer {\n\n    function __BaseDSContract_init() public onlyProxy onlyInitializing {\n        __UUPSUpgradeable_init();\n        __ServiceConsumer_init();\n    }\n\n    /**\n     * @dev required by the OZ UUPS module\n     */\n    function _authorizeUpgrade(address) internal override onlyMaster {}\n\n    /**\n     * @dev returns proxy ERC1967 implementation address\n     */\n    function getImplementationAddress() external view returns (address) {\n        return ERC1967Utils.getImplementation();\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function getInitializedVersion() external view returns (uint64) {\n        return _getInitializedVersion();\n    }\n\n}\n"},"contracts/utils/CommonUtils.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nlibrary CommonUtils {\n  enum IncDec { Increase, Decrease }\n\n  function encodeString(string memory _str) internal pure returns (bytes32) {\n    return keccak256(abi.encodePacked(_str));\n  }\n\n  function isEqualString(string memory _str1, string memory _str2) internal pure returns (bool) {\n    return encodeString(_str1) == encodeString(_str2);\n  }\n\n  function isEmptyString(string memory _str) internal pure returns (bool) {\n    return bytes(_str).length == 0;\n  }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.22+commit.4fc1097e","compilerSettings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"},"name":"TokenIssuer","fullyQualifiedName":"contracts/issuance/TokenIssuer.sol:TokenIssuer"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AddressEmptyCode","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"ERC1967InvalidImplementation","type":"error","inputs":[{"name":"implementation","type":"address","internalType":"address"}]},{"name":"ERC1967NonPayable","type":"error","inputs":[]},{"name":"FailedCall","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"UUPSUnauthorizedCallContext","type":"error","inputs":[]},{"name":"UUPSUnsupportedProxiableUUID","type":"error","inputs":[{"name":"slot","type":"bytes32","internalType":"bytes32"}]},{"name":"DSServiceSet","type":"event","inputs":[{"name":"serviceId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"serviceAddress","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"BLACKLIST_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"COMPLIANCE_CONFIGURATION_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"COMPLIANCE_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_ISSUER_MULTICALL","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_OMNIBUS_TBE_CONTROLLER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_PARTITIONS_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_SECURITIZE_SWAP","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_TA_MULTICALL","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_TOKEN_REALLOCATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DS_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"LOCK_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"REBASING_PROVIDER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"REGISTRY_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"ROLE_EXCHANGE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_ISSUER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_MASTER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_NONE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_TRANSFER_AGENT","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"TOKEN_ISSUER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"TRANSACTION_RELAYER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"TRUST_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"UNUSED_1","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"UPGRADE_INTERFACE_VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"WALLET_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"WALLET_REGISTRAR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"__BaseDSContract_init","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"__ServiceConsumer_init","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"getDSService","type":"function","inputs":[{"name":"_serviceId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"getImplementationAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"getInitializedVersion","type":"function","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"issueTokens","type":"function","inputs":[{"name":"_id","type":"string","internalType":"string"},{"name":"_to","type":"address","internalType":"address"},{"name":"_issuanceValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_reason","type":"string","internalType":"string"},{"name":"_locksValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_lockReleaseTimes","type":"uint64[]","internalType":"uint64[]"},{"name":"_collisionHash","type":"string","internalType":"string"},{"name":"_country","type":"string","internalType":"string"},{"name":"_attributeValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_attributeExpirations","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setDSService","type":"function","inputs":[{"name":"_serviceId","type":"uint256","internalType":"uint256"},{"name":"_address","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"serviceId","type":"uint256"},{"indexed":false,"internalType":"address","name":"serviceAddress","type":"address"}],"name":"DSServiceSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"BLACKLIST_MANAGER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"COMPLIANCE_CONFIGURATION_SERVICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"COMPLIANCE_SERVICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPRECATED_ISSUER_MULTICALL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPRECATED_OMNIBUS_TBE_CONTROLLER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPRECATED_PARTITIONS_MANAGER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPRECATED_SECURITIZE_SWAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPRECATED_TA_MULTICALL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPRECATED_TOKEN_REALLOCATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DS_TOKEN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LOCK_MANAGER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REBASING_PROVIDER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REGISTRY_SERVICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROLE_EXCHANGE","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROLE_ISSUER","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROLE_MASTER","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROLE_NONE","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROLE_TRANSFER_AGENT","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_ISSUER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRANSACTION_RELAYER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRUST_SERVICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNUSED_1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WALLET_MANAGER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WALLET_REGISTRAR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"__BaseDSContract_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"__ServiceConsumer_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_serviceId","type":"uint256"}],"name":"getDSService","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getImplementationAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getInitializedVersion","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_id","type":"string"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_issuanceValues","type":"uint256[]"},{"internalType":"string","name":"_reason","type":"string"},{"internalType":"uint256[]","name":"_locksValues","type":"uint256[]"},{"internalType":"uint64[]","name":"_lockReleaseTimes","type":"uint64[]"},{"internalType":"string","name":"_collisionHash","type":"string"},{"internalType":"string","name":"_country","type":"string"},{"internalType":"uint256[]","name":"_attributeValues","type":"uint256[]"},{"internalType":"uint256[]","name":"_attributeExpirations","type":"uint256[]"}],"name":"issueTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_serviceId","type":"uint256"},{"internalType":"address","name":"_address","type":"address"}],"name":"setDSService","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"}],"devdoc":{"errors":{"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"ERC1967InvalidImplementation(address)":[{"details":"The `implementation` of the proxy is invalid."}],"ERC1967NonPayable()":[{"details":"An upgrade function sees `msg.value > 0` that may be lost."}],"FailedCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"UUPSUnauthorizedCallContext()":[{"details":"The call is from an unauthorized context."}],"UUPSUnsupportedProxiableUUID(bytes32)":[{"details":"The storage `slot` is unsupported as a UUID."}]},"events":{"Initialized(uint64)":{"details":"Triggered when the contract has been initialized or reinitialized."},"Upgraded(address)":{"details":"Emitted when the implementation is upgraded."}},"kind":"dev","methods":{"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"getImplementationAddress()":{"details":"returns proxy ERC1967 implementation address"},"getInitializedVersion()":{"details":"Returns the highest version that has been initialized. See {reinitializer}."},"owner()":{"details":"Returns the address of the current owner."},"proxiableUUID()":{"details":"Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"upgradeToAndCall(address,bytes)":{"custom:oz-upgrades-unsafe-allow-reachable":"delegatecall","details":"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event."}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"contracts/issuance/TokenIssuer.sol":"TokenIssuer"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol":{"keccak256":"0xc163fcf9bb10138631a9ba5564df1fa25db9adff73bd9ee868a8ae1858fe093a","license":"MIT","urls":["bzz-raw://9706d43a0124053d9880f6e31a59f31bc0a6a3dc1acd66ce0a16e1111658c5f6","dweb:/ipfs/QmUFmfowzkRwGtDu36cXV9SPTBHJ3n7dG9xQiK5B28jTf2"]},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"keccak256":"0xdb4d24ee2c087c391d587cd17adfe5b3f9d93b3110b1388c2ab6c7c0ad1dcd05","license":"MIT","urls":["bzz-raw://ab7b6d5b9e2b88176312967fe0f0e78f3d9a1422fa5e4b64e2440c35869b5d08","dweb:/ipfs/QmXKYWWyzcLg1B2k7Sb1qkEXgLCYfXecR9wYW5obRzWP1Q"]},"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol":{"keccak256":"0x574a7451e42724f7de29e2855c392a8a5020acd695169466a18459467d719d63","license":"MIT","urls":["bzz-raw://5bc189f63b639ee173dd7b6fecc39baf7113bf161776aea22b34c57fdd1872ec","dweb:/ipfs/QmZAf2VtjDLRULqjJkde6LNsxAg12tUqpPqgUQQZbAjgtZ"]},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"keccak256":"0xdbef5f0c787055227243a7318ef74c8a5a1108ca3a07f2b3a00ef67769e1e397","license":"MIT","urls":["bzz-raw://08e39f23d5b4692f9a40803e53a8156b72b4c1f9902a88cd65ba964db103dab9","dweb:/ipfs/QmPKn6EYDgpga7KtpkA8wV2yJCYGMtc9K4LkJfhKX2RVSV"]},"@openzeppelin/contracts/interfaces/IERC1967.sol":{"keccak256":"0xbf2aefe54b76d7f7bcd4f6da1080b7b1662611937d870b880db584d09cea56b5","license":"MIT","urls":["bzz-raw://f5e7e2f12e0feec75296e57f51f82fdaa8bd1551f4b8cc6560442c0bf60f818c","dweb:/ipfs/QmcW9wDMaQ8RbQibMarfp17a3bABzY5KraWe2YDwuUrUoz"]},"@openzeppelin/contracts/interfaces/IERC20.sol":{"keccak256":"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44","license":"MIT","urls":["bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d","dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF"]},"@openzeppelin/contracts/interfaces/draft-IERC1822.sol":{"keccak256":"0x82f757819bf2429a0d4db141b99a4bbe5039e4ef86dfb94e2e6d40577ed5b28b","license":"MIT","urls":["bzz-raw://37c30ed931e19fb71fdb806bb504cfdb9913b7127545001b64d4487783374422","dweb:/ipfs/QmUBHpv4hm3ZmwJ4GH8BeVzK4mv41Q6vBbWXxn8HExPXza"]},"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol":{"keccak256":"0xa1ad192cd45317c788618bef5cb1fb3ca4ce8b230f6433ac68cc1d850fb81618","license":"MIT","urls":["bzz-raw://b43447bb85a53679d269a403c693b9d88d6c74177dfb35eddca63abaf7cf110a","dweb:/ipfs/QmXSDmpd4bNZj1PDgegr6C4w1jDaWHXCconC3rYiw9TSkQ"]},"@openzeppelin/contracts/proxy/beacon/IBeacon.sol":{"keccak256":"0x20462ddb2665e9521372c76b001d0ce196e59dbbd989de9af5576cad0bd5628b","license":"MIT","urls":["bzz-raw://f417fd12aeec8fbfaceaa30e3a08a0724c0bc39de363e2acf6773c897abbaf6d","dweb:/ipfs/QmU4Hko6sApdweVM92CsiuLKkCk8HfyBeutF89PCTz5Tye"]},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2","license":"MIT","urls":["bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303","dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV"]},"@openzeppelin/contracts/utils/Address.sol":{"keccak256":"0x6d0ae6e206645341fd122d278c2cb643dea260c190531f2f3f6a0426e77b00c0","license":"MIT","urls":["bzz-raw://032d1201d839435be2c85b72e33206b3ea980c569d6ebf7fa57d811ab580a82f","dweb:/ipfs/QmeqQjAtMvdZT2tG7zm39itcRJkuwu8AEReK6WRnLJ18DD"]},"@openzeppelin/contracts/utils/Errors.sol":{"keccak256":"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123","license":"MIT","urls":["bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf","dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB"]},"@openzeppelin/contracts/utils/StorageSlot.sol":{"keccak256":"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97","license":"MIT","urls":["bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b","dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM"]},"contracts/compliance/IDSBlackListManager.sol":{"keccak256":"0xc1405c507a45895c802d817933bce7abbeacc4919e036d87e772bcf4426fa254","license":"Apache-2.0","urls":["bzz-raw://a040e282878972622e246b02199f27760953c982ae66ee1cc3884c196a8051e4","dweb:/ipfs/QmPw5XVRVZEgbgKvVn3ypZJhaUiWWXLdfMnCutNjS9vXkk"]},"contracts/compliance/IDSComplianceConfigurationService.sol":{"keccak256":"0xe276c42f1df8b7f778d37ab366a7141e94b8b0d668e12ea68137a8f5c1556a26","license":"Apache-2.0","urls":["bzz-raw://872af08636fc9242da0e1944ab2b1655530014d914ff7173e7d3e2c4a7416ff0","dweb:/ipfs/QmSDYjkeXHEvm2ZjaS2kncm8PJiVMCzZdEWGCRUeprotff"]},"contracts/compliance/IDSComplianceService.sol":{"keccak256":"0x7ec87e6c3d9dbd0543c9a4ed311fc7f28d0f255085f354e2e66e0f59a925933d","license":"Apache-2.0","urls":["bzz-raw://eff19340b27ec907ca36db46c3b87188d8262319b9fcaa6a13c5aeb4cb7a9ac9","dweb:/ipfs/QmYn4D2sNMwUh1L2qptXvpYVpwJoZbjfwnSVWAHEAhpU8a"]},"contracts/compliance/IDSLockManager.sol":{"keccak256":"0xb64ef40c572a0336f239b37dfc37a0c000aa5a95ed13e59e4ad93a98906b5ad5","license":"Apache-2.0","urls":["bzz-raw://a116afade793478786678d28a69102801e3b24cde5f4907bbd88d6f525471d38","dweb:/ipfs/QmXmmMayfswQBQ81yZFjVzZvbmf88sK5i9L3PoEXWYMeaF"]},"contracts/compliance/IDSWalletManager.sol":{"keccak256":"0xe5dbfdbe8e6c335a9b0b43d10ebef5d108d6b29ab1d750a235e00e4918256a3e","license":"Apache-2.0","urls":["bzz-raw://a0bf5a92cdfcaef62da2e5b567fa8f212e32c0a0482834c7dea8bdc843e6acc7","dweb:/ipfs/QmPgmNM94pwfFG1fnxwNYMBmwPnyeP646QBCph8gRFwteM"]},"contracts/data-stores/ServiceConsumerDataStore.sol":{"keccak256":"0x82c2d45eca38a7517d66caa2e923c00888c0d5c825784ae2c1e124f230763318","license":"Apache-2.0","urls":["bzz-raw://23b8ec1dd24d5a399bed4569247cd3a4527faf1ac310e1886646931eae64bb62","dweb:/ipfs/QmQ9VLKuRAhECYwc5vz4RKU1mAioQXhG5Mjxrnq8DSZ6fV"]},"contracts/issuance/IDSTokenIssuer.sol":{"keccak256":"0x91a5ad17820efa5f2499f8d1031f75797b65aed3bd1caf95be327c90921a843f","license":"Apache-2.0","urls":["bzz-raw://7d3fbc2955b92151869c9940b63a341aaa5859b4c8bfdd5d8c4f625fa7bae4da","dweb:/ipfs/QmdZq3uVKi262oq4U11SQwdFu5GVB2sPzW3tc8RTiWk7Yx"]},"contracts/issuance/TokenIssuer.sol":{"keccak256":"0x7ba8811146ec212ce028991209adb0ac93f94c0e2f8c36348400ad3c3a591b6d","license":"Apache-2.0","urls":["bzz-raw://efc33426d5431ee2d15037375a2c34e827549b090901cd62a4a416e306b88aef","dweb:/ipfs/QmPt5BYCZ9XnTNBspWjMMM5cD3nES8yDVbaRcQWC8xZ6jw"]},"contracts/rebasing/ISecuritizeRebasingProvider.sol":{"keccak256":"0x01beb0ca06b9c6d9509da8ff68ccaa6cdfe105110cec23f36ad5791241170d15","license":"Apache-2.0","urls":["bzz-raw://25405ad76355dbe489d1c6ec903ccc955f061fb07ac4e12ab61332ec3c1c121c","dweb:/ipfs/QmPQq8D6VQXhxqA2zgcHbK9hABZL1c13wdid4yffBotZ88"]},"contracts/registry/IDSRegistryService.sol":{"keccak256":"0x31818dbfd6d1a10a5be4ef4add1228a71a9a3529f313e431259ce143be51ebcb","license":"Apache-2.0","urls":["bzz-raw://573381bf8fb270e236c717a061a02873035cc29d9eb7437e476d792c5586a2d0","dweb:/ipfs/QmcB8RSwBZAEryTGMw4RtBgsuCi9V63tDZTXjXEuiVKBQ3"]},"contracts/service/IDSServiceConsumer.sol":{"keccak256":"0x791c40e727af0329606e4ad273f30f068055bfb49f26adb9085e9b9e22857024","license":"Apache-2.0","urls":["bzz-raw://8fbaab8c3bb9a26ae295d8417b2bbd9745aa68811b128e713bc39ddddd244ba2","dweb:/ipfs/Qmd4z6m5MjsJ9emGiKvhaxdGC72bSXAhtjpkPeUaN3xmpC"]},"contracts/service/ServiceConsumer.sol":{"keccak256":"0x9e7a76550715d0b28c56208e4dd8249c51f1c31d4c5384bb304a8409aef073a2","license":"Apache-2.0","urls":["bzz-raw://a8e8328ba98ea2ecc51cd1eadd37f531516ce06cb97ec43507a6896072c0c96b","dweb:/ipfs/QmWsYGtaf31YsevFbYmVVeDqGWnxy4umZun5oFdeia8Uvk"]},"contracts/token/IDSToken.sol":{"keccak256":"0x5e37507a3ac1bb628635e6b9f2929b87cb63a687075fec9a0d586e0d21a66484","license":"Apache-2.0","urls":["bzz-raw://4497593a744c9d2b91fddcd3c77e4fb58c3566cc7db69718def60ce9c443b700","dweb:/ipfs/QmNkU5D5JQLsNJzKzbm8wuxDLAyskqNEKhv2MnzE273Nyz"]},"contracts/trust/IDSTrustService.sol":{"keccak256":"0xeb6873df49c0fa79d817ac703465d4f2819ddfc3cd77ad305270c2101f785136","license":"Apache-2.0","urls":["bzz-raw://fcec4f776fdfa5b9a6060d78e7d8a50521e9d4c8ef289a5d5964dbfd2450bcb6","dweb:/ipfs/QmcoGwD6WqWBEnKAGSx23erAawGK3M2xqdCvWV8XifJcac"]},"contracts/utils/BaseDSContract.sol":{"keccak256":"0xa99851762d66d1636db92494bfe8c5ab997b5995fd208d5b07e62284d1bee0b3","license":"Apache-2.0","urls":["bzz-raw://74132312667c478aa780ff6cdfa443245848421c7248b93083f4d6f83b80feff","dweb:/ipfs/QmPEkeExbDNF9wjKGsRGE9Bf9qpH5XiQbd5nrsJkiBUd8S"]},"contracts/utils/CommonUtils.sol":{"keccak256":"0xb4e8316d25f76902ccd344f8336e22a15da939547b681a1193d6072a58ce9308","license":"Apache-2.0","urls":["bzz-raw://7aacf875230d1333848d63f73ddecf4d3fc8cc854f57ff842c836daf992e77bc","dweb:/ipfs/QmXPhogwSYwELQ7DowjTJjpXX4AqGiLUX8REtQ4F7av7YY"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_array(t_uint256)49_storage":{"base":"t_uint256","label":"uint256[49]","encoding":"inplace","numberOfBytes":"1568"},"t_mapping(t_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_uint256,t_address)","astId":2468,"label":"services","offset":0,"contract":"contracts/issuance/TokenIssuer.sol:TokenIssuer"},{"slot":"1","type":"t_array(t_uint256)49_storage","astId":2473,"label":"__gap","offset":0,"contract":"contracts/issuance/TokenIssuer.sol:TokenIssuer"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","errors":{"FailedCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"ERC1967NonPayable()":[{"details":"An upgrade function sees `msg.value > 0` that may be lost."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"UUPSUnauthorizedCallContext()":[{"details":"The call is from an unauthorized context."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC1967InvalidImplementation(address)":[{"details":"The `implementation` of the proxy is invalid."}],"UUPSUnsupportedProxiableUUID(bytes32)":[{"details":"The storage `slot` is unsupported as a UUID."}]},"events":{"Upgraded(address)":{"details":"Emitted when the implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized or reinitialized."}},"methods":{"owner()":{"details":"Returns the address of the current owner."},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"proxiableUUID()":{"details":"Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"getInitializedVersion()":{"details":"Returns the highest version that has been initialized. See {reinitializer}."},"getImplementationAddress()":{"details":"returns proxy ERC1967 implementation address"},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"upgradeToAndCall(address,bytes)":{"details":"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.","custom:oz-upgrades-unsafe-allow-reachable":"delegatecall"}},"version":1},"sourceIds":{"contracts/token/IDSToken.sol":{"id":25},"contracts/utils/CommonUtils.sol":{"id":28},"contracts/issuance/TokenIssuer.sol":{"id":20},"contracts/utils/BaseDSContract.sol":{"id":27},"contracts/trust/IDSTrustService.sol":{"id":26},"contracts/issuance/IDSTokenIssuer.sol":{"id":19},"contracts/service/ServiceConsumer.sol":{"id":24},"contracts/compliance/IDSLockManager.sol":{"id":16},"@openzeppelin/contracts/utils/Errors.sol":{"id":11},"contracts/service/IDSServiceConsumer.sol":{"id":23},"@openzeppelin/contracts/utils/Address.sol":{"id":10},"contracts/compliance/IDSWalletManager.sol":{"id":17},"contracts/registry/IDSRegistryService.sol":{"id":22},"contracts/compliance/IDSBlackListManager.sol":{"id":13},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":5},"@openzeppelin/contracts/utils/StorageSlot.sol":{"id":12},"contracts/compliance/IDSComplianceService.sol":{"id":15},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":9},"@openzeppelin/contracts/interfaces/IERC1967.sol":{"id":4},"@openzeppelin/contracts/proxy/beacon/IBeacon.sol":{"id":8},"contracts/data-stores/ServiceConsumerDataStore.sol":{"id":18},"contracts/rebasing/ISecuritizeRebasingProvider.sol":{"id":21},"@openzeppelin/contracts/interfaces/draft-IERC1822.sol":{"id":6},"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol":{"id":7},"contracts/compliance/IDSComplianceConfigurationService.sol":{"id":14},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"id":3},"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol":{"id":0},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"id":1},"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol":{"id":2}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/token/IDSToken.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {IERC20} from \"@openzeppelin/contracts/interfaces/IERC20.sol\";\nimport {Initializable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\nabstract contract IDSToken is IERC20, Initializable {\n    event Issue(address indexed to, uint256 value, uint256 valueLocked);\n    event TxShares(address indexed from, address indexed to, uint256 shares, uint256 multiplier);\n    event Burn(address indexed burner, uint256 value, string reason);\n    event Seize(address indexed from, address indexed to, uint256 value, string reason);\n\n    event WalletAdded(address wallet);\n    event WalletRemoved(address wallet);\n\n    function initialize(string calldata _name, string calldata _symbol, uint8 _decimals) public virtual;\n\n    /******************************\n       TOKEN ISSUANCE (MINTING)\n   *******************************/\n\n    /**\n     * @dev Issues unlocked tokens\n     * @param _to address The address which is going to receive the newly issued tokens\n     * @param _value uint256 the value of tokens to issue\n     * @return true if successful\n     */\n    function issueTokens(\n        address _to,\n        uint256 _value /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Issuing tokens from the fund\n     * @param _to address The address which is going to receive the newly issued tokens\n     * @param _value uint256 the value of tokens to issue\n     * @param _valueLocked uint256 value of tokens, from those issued, to lock immediately.\n     * @param _reason reason for token locking\n     * @param _releaseTime timestamp to release the lock (or 0 for locks which can only released by an unlockTokens call)\n     * @return true if successful\n     */\n    function issueTokensCustom(\n        address _to,\n        uint256 _value,\n        uint256 _issuanceTime,\n        uint256 _valueLocked,\n        string memory _reason,\n        uint64 _releaseTime /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    function issueTokensWithMultipleLocks(\n        address _to,\n        uint256 _value,\n        uint256 _issuanceTime,\n        uint256[] memory _valuesLocked,\n        string memory _reason,\n        uint64[] memory _releaseTimes /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    //*********************\n    // TOKEN BURNING\n    //*********************\n\n    function burn(\n        address _who,\n        uint256 _value,\n        string calldata _reason /*onlyIssuerOrAbove*/\n    ) public virtual;\n\n    //*********************\n    // TOKEN SIEZING\n    //*********************\n\n    function seize(\n        address _from,\n        address _to,\n        uint256 _value,\n        string calldata _reason /*onlyIssuerOrAbove*/\n    ) public virtual;\n\n    //*********************\n    // WALLET ENUMERATION\n    //*********************\n\n    function getWalletAt(uint256 _index) public view virtual returns (address);\n\n    function walletCount() public view virtual returns (uint256);\n\n    //**************************************\n    // MISCELLANEOUS FUNCTIONS\n    //**************************************\n    function isPaused() public view virtual returns (bool);\n\n    function balanceOfInvestor(string memory _id) public view virtual returns (uint256);\n\n    function updateInvestorBalance(address _wallet, uint256 _value, CommonUtils.IncDec _increase) internal virtual;\n\n    function preTransferCheck(address _from, address _to, uint256 _value) public view virtual returns (uint256 code, string memory reason);\n\n}\n"},"contracts/utils/CommonUtils.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nlibrary CommonUtils {\n  enum IncDec { Increase, Decrease }\n\n  function encodeString(string memory _str) internal pure returns (bytes32) {\n    return keccak256(abi.encodePacked(_str));\n  }\n\n  function isEqualString(string memory _str1, string memory _str2) internal pure returns (bool) {\n    return encodeString(_str1) == encodeString(_str2);\n  }\n\n  function isEmptyString(string memory _str) internal pure returns (bool) {\n    return bytes(_str).length == 0;\n  }\n}\n"},"contracts/issuance/TokenIssuer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {IDSTokenIssuer} from \"./IDSTokenIssuer.sol\";\nimport {IDSRegistryService} from \"../registry/IDSRegistryService.sol\";\nimport {BaseDSContract} from \"../utils/BaseDSContract.sol\";\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\ncontract TokenIssuer is IDSTokenIssuer, BaseDSContract {\n    /// @custom:oz-upgrades-unsafe-allow constructor\n    constructor() {\n        _disableInitializers();\n    }\n\n    function initialize() public override onlyProxy initializer {\n        __BaseDSContract_init();\n    }\n\n    function issueTokens(\n        string calldata _id,\n        address _to,\n        uint256[] memory _issuanceValues,\n        string memory _reason,\n        uint256[] memory _locksValues,\n        uint64[] memory _lockReleaseTimes,\n        string memory _collisionHash,\n        string memory _country,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations\n    ) public override onlyIssuerOrAbove returns (bool) {\n        require(_issuanceValues.length == 2, \"Wrong length of parameters\");\n        require(_attributeValues.length == _attributeExpirations.length, \"Wrong length of parameters\");\n        require(_locksValues.length == _lockReleaseTimes.length, \"Wrong length of parameters\");\n        if (getRegistryService().isWallet(_to)) {\n            require(CommonUtils.isEqualString(getRegistryService().getInvestor(_to), _id), \"Wallet does not belong to investor\");\n        } else {\n            registerInvestor(_id, _to, _collisionHash, _country, _attributeValues, _attributeExpirations);\n        }\n\n        getToken().issueTokensWithMultipleLocks(_to, _issuanceValues[0], _issuanceValues[1], _locksValues, _reason, _lockReleaseTimes);\n\n        return true;\n    }\n\n    function registerInvestor(\n        string memory _id,\n        address _wallet,\n        string memory _collisionHash,\n        string memory _country,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations\n    ) private {\n        IDSRegistryService registryService = getRegistryService();\n        uint8 EXPECTED_NUM_ATTRIBUTES = 3;\n        // all parameters required or none for Token Issuer\n        require(_attributeValues.length == 0 || _attributeValues.length == EXPECTED_NUM_ATTRIBUTES, \"Wrong length of parameters\");\n        uint8[] memory attributesIds;\n        if (_attributeValues.length == EXPECTED_NUM_ATTRIBUTES) {\n            attributesIds = new uint8[](EXPECTED_NUM_ATTRIBUTES);\n            attributesIds[0] = registryService.KYC_APPROVED();\n            attributesIds[1] = registryService.ACCREDITED();\n            attributesIds[2] = registryService.QUALIFIED();\n        } else {\n            attributesIds = new uint8[](0);\n        }\n        address[] memory investorWallets = new address[](1);\n        investorWallets[0] = _wallet;\n        registryService.updateInvestor(\n            _id,\n            _collisionHash,\n            _country,\n            investorWallets,\n            attributesIds,\n            _attributeValues,\n            _attributeExpirations\n        );\n    }\n}\n"},"contracts/utils/BaseDSContract.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {ServiceConsumer} from \"../service/ServiceConsumer.sol\";\nimport {UUPSUpgradeable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\n\nabstract contract BaseDSContract is UUPSUpgradeable, ServiceConsumer {\n\n    function __BaseDSContract_init() public onlyProxy onlyInitializing {\n        __UUPSUpgradeable_init();\n        __ServiceConsumer_init();\n    }\n\n    /**\n     * @dev required by the OZ UUPS module\n     */\n    function _authorizeUpgrade(address) internal override onlyMaster {}\n\n    /**\n     * @dev returns proxy ERC1967 implementation address\n     */\n    function getImplementationAddress() external view returns (address) {\n        return ERC1967Utils.getImplementation();\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function getInitializedVersion() external view returns (uint64) {\n        return _getInitializedVersion();\n    }\n\n}\n"},"contracts/trust/IDSTrustService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\n/**\n * @title IDSTrustService\n * @dev An interface for a trust service which allows role-based access control for other contracts.\n */\n\nabstract contract IDSTrustService {\n\n    function initialize() public virtual;\n\n    /**\n     * @dev Should be emitted when a role is set for a user.\n     */\n    event DSTrustServiceRoleAdded(address targetAddress, uint8 role, address sender);\n    /**\n     * @dev Should be emitted when a role is removed for a user.\n     */\n    event DSTrustServiceRoleRemoved(address targetAddress, uint8 role, address sender);\n\n    // Role constants\n    uint8 public constant NONE = 0;\n    uint8 public constant MASTER = 1;\n    uint8 public constant ISSUER = 2;\n    uint8 public constant EXCHANGE = 4;\n    uint8 public constant TRANSFER_AGENT = 8;\n\n    /**\n     * @dev Transfers the ownership (MASTER role) of the contract.\n     * @param _address The address which the ownership needs to be transferred to.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setServiceOwner(\n        address _address /*onlyMaster*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Sets a role for an array of wallets.\n     * @dev Should not be used for setting MASTER (use setServiceOwner) or role removal (use removeRole).\n     * @param _addresses The array of wallet whose role needs to be set.\n     * @param _roles The array of role to be set. The length and order must match with _addresses\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setRoles(address[] calldata _addresses, uint8[] calldata _roles) public virtual returns (bool);\n\n    /**\n     * @dev Sets a role for a wallet.\n     * @dev Should not be used for setting MASTER (use setServiceOwner) or role removal (use removeRole).\n     * @param _address The wallet whose role needs to be set.\n     * @param _role The role to be set.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setRole(\n        address _address,\n        uint8 _role /*onlyMasterOrIssuer*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Removes the role for a wallet.\n     * @dev Should not be used to remove MASTER (use setServiceOwner).\n     * @param _address The wallet whose role needs to be removed.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function removeRole(\n        address _address /*onlyMasterOrIssuer*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Gets the role for a wallet.\n     * @param _address The wallet whose role needs to be fetched.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function getRole(address _address) public view virtual returns (uint8);\n\n}\n"},"contracts/issuance/IDSTokenIssuer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSTokenIssuer {\n\n    function initialize() public virtual;\n\n    function issueTokens(\n        string calldata _id,\n        address _to,\n        uint256[] memory _issuanceValues,\n        string memory _reason,\n        uint256[] memory _locksValues,\n        uint64[] memory _lockReleaseTimes,\n        string memory _collisionHash,\n        string memory _country,\n        uint256[] memory attributeValues,\n        uint256[] memory attributeExpirations /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n}\n"},"contracts/service/ServiceConsumer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {IDSServiceConsumer} from \"./IDSServiceConsumer.sol\";\nimport {ServiceConsumerDataStore} from \"../data-stores/ServiceConsumerDataStore.sol\";\nimport {IDSToken} from \"../token/IDSToken.sol\";\nimport {IDSWalletManager} from \"../compliance/IDSWalletManager.sol\";\nimport {IDSLockManager} from \"../compliance/IDSLockManager.sol\";\nimport {IDSComplianceService} from \"../compliance/IDSComplianceService.sol\";\nimport {IDSComplianceConfigurationService} from \"../compliance/IDSComplianceConfigurationService.sol\";\nimport {IDSRegistryService} from \"../registry/IDSRegistryService.sol\";\nimport {IDSTrustService} from \"../trust/IDSTrustService.sol\";\nimport {ISecuritizeRebasingProvider} from \"../rebasing/ISecuritizeRebasingProvider.sol\";\nimport {OwnableUpgradeable} from \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport {IDSBlackListManager} from \"../compliance/IDSBlackListManager.sol\";\n\nabstract contract ServiceConsumer is IDSServiceConsumer, ServiceConsumerDataStore, OwnableUpgradeable {\n    // Bring role constants to save gas both in deployment (less bytecode) and usage\n    uint8 public constant ROLE_NONE = 0;\n    uint8 public constant ROLE_MASTER = 1;\n    uint8 public constant ROLE_ISSUER = 2;\n    uint8 public constant ROLE_EXCHANGE = 4;\n    uint8 public constant ROLE_TRANSFER_AGENT = 8;\n\n    function __ServiceConsumer_init() public virtual onlyInitializing {\n        __Ownable_init(msg.sender);\n    }\n\n    modifier onlyMaster {\n        if (owner() != msg.sender) require(getTrustService().getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    /**\n     * @dev Allow invoking functions only by the users who have the MASTER role or the ISSUER role or the TRANSFER AGENT role.\n     */\n    modifier onlyIssuerOrTransferAgentOrAbove() {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_TRANSFER_AGENT || role == ROLE_ISSUER || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyIssuerOrAbove {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_ISSUER || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyTransferAgentOrAbove {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_TRANSFER_AGENT || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyExchangeOrAbove {\n        IDSTrustService trustManager = getTrustService();\n        uint8 role = trustManager.getRole(msg.sender);\n        require(role == ROLE_EXCHANGE || role == ROLE_ISSUER || role == ROLE_TRANSFER_AGENT || role == ROLE_MASTER, \"Insufficient trust level\");\n        _;\n    }\n\n    modifier onlyToken {\n        require(msg.sender == getDSService(DS_TOKEN), \"This function can only called by the associated token\");\n        _;\n    }\n\n    modifier onlyRegistry {\n        require(msg.sender == getDSService(REGISTRY_SERVICE), \"This function can only called by the registry service\");\n        _;\n    }\n\n    modifier onlyIssuerOrAboveOrToken {\n        if (msg.sender != getDSService(DS_TOKEN)) {\n            IDSTrustService trustManager = IDSTrustService(getDSService(TRUST_SERVICE));\n            require(trustManager.getRole(msg.sender) == ROLE_ISSUER || trustManager.getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        }\n        _;\n    }\n\n    modifier onlyTransferAgentOrAboveOrToken {\n        if (msg.sender != getDSService(DS_TOKEN)) {\n            IDSTrustService trustManager = IDSTrustService(getDSService(TRUST_SERVICE));\n            require(trustManager.getRole(msg.sender) == ROLE_TRANSFER_AGENT || trustManager.getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        }\n        _;\n    }\n\n    modifier onlyOwnerOrIssuerOrAbove {\n        if(owner() != msg.sender) {\n            IDSTrustService trustManager = getTrustService();\n            require(trustManager.getRole(msg.sender) == ROLE_ISSUER || trustManager.getRole(msg.sender) == ROLE_MASTER, \"Insufficient trust level\");\n        }\n        _;\n    }\n\n    function getDSService(uint256 _serviceId) public view override returns (address) {\n        return services[_serviceId];\n    }\n\n    function setDSService(uint256 _serviceId, address _address) public override onlyMaster returns (bool) {\n        services[_serviceId] = _address;\n        emit DSServiceSet(_serviceId, _address);\n        return true;\n    }\n\n    function getToken() internal view returns (IDSToken) {\n        return IDSToken(getDSService(DS_TOKEN));\n    }\n\n    function getTrustService() internal view returns (IDSTrustService) {\n        return IDSTrustService(getDSService(TRUST_SERVICE));\n    }\n\n    function getWalletManager() internal view returns (IDSWalletManager) {\n        return IDSWalletManager(getDSService(WALLET_MANAGER));\n    }\n\n    function getLockManager() internal view returns (IDSLockManager) {\n        return IDSLockManager(getDSService(LOCK_MANAGER));\n    }\n\n    function getComplianceService() internal view returns (IDSComplianceService) {\n        return IDSComplianceService(getDSService(COMPLIANCE_SERVICE));\n    }\n\n    function getRegistryService() internal view returns (IDSRegistryService) {\n        return IDSRegistryService(getDSService(REGISTRY_SERVICE));\n    }\n\n    function getComplianceConfigurationService() internal view returns (IDSComplianceConfigurationService) {\n        return IDSComplianceConfigurationService(getDSService(COMPLIANCE_CONFIGURATION_SERVICE));\n    }\n\n    function getRebasingProvider() internal view returns (ISecuritizeRebasingProvider) {\n        return ISecuritizeRebasingProvider(getDSService(REBASING_PROVIDER));\n    }\n\n    function getBlackListManager() internal view returns (IDSBlackListManager) {\n        return IDSBlackListManager(getDSService(BLACKLIST_MANAGER));\n    }\n}\n"},"contracts/compliance/IDSLockManager.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSLockManager {\n\n    function initialize() public virtual;\n\n    modifier validLock(uint256 _valueLocked, uint256 _releaseTime) {\n        require(_valueLocked > 0, \"Value is zero\");\n        require(_releaseTime == 0 || _releaseTime > uint256(block.timestamp), \"Release time is in the past\");\n        _;\n    }\n\n    event Locked(address indexed who, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n    event Unlocked(address indexed who, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n\n    event HolderLocked(string holderId, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n    event HolderUnlocked(string holderId, uint256 value, uint256 indexed reason, string reasonString, uint256 releaseTime);\n    /**\n     * @dev creates a lock record for wallet address\n     * @param _to address to lock the tokens at\n     * @param _valueLocked value of tokens to lock\n     * @param _reason reason for lock\n     * @param _releaseTime timestamp to release the lock (or 0 for locks which can only released by an unlockTokens call)\n     * Note: The user MAY have at a certain time more locked tokens than actual tokens\n     */\n\n    function addManualLockRecord(\n        address _to,\n        uint256 _valueLocked,\n        string calldata _reason,\n        uint256 _releaseTime /*issuerOrAboveOrToken*/\n    ) public virtual;\n\n    /**\n     * @dev creates a lock record for investor Id\n     * @param _investor investor id to lock the tokens at\n     * @param _valueLocked value of tokens to lock\n     * @param _reasonCode reason code for lock\n     * @param _reasonString reason for lock\n     * @param _releaseTime timestamp to release the lock (or 0 for locks which can only released by an unlockTokens call)\n     * Note: The user MAY have at a certain time more locked tokens than actual tokens\n     */\n\n    function createLockForInvestor(\n        string memory _investor,\n        uint256 _valueLocked,\n        uint256 _reasonCode,\n        string calldata _reasonString,\n        uint256 _releaseTime /*onlyIssuerOrAboveOrToken*/\n    ) public virtual;\n\n    /**\n     * @dev Releases a specific lock record for a wallet\n     * @param _to address to release the tokens for\n     * @param _lockIndex the index of the lock to remove\n     *\n     * note - this may change the order of the locks on an address, so if iterating the iteration should be restarted.\n     * @return true on success\n     */\n    function removeLockRecord(\n        address _to,\n        uint256 _lockIndex /*issuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Releases a specific lock record for a investor\n     * @param _investorId investor id to release the tokens for\n     * @param _lockIndex the index of the lock to remove\n     *\n     * note - this may change the order of the locks on an address, so if iterating the iteration should be restarted.\n     * @return true on success\n     */\n    function removeLockRecordForInvestor(\n        string memory _investorId,\n        uint256 _lockIndex /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Get number of locks currently associated with an address\n     * @param _who address to get count for\n     *\n     * @return number of locks\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n    function lockCount(address _who) public view virtual returns (uint256);\n\n    /**\n     * @dev Get number of locks currently associated with a investor\n     * @param _investorId investor id to get count for\n     *\n     * @return number of locks\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n\n    function lockCountForInvestor(string calldata _investorId) public view virtual returns (uint256);\n\n    /**\n     * @dev Get details of a specific lock associated with an address\n     * can be used to iterate through the locks of a user\n     * @param _who address to get token lock for\n     * @param _lockIndex the 0 based index of the lock.\n     * @return reasonCode the reason code\n     * @return reasonString the reason for the lock\n     * @return value the value of tokens locked\n     * @return autoReleaseTime the timestamp in which the lock will be inactive (or 0 if it's always active until removed)\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n    function lockInfo(address _who, uint256 _lockIndex) public view virtual returns (uint256 reasonCode, string memory reasonString, uint256 value, uint256 autoReleaseTime);\n\n    /**\n     * @dev Get details of a specific lock associated with a investor\n     * can be used to iterate through the locks of a user\n     * @param _investorId investorId to get token lock for\n     * @param _lockIndex the 0 based index of the lock.\n     * @return reasonCode the reason code\n     * @return reasonString the reason for the lock\n     * @return value the value of tokens locked\n     * @return autoReleaseTime the timestamp in which the lock will be inactive (or 0 if it's always active until removed)\n     *\n     * Note - a lock can be inactive (due to its time expired) but still exists for a specific address\n     */\n    function lockInfoForInvestor(\n        string memory _investorId,\n        uint256 _lockIndex\n    ) public view virtual  returns (uint256 reasonCode, string memory reasonString, uint256 value, uint256 autoReleaseTime);\n\n    /**\n     * @dev get total number of transferable tokens for a wallet, at a certain time\n     * @param _who address to get number of transferable tokens for\n     * @param _time time to calculate for\n     */\n    function getTransferableTokens(address _who, uint256 _time) public view virtual returns (uint256);\n\n    /**\n     * @dev get total number of transferable tokens for a investor, at a certain time\n     * @param _investorId investor id\n     * @param _time time to calculate for\n     */\n    function getTransferableTokensForInvestor(string memory _investorId, uint256 _time) public view virtual returns (uint256);\n\n    /**\n     * @dev pause investor\n     * @param _investorId investor id\n     */\n    function lockInvestor(\n        string calldata _investorId /*issuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev unpauses investor\n     * @param _investorId investor id\n     */\n    function unlockInvestor(\n        string calldata _investorId /*issuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Returns true if paused, otherwise false\n     * @param _investorId investor id\n     */\n    function isInvestorLocked(string calldata _investorId) public view virtual returns (bool);\n\n    /**\n     * @dev set investor to liquidate only mode\n     * @param _investorId investor id\n     * @param _enabled true to enable, false to disable\n     */\n    function setInvestorLiquidateOnly(string memory _investorId, bool _enabled) public virtual returns (bool);\n\n    /**\n     * @dev Returns true if the investor is in liquidate only mode\n     * @param _investorId investor id\n     */\n    function isInvestorLiquidateOnly(string calldata _investorId) public view virtual returns (bool);\n}\n"},"@openzeppelin/contracts/utils/Errors.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Collection of common custom errors used in multiple contracts\n *\n * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.\n * It is recommended to avoid relying on the error API for critical functionality.\n *\n * _Available since v5.1._\n */\nlibrary Errors {\n    /**\n     * @dev The ETH balance of the account is not enough to perform the operation.\n     */\n    error InsufficientBalance(uint256 balance, uint256 needed);\n\n    /**\n     * @dev A call to an address target failed. The target may have reverted.\n     */\n    error FailedCall();\n\n    /**\n     * @dev The deployment failed.\n     */\n    error FailedDeployment();\n\n    /**\n     * @dev A necessary precompile is missing.\n     */\n    error MissingPrecompile(address);\n}\n"},"contracts/service/IDSServiceConsumer.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSServiceConsumer {\n    uint256 public constant TRUST_SERVICE = 1;\n    uint256 public constant DS_TOKEN = 2;\n    uint256 public constant REGISTRY_SERVICE = 4;\n    uint256 public constant COMPLIANCE_SERVICE = 8;\n    uint256 public constant UNUSED_1 = 16;\n    uint256 public constant WALLET_MANAGER = 32;\n    uint256 public constant LOCK_MANAGER = 64;\n    uint256 public constant DEPRECATED_PARTITIONS_MANAGER = 128;\n    uint256 public constant COMPLIANCE_CONFIGURATION_SERVICE = 256;\n    uint256 public constant TOKEN_ISSUER = 512;\n    uint256 public constant WALLET_REGISTRAR = 1024;\n    uint256 public constant DEPRECATED_OMNIBUS_TBE_CONTROLLER = 2048; // Deprecated, keep for backward compatibility\n    uint256 public constant TRANSACTION_RELAYER = 4096;\n    uint256 public constant DEPRECATED_TOKEN_REALLOCATOR = 8192; // Deprecated, keep for backward compatibility\n    uint256 public constant DEPRECATED_ISSUER_MULTICALL = 0;\n    uint256 public constant DEPRECATED_TA_MULTICALL = 0;\n    uint256 public constant DEPRECATED_SECURITIZE_SWAP = 16384;\n    uint256 public constant REBASING_PROVIDER = 8196;\n    uint256 public constant BLACKLIST_MANAGER = 8197;\n\n    function getDSService(uint256 _serviceId) public view virtual returns (address);\n\n    function setDSService(uint256 _serviceId, address _address /*onlyMaster*/) public virtual returns (bool);\n\n    event DSServiceSet(uint256 serviceId, address serviceAddress);\n}\n"},"@openzeppelin/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/Address.sol)\n\npragma solidity ^0.8.20;\n\nimport {Errors} from \"./Errors.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev There's no code at `target` (it is not a contract).\n     */\n    error AddressEmptyCode(address target);\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        if (address(this).balance < amount) {\n            revert Errors.InsufficientBalance(address(this).balance, amount);\n        }\n\n        (bool success, bytes memory returndata) = recipient.call{value: amount}(\"\");\n        if (!success) {\n            _revert(returndata);\n        }\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason or custom error, it is bubbled\n     * up by this function (like regular Solidity function calls). However, if\n     * the call reverted with no returned reason, this function reverts with a\n     * {Errors.FailedCall} error.\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        if (address(this).balance < value) {\n            revert Errors.InsufficientBalance(address(this).balance, value);\n        }\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\n     * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case\n     * of an unsuccessful call.\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata\n    ) internal view returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            // only check if target is a contract if the call was successful and the return data is empty\n            // otherwise we already know that it was a contract\n            if (returndata.length == 0 && target.code.length == 0) {\n                revert AddressEmptyCode(target);\n            }\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\n     * revert reason or with a default {Errors.FailedCall} error.\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (!success) {\n            _revert(returndata);\n        } else {\n            return returndata;\n        }\n    }\n\n    /**\n     * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.\n     */\n    function _revert(bytes memory returndata) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            assembly (\"memory-safe\") {\n                revert(add(returndata, 0x20), mload(returndata))\n            }\n        } else {\n            revert Errors.FailedCall();\n        }\n    }\n}\n"},"contracts/compliance/IDSWalletManager.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSWalletManager {\n\n    function initialize() public virtual;\n\n    // Special wallets constants\n    uint8 public constant NONE = 0;\n    uint8 public constant ISSUER = 1;\n    uint8 public constant PLATFORM = 2;\n    uint8 public constant EXCHANGE = 4;\n\n    /**\n     * @dev should be emitted when a special wallet is added.\n     */\n    event DSWalletManagerSpecialWalletAdded(address wallet, uint8 walletType, address sender);\n    /**\n     * @dev should be emitted when a special wallet is removed.\n     */\n    event DSWalletManagerSpecialWalletRemoved(address wallet, uint8 walletType, address sender);\n    /**\n     * @dev should be emitted when the number of reserved slots is set for a wallet.\n     */\n    event DSWalletManagerReservedSlotsSet(address wallet, string country, uint8 accreditationStatus, uint256 slots, address sender);\n\n    /**\n     * @dev Sets a wallet to be an special wallet. (internal)\n     * @param _wallet The address of the wallet.\n     * @param _type The type of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function setSpecialWallet(address _wallet, uint8 _type) internal virtual returns (bool);\n\n    /**\n     * @dev gets a wallet type\n     * @param _wallet the address of the wallet to check.\n     */\n    function getWalletType(address _wallet) public view virtual returns (uint8);\n\n    /**\n     * @dev Returns true if it is platform wallet\n     * @param _wallet the address of the wallet to check.\n     */\n    function isPlatformWallet(address _wallet) external view virtual returns (bool);\n\n    /**\n     * @dev Returns true if it is special wallet\n     * @param _wallet the address of the wallet to check.\n     */\n    function isSpecialWallet(address _wallet) external view virtual returns (bool);\n\n    /**\n     * @dev Returns true if it is issuer special wallet\n     * @param _wallet the address of the wallet to check.\n     */\n    function isIssuerSpecialWallet(address _wallet) external view virtual returns (bool);\n\n    /**\n     * @dev Sets a wallet to be an issuer wallet.\n     * @param _wallet The address of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addIssuerWallet(\n        address _wallet /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Sets an array of wallets to be issuer wallets.\n     * @param _wallets The address of the wallets.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addIssuerWallets(address[] calldata _wallets) public virtual returns (bool);\n\n    /**\n     * @dev Sets a wallet to be a platform wallet.\n     * @param _wallet The address of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addPlatformWallet(\n        address _wallet /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    /**\n     * @dev Sets an array of wallets to be platforms wallet.\n     * @param _wallets The address of the wallets.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addPlatformWallets(address[] calldata _wallets) public virtual returns (bool);\n\n    /**\n     * @dev Sets a wallet to be an exchange wallet.\n     * @param _wallet The address of the wallet.\n     * @param _owner The address of the owner.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function addExchangeWallet(address _wallet, address _owner) public virtual returns (bool);\n\n    /**\n     * @dev Removes a special wallet.\n     * @param _wallet The address of the wallet.\n     * @return A boolean that indicates if the operation was successful.\n     */\n    function removeSpecialWallet(\n        address _wallet /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n}\n"},"contracts/registry/IDSRegistryService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\nabstract contract IDSRegistryService {\n\n    function initialize() public virtual;\n\n    event DSRegistryServiceInvestorAdded(string investorId, address sender);\n    event DSRegistryServiceInvestorRemoved(string investorId, address sender);\n    event DSRegistryServiceInvestorCountryChanged(string investorId, string country, address sender);\n    event DSRegistryServiceInvestorAttributeChanged(string investorId, uint256 attributeId, uint256 value, uint256 expiry, string proofHash, address sender);\n    event DSRegistryServiceWalletAdded(address wallet, string investorId, address sender);\n    event DSRegistryServiceWalletRemoved(address wallet, string investorId, address sender);\n\n    uint8 public constant NONE = 0;\n    uint8 public constant KYC_APPROVED = 1;\n    uint8 public constant ACCREDITED = 2;\n    uint8 public constant QUALIFIED = 4;\n    uint8 public constant PROFESSIONAL = 8;\n\n    uint8 public constant PENDING = 0;\n    uint8 public constant APPROVED = 1;\n    uint8 public constant REJECTED = 2;\n\n    uint8 public constant EXCHANGE = 4;\n\n    modifier investorExists(string memory _id) {\n        require(isInvestor(_id), \"Unknown investor\");\n        _;\n    }\n\n    modifier newInvestor(string memory _id) {\n        require(!CommonUtils.isEmptyString(_id), \"Investor id must not be empty\");\n        require(!isInvestor(_id), \"Investor already exists\");\n        _;\n    }\n\n    modifier walletExists(address _address) {\n        require(isWallet(_address), \"Unknown wallet\");\n        _;\n    }\n\n    modifier newWallet(address _address) {\n        require(!isWallet(_address), \"Wallet already exists\");\n        _;\n    }\n\n    modifier walletBelongsToInvestor(address _address, string memory _id) {\n        require(CommonUtils.isEqualString(getInvestor(_address), _id), \"Wallet does not belong to investor\");\n        _;\n    }\n\n    function registerInvestor(\n        string calldata _id,\n        string calldata _collision_hash /*onlyExchangeOrAbove newInvestor(_id)*/\n    ) public virtual returns (bool);\n\n    function updateInvestor(\n        string calldata _id,\n        string calldata _collisionHash,\n        string memory _country,\n        address[] memory _wallets,\n        uint8[] memory _attributeIds,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations /*onlyIssuerOrAbove*/\n    ) public virtual returns (bool);\n\n    function removeInvestor(\n        string calldata _id /*onlyExchangeOrAbove investorExists(_id)*/\n    ) public virtual returns (bool);\n\n    function setCountry(\n        string calldata _id,\n        string memory _country /*onlyExchangeOrAbove investorExists(_id)*/\n    ) public virtual returns (bool);\n\n    function getCountry(string memory _id) public view virtual returns (string memory);\n\n    function getCollisionHash(string calldata _id) public view virtual returns (string memory);\n\n    function setAttribute(\n        string calldata _id,\n        uint8 _attributeId,\n        uint256 _value,\n        uint256 _expiry,\n        string memory _proofHash /*onlyExchangeOrAbove investorExists(_id)*/\n    ) public virtual returns (bool);\n\n    function getAttributeValue(string memory _id, uint8 _attributeId) public view virtual returns (uint256);\n\n    function getAttributeExpiry(string memory _id, uint8 _attributeId) public view virtual returns (uint256);\n\n    function getAttributeProofHash(string memory _id, uint8 _attributeId) public view virtual returns (string memory);\n\n    function addWallet(\n        address _address,\n        string memory _id /*onlyExchangeOrAbove newWallet(_address)*/\n    ) public virtual returns (bool);\n\n\n    function removeWallet(\n        address _address,\n        string memory _id /*onlyExchangeOrAbove walletExists walletBelongsToInvestor(_address, _id)*/\n    ) public virtual returns (bool);\n\n    function getInvestor(address _address) public view virtual returns (string memory);\n\n    function getInvestorDetails(address _address) public view virtual returns (string memory, string memory);\n\n    function getInvestorDetailsFull(string memory _id)\n        public\n        view\n        virtual\n        returns (string memory, uint256[] memory, uint256[] memory, string memory, string memory, string memory, string memory);\n\n    function isInvestor(string memory _id) public view virtual returns (bool);\n\n    function isWallet(address _address) public view virtual returns (bool);\n\n    function isAccreditedInvestor(string calldata _id) external view virtual returns (bool);\n\n    function isQualifiedInvestor(string calldata _id) external view virtual returns (bool);\n\n    function isAccreditedInvestor(address _wallet) external view virtual returns (bool);\n\n    function isQualifiedInvestor(address _wallet) external view virtual returns (bool);\n\n    function getInvestors(address _from, address _to) external view virtual returns (string memory, string memory);\n}\n"},"contracts/compliance/IDSBlackListManager.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\n/**\n * @title Interface for BlackListManager\n *\n * This interface defines functionality for managing blacklisted wallets.\n * Blacklisted wallets are prevented from receiving tokens through transfers or issuances.\n */\nabstract contract IDSBlackListManager {\n    function initialize() public virtual;\n\n    // Events\n    event WalletAddedToBlacklist(address indexed wallet, string reason, address indexed admin);\n    event WalletRemovedFromBlacklist(address indexed wallet, address indexed admin);\n\n    // Custom errors\n    /// @dev Thrown when a wallet is already blacklisted\n    /// @custom:selector 0xb59c1958\n    error WalletAlreadyBlacklisted();\n    /// @dev Thrown when a wallet is not blacklisted\n    /// @custom:selector 0xfae0e716\n    error WalletNotBlacklisted();\n    /// @dev Thrown when the zero address is used\n    /// @custom:selector 0x14c880ca\n    error ZeroAddressInvalid();\n    /// @dev Thrown when the lengths of the arrays do not match\n    /// @custom:selector 0xfc235960\n    error ArraysLengthMismatch();\n\n    // View functions\n    function isBlacklisted(address _wallet) external view virtual returns (bool);\n\n    function getBlacklistedWalletsCount() external view virtual returns (uint256);\n\n    function getBlacklistedWallets() external view virtual returns (address[] memory);\n\n    function getBlacklistReason(address _wallet) external view virtual returns (string memory);\n\n    // State-changing functions\n    function addToBlacklist(address _wallet, string calldata _reason) external virtual returns (bool);\n\n    function removeFromBlacklist(address _wallet) external virtual returns (bool);\n}\n"},"@openzeppelin/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"@openzeppelin/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct Int256Slot {\n        int256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"contracts/compliance/IDSComplianceService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSComplianceService {\n\n    uint256 internal constant NONE = 0;\n    uint256 internal constant US = 1;\n    uint256 internal constant EU = 2;\n    uint256 internal constant FORBIDDEN = 4;\n    uint256 internal constant JP = 8;\n    string internal constant TOKEN_PAUSED = \"Token Paused\";\n    string internal constant NOT_ENOUGH_TOKENS = \"Not Enough Tokens\";\n    string internal constant TOKENS_LOCKED = \"Tokens Locked\";\n    string internal constant WALLET_NOT_IN_REGISTRY_SERVICE = \"Wallet not in registry Service\";\n    string internal constant DESTINATION_RESTRICTED = \"Destination restricted\";\n    string internal constant VALID = \"Valid\";\n    string internal constant HOLD_UP = \"Under lock-up\";\n    string internal constant ONLY_FULL_TRANSFER = \"Only Full Transfer\";\n    string internal constant FLOWBACK = \"Flowback\";\n    string internal constant MAX_INVESTORS_IN_CATEGORY = \"Max Investors in category\";\n    string internal constant AMOUNT_OF_TOKENS_UNDER_MIN = \"Amount of tokens under min\";\n    string internal constant AMOUNT_OF_TOKENS_ABOVE_MAX = \"Amount of tokens above max\";\n    string internal constant ONLY_ACCREDITED = \"Only accredited\";\n    string internal constant ONLY_US_ACCREDITED = \"Only us accredited\";\n    string internal constant NOT_ENOUGH_INVESTORS = \"Not enough investors\";\n    string internal constant MAX_AUTHORIZED_SECURITIES_EXCEEDED = \"Max authorized securities exceeded\";\n\n    function initialize() public virtual;\n\n    function adjustInvestorCountsAfterCountryChange(\n        string memory _id,\n        string memory _country,\n        string memory _prevCountry\n    ) public virtual returns (bool);\n\n    //*****************************************\n    // TOKEN ACTION VALIDATIONS\n    //*****************************************\n\n    function validateTransfer(\n        address _from,\n        address _to,\n        uint256 _value /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function validateTransfer(\n        address _from,\n        address _to,\n        uint256 _value, /*onlyToken*/\n        bool _pausedToken,\n        uint256 _balanceFrom\n    ) public virtual returns (bool);\n\n    function validateIssuance(\n        address _to,\n        uint256 _value,\n        uint256 _issuanceTime /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function validateBurn(\n        address _who,\n        uint256 _value /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function validateSeize(\n        address _from,\n        address _to,\n        uint256 _value /*onlyToken*/\n    ) public virtual returns (bool);\n\n    function preIssuanceCheck(address _to, uint256 _value) public view virtual returns (uint256 code, string memory reason);\n\n    function preTransferCheck(\n        address _from,\n        address _to,\n        uint256 _value\n    ) public view virtual returns (uint256 code, string memory reason);\n\n    function newPreTransferCheck(\n        address _from,\n        address _to,\n        uint256 _value,\n        uint256 _balanceFrom,\n        bool _pausedToken\n    ) public view virtual returns (uint256 code, string memory reason);\n\n    function preInternalTransferCheck(\n        address _from,\n        address _to,\n        uint256 _value\n    ) public view virtual returns (uint256 code, string memory reason);\n\n    function validateIssuanceTime(uint256 _issuanceTime) public view virtual returns (uint256 issuanceTime);\n\n    function getComplianceTransferableTokens(\n        address _who,\n        uint256 _time,\n        uint64 _lockTime\n    ) public view virtual returns (uint256);\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/interfaces/IERC1967.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1967.sol)\n\npragma solidity >=0.4.11;\n\n/**\n * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.\n */\ninterface IERC1967 {\n    /**\n     * @dev Emitted when the implementation is upgraded.\n     */\n    event Upgraded(address indexed implementation);\n\n    /**\n     * @dev Emitted when the admin account has changed.\n     */\n    event AdminChanged(address previousAdmin, address newAdmin);\n\n    /**\n     * @dev Emitted when the beacon is changed.\n     */\n    event BeaconUpgraded(address indexed beacon);\n}\n"},"@openzeppelin/contracts/proxy/beacon/IBeacon.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (proxy/beacon/IBeacon.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\n */\ninterface IBeacon {\n    /**\n     * @dev Must return an address that can be used as a delegate call target.\n     *\n     * {UpgradeableBeacon} will check that this address is a contract.\n     */\n    function implementation() external view returns (address);\n}\n"},"contracts/data-stores/ServiceConsumerDataStore.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\ncontract ServiceConsumerDataStore {\n\n    mapping(uint256 serviceId => address service) internal services;\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"},"contracts/rebasing/ISecuritizeRebasingProvider.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\n/**\n * @title ISecuritizeRebasingProvider\n * @dev Defines a common interface to get Rebasing multiplier\n */\ninterface ISecuritizeRebasingProvider {\n    /**\n     * @dev Emitted when owner updates multiplier.\n     * @param oldValue Old multiplier value\n     * @param newValue New multiplier value\n     */\n    event RebasingRateUpdated(uint256 oldValue, uint256 newValue);\n\n    /**\n     * @dev Proxy Initializer.\n     * @param _multiplier the initial rebasing multiplier value\n     * @param _tokenDecimals the token decimals for conversion calculations\n    */\n    function initialize(uint256 _multiplier, uint8 _tokenDecimals) external;\n\n\n    /**\n     * @dev Set rebasing multiplier. It is expressed with the same decimal numbers as stable coin\n     */\n    function setMultiplier(uint256 _multiplier) external;\n\n    /**\n     * @dev The asset:rebasing multiplier.\n     * @return The asset:rebasing multiplier.\n     */\n    function multiplier() external view returns (uint256);\n\n    /**\n     * @dev Convert tokens to shares using the current multiplier and token decimals.\n     * @param _tokens The amount of tokens to convert\n     * @return shares The equivalent amount in shares\n     */\n    function convertTokensToShares(uint256 _tokens) external view returns (uint256 shares);\n\n    /**\n     * @dev Convert shares to tokens using the current multiplier and token decimals.\n     * @param _shares The amount of shares to convert\n     * @return tokens The equivalent amount in tokens\n     */\n    function convertSharesToTokens(uint256 _shares) external view returns (uint256 tokens);\n}\n"},"@openzeppelin/contracts/interfaces/draft-IERC1822.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC1822.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\n * proxy whose upgrades are fully controlled by the current implementation.\n */\ninterface IERC1822Proxiable {\n    /**\n     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\n     * address.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy.\n     */\n    function proxiableUUID() external view returns (bytes32);\n}\n"},"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (proxy/ERC1967/ERC1967Utils.sol)\n\npragma solidity ^0.8.21;\n\nimport {IBeacon} from \"../beacon/IBeacon.sol\";\nimport {IERC1967} from \"../../interfaces/IERC1967.sol\";\nimport {Address} from \"../../utils/Address.sol\";\nimport {StorageSlot} from \"../../utils/StorageSlot.sol\";\n\n/**\n * @dev This library provides getters and event emitting update functions for\n * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots.\n */\nlibrary ERC1967Utils {\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev The `implementation` of the proxy is invalid.\n     */\n    error ERC1967InvalidImplementation(address implementation);\n\n    /**\n     * @dev The `admin` of the proxy is invalid.\n     */\n    error ERC1967InvalidAdmin(address admin);\n\n    /**\n     * @dev The `beacon` of the proxy is invalid.\n     */\n    error ERC1967InvalidBeacon(address beacon);\n\n    /**\n     * @dev An upgrade function sees `msg.value > 0` that may be lost.\n     */\n    error ERC1967NonPayable();\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n    function getImplementation() internal view returns (address) {\n        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the ERC-1967 implementation slot.\n     */\n    function _setImplementation(address newImplementation) private {\n        if (newImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(newImplementation);\n        }\n        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\n    }\n\n    /**\n     * @dev Performs implementation upgrade with additional setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) internal {\n        _setImplementation(newImplementation);\n        emit IERC1967.Upgraded(newImplementation);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(newImplementation, data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Storage slot with the admin of the contract.\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\n\n    /**\n     * @dev Returns the current admin.\n     *\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using\n     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\n     */\n    function getAdmin() internal view returns (address) {\n        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new address in the ERC-1967 admin slot.\n     */\n    function _setAdmin(address newAdmin) private {\n        if (newAdmin == address(0)) {\n            revert ERC1967InvalidAdmin(address(0));\n        }\n        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\n    }\n\n    /**\n     * @dev Changes the admin of the proxy.\n     *\n     * Emits an {IERC1967-AdminChanged} event.\n     */\n    function changeAdmin(address newAdmin) internal {\n        emit IERC1967.AdminChanged(getAdmin(), newAdmin);\n        _setAdmin(newAdmin);\n    }\n\n    /**\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\n     * This is the keccak-256 hash of \"eip1967.proxy.beacon\" subtracted by 1.\n     */\n    // solhint-disable-next-line private-vars-leading-underscore\n    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\n\n    /**\n     * @dev Returns the current beacon.\n     */\n    function getBeacon() internal view returns (address) {\n        return StorageSlot.getAddressSlot(BEACON_SLOT).value;\n    }\n\n    /**\n     * @dev Stores a new beacon in the ERC-1967 beacon slot.\n     */\n    function _setBeacon(address newBeacon) private {\n        if (newBeacon.code.length == 0) {\n            revert ERC1967InvalidBeacon(newBeacon);\n        }\n\n        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\n\n        address beaconImplementation = IBeacon(newBeacon).implementation();\n        if (beaconImplementation.code.length == 0) {\n            revert ERC1967InvalidImplementation(beaconImplementation);\n        }\n    }\n\n    /**\n     * @dev Change the beacon and trigger a setup call if data is nonempty.\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\n     * to avoid stuck value in the contract.\n     *\n     * Emits an {IERC1967-BeaconUpgraded} event.\n     *\n     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\n     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\n     * efficiency.\n     */\n    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\n        _setBeacon(newBeacon);\n        emit IERC1967.BeaconUpgraded(newBeacon);\n\n        if (data.length > 0) {\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\n        } else {\n            _checkNonPayable();\n        }\n    }\n\n    /**\n     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\n     * if an upgrade doesn't perform an initialization call.\n     */\n    function _checkNonPayable() private {\n        if (msg.value > 0) {\n            revert ERC1967NonPayable();\n        }\n    }\n}\n"},"contracts/compliance/IDSComplianceConfigurationService.sol":{"content":"/**\n * Copyright 2025 Securitize Inc. All rights reserved.\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npragma solidity 0.8.22;\n\nabstract contract IDSComplianceConfigurationService {\n\n    function initialize() public virtual;\n\n    event DSComplianceUIntRuleSet(string ruleName, uint256 prevValue, uint256 newValue);\n    event DSComplianceBoolRuleSet(string ruleName, bool prevValue, bool newValue);\n    event DSComplianceStringToUIntMapRuleSet(string ruleName, string keyValue, uint256 prevValue, uint256 newValue);\n\n    function getCountryCompliance(string calldata _country) public view virtual returns (uint256);\n\n    function setCountriesCompliance(string[] calldata _countries, uint256[] calldata _values) public virtual;\n\n    function setCountryCompliance(\n        string calldata _country,\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getTotalInvestorsLimit() public view virtual returns (uint256);\n\n    function setTotalInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinUSTokens() public view virtual returns (uint256);\n\n    function setMinUSTokens(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinEUTokens() public view virtual returns (uint256);\n\n    function setMinEUTokens(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getUSInvestorsLimit() public view virtual returns (uint256);\n\n    function setUSInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getJPInvestorsLimit() public view virtual returns (uint256);\n\n    function setJPInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getUSAccreditedInvestorsLimit() public view virtual returns (uint256);\n\n    function setUSAccreditedInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getNonAccreditedInvestorsLimit() public view virtual returns (uint256);\n\n    function setNonAccreditedInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMaxUSInvestorsPercentage() public view virtual returns (uint256);\n\n    function setMaxUSInvestorsPercentage(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getBlockFlowbackEndTime() public view virtual returns (uint256);\n\n    function setBlockFlowbackEndTime(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getNonUSLockPeriod() public view virtual returns (uint256);\n\n    function setNonUSLockPeriod(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinimumTotalInvestors() public view virtual returns (uint256);\n\n    function setMinimumTotalInvestors(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMinimumHoldingsPerInvestor() public view virtual returns (uint256);\n\n    function setMinimumHoldingsPerInvestor(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getMaximumHoldingsPerInvestor() public view virtual returns (uint256);\n\n    function setMaximumHoldingsPerInvestor(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getEURetailInvestorsLimit() public view virtual returns (uint256);\n\n    function setEURetailInvestorsLimit(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getUSLockPeriod() public view virtual returns (uint256);\n\n    function setUSLockPeriod(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getForceFullTransfer() public view virtual returns (bool);\n\n    function setForceFullTransfer(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getForceAccredited() public view virtual returns (bool);\n\n    function setForceAccredited(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function setForceAccreditedUS(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getForceAccreditedUS() public view virtual returns (bool);\n\n    function setWorldWideForceFullTransfer(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getWorldWideForceFullTransfer() public view virtual returns (bool);\n\n    function getAuthorizedSecurities() public view virtual returns (uint256);\n\n    function setAuthorizedSecurities(\n        uint256 _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getDisallowBackDating() public view virtual returns (bool);\n\n    function setDisallowBackDating(\n        bool _value /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function setAll(\n        uint256[] calldata _uint_values,\n        bool[] calldata _bool_values /*onlyTransferAgentOrAbove*/\n    ) public virtual;\n\n    function getAll() public view virtual returns (uint256[] memory, bool[] memory);\n}\n"},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {ContextUpgradeable} from \"../utils/ContextUpgradeable.sol\";\nimport {Initializable} from \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable\n    struct OwnableStorage {\n        address _owner;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Ownable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;\n\n    function _getOwnableStorage() private pure returns (OwnableStorage storage $) {\n        assembly {\n            $.slot := OwnableStorageLocation\n        }\n    }\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    function __Ownable_init(address initialOwner) internal onlyInitializing {\n        __Ownable_init_unchained(initialOwner);\n    }\n\n    function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        OwnableStorage storage $ = _getOwnableStorage();\n        return $._owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        OwnableStorage storage $ = _getOwnableStorage();\n        address oldOwner = $._owner;\n        $._owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```solidity\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n *\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Storage of the initializable contract.\n     *\n     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\n     * when using with upgradeable contracts.\n     *\n     * @custom:storage-location erc7201:openzeppelin.storage.Initializable\n     */\n    struct InitializableStorage {\n        /**\n         * @dev Indicates that the contract has been initialized.\n         */\n        uint64 _initialized;\n        /**\n         * @dev Indicates that the contract is in the process of being initialized.\n         */\n        bool _initializing;\n    }\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.Initializable\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\n\n    /**\n     * @dev The contract is already initialized.\n     */\n    error InvalidInitialization();\n\n    /**\n     * @dev The contract is not initializing.\n     */\n    error NotInitializing();\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint64 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\n     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\n     * production.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        // Cache values to avoid duplicated sloads\n        bool isTopLevelCall = !$._initializing;\n        uint64 initialized = $._initialized;\n\n        // Allowed calls:\n        // - initialSetup: the contract is not in the initializing state and no previous version was\n        //                 initialized\n        // - construction: the contract is initialized at version 1 (no reinitialization) and the\n        //                 current contract is just being deployed\n        bool initialSetup = initialized == 0 && isTopLevelCall;\n        bool construction = initialized == 1 && address(this).code.length == 0;\n\n        if (!initialSetup && !construction) {\n            revert InvalidInitialization();\n        }\n        $._initialized = 1;\n        if (isTopLevelCall) {\n            $._initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            $._initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint64 version) {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing || $._initialized >= version) {\n            revert InvalidInitialization();\n        }\n        $._initialized = version;\n        $._initializing = true;\n        _;\n        $._initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        _checkInitializing();\n        _;\n    }\n\n    /**\n     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\n     */\n    function _checkInitializing() internal view virtual {\n        if (!_isInitializing()) {\n            revert NotInitializing();\n        }\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        // solhint-disable-next-line var-name-mixedcase\n        InitializableStorage storage $ = _getInitializableStorage();\n\n        if ($._initializing) {\n            revert InvalidInitialization();\n        }\n        if ($._initialized != type(uint64).max) {\n            $._initialized = type(uint64).max;\n            emit Initialized(type(uint64).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint64) {\n        return _getInitializableStorage()._initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _getInitializableStorage()._initializing;\n    }\n\n    /**\n     * @dev Pointer to storage slot. Allows integrators to override it with a custom storage location.\n     *\n     * NOTE: Consider following the ERC-7201 formula to derive storage locations.\n     */\n    function _initializableStorageSlot() internal pure virtual returns (bytes32) {\n        return INITIALIZABLE_STORAGE;\n    }\n\n    /**\n     * @dev Returns a pointer to the storage namespace.\n     */\n    // solhint-disable-next-line var-name-mixedcase\n    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\n        bytes32 slot = _initializableStorageSlot();\n        assembly {\n            $.slot := slot\n        }\n    }\n}\n"},"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/UUPSUpgradeable.sol)\n\npragma solidity ^0.8.22;\n\nimport {IERC1822Proxiable} from \"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\";\nimport {ERC1967Utils} from \"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\";\nimport {Initializable} from \"./Initializable.sol\";\n\n/**\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\n *\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\n * `UUPSUpgradeable` with a custom implementation of upgrades.\n *\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\n */\nabstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {\n    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\n    address private immutable __self = address(this);\n\n    /**\n     * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\n     * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\n     * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\n     * If the getter returns `\"5.0.0\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\n     * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\n     * during an upgrade.\n     */\n    string public constant UPGRADE_INTERFACE_VERSION = \"5.0.0\";\n\n    /**\n     * @dev The call is from an unauthorized context.\n     */\n    error UUPSUnauthorizedCallContext();\n\n    /**\n     * @dev The storage `slot` is unsupported as a UUID.\n     */\n    error UUPSUnsupportedProxiableUUID(bytes32 slot);\n\n    /**\n     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\n     * a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case\n     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\n     * function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\n     * fail.\n     */\n    modifier onlyProxy() {\n        _checkProxy();\n        _;\n    }\n\n    /**\n     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\n     * callable on the implementing contract but not through proxies.\n     */\n    modifier notDelegated() {\n        _checkNotDelegated();\n        _;\n    }\n\n    function __UUPSUpgradeable_init() internal onlyInitializing {\n    }\n\n    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\n    }\n    /**\n     * @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the\n     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\n     *\n     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\n     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\n     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\n     */\n    function proxiableUUID() external view virtual notDelegated returns (bytes32) {\n        return ERC1967Utils.IMPLEMENTATION_SLOT;\n    }\n\n    /**\n     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\n     * encoded in `data`.\n     *\n     * Calls {_authorizeUpgrade}.\n     *\n     * Emits an {Upgraded} event.\n     *\n     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\n     */\n    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\n        _authorizeUpgrade(newImplementation);\n        _upgradeToAndCallUUPS(newImplementation, data);\n    }\n\n    /**\n     * @dev Reverts if the execution is not performed via delegatecall or the execution\n     * context is not of a proxy with an ERC-1967 compliant implementation pointing to self.\n     */\n    function _checkProxy() internal view virtual {\n        if (\n            address(this) == __self || // Must be called through delegatecall\n            ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\n        ) {\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Reverts if the execution is performed via delegatecall.\n     * See {notDelegated}.\n     */\n    function _checkNotDelegated() internal view virtual {\n        if (address(this) != __self) {\n            // Must not be called through delegatecall\n            revert UUPSUnauthorizedCallContext();\n        }\n    }\n\n    /**\n     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\n     * {upgradeToAndCall}.\n     *\n     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\n     *\n     * ```solidity\n     * function _authorizeUpgrade(address) internal onlyOwner {}\n     * ```\n     */\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /**\n     * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\n     *\n     * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\n     * is expected to be the implementation slot in ERC-1967.\n     *\n     * Emits an {IERC1967-Upgraded} event.\n     */\n    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\n        try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\n            if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\n                revert UUPSUnsupportedProxiableUUID(slot);\n            }\n            ERC1967Utils.upgradeToAndCall(newImplementation, data);\n        } catch {\n            // The implementation is not UUPS\n            revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\n        }\n    }\n}\n"}},"language":"Solidity","settings":{"optimizer":{"runs":200,"enabled":true},"evmVersion":"paris"}},"stdJsonOutput":{"sources":{"contracts/token/IDSToken.sol":{"id":25},"contracts/utils/CommonUtils.sol":{"id":28},"contracts/issuance/TokenIssuer.sol":{"id":20},"contracts/utils/BaseDSContract.sol":{"id":27},"contracts/trust/IDSTrustService.sol":{"id":26},"contracts/issuance/IDSTokenIssuer.sol":{"id":19},"contracts/service/ServiceConsumer.sol":{"id":24},"contracts/compliance/IDSLockManager.sol":{"id":16},"@openzeppelin/contracts/utils/Errors.sol":{"id":11},"contracts/service/IDSServiceConsumer.sol":{"id":23},"@openzeppelin/contracts/utils/Address.sol":{"id":10},"contracts/compliance/IDSWalletManager.sol":{"id":17},"contracts/registry/IDSRegistryService.sol":{"id":22},"contracts/compliance/IDSBlackListManager.sol":{"id":13},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":5},"@openzeppelin/contracts/utils/StorageSlot.sol":{"id":12},"contracts/compliance/IDSComplianceService.sol":{"id":15},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":9},"@openzeppelin/contracts/interfaces/IERC1967.sol":{"id":4},"@openzeppelin/contracts/proxy/beacon/IBeacon.sol":{"id":8},"contracts/data-stores/ServiceConsumerDataStore.sol":{"id":18},"contracts/rebasing/ISecuritizeRebasingProvider.sol":{"id":21},"@openzeppelin/contracts/interfaces/draft-IERC1822.sol":{"id":6},"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol":{"id":7},"contracts/compliance/IDSComplianceConfigurationService.sol":{"id":14},"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol":{"id":3},"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol":{"id":0},"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol":{"id":1},"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol":{"id":2}},"contracts":{"contracts/issuance/TokenIssuer.sol":{"TokenIssuer":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AddressEmptyCode","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"ERC1967InvalidImplementation","type":"error","inputs":[{"name":"implementation","type":"address","internalType":"address"}]},{"name":"ERC1967NonPayable","type":"error","inputs":[]},{"name":"FailedCall","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"UUPSUnauthorizedCallContext","type":"error","inputs":[]},{"name":"UUPSUnsupportedProxiableUUID","type":"error","inputs":[{"name":"slot","type":"bytes32","internalType":"bytes32"}]},{"name":"DSServiceSet","type":"event","inputs":[{"name":"serviceId","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"serviceAddress","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"BLACKLIST_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"COMPLIANCE_CONFIGURATION_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"COMPLIANCE_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_ISSUER_MULTICALL","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_OMNIBUS_TBE_CONTROLLER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_PARTITIONS_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_SECURITIZE_SWAP","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_TA_MULTICALL","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DEPRECATED_TOKEN_REALLOCATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"DS_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"LOCK_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"REBASING_PROVIDER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"REGISTRY_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"ROLE_EXCHANGE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_ISSUER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_MASTER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_NONE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"ROLE_TRANSFER_AGENT","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"TOKEN_ISSUER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"TRANSACTION_RELAYER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"TRUST_SERVICE","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"UNUSED_1","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"UPGRADE_INTERFACE_VERSION","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"WALLET_MANAGER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"WALLET_REGISTRAR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"__BaseDSContract_init","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"__ServiceConsumer_init","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"getDSService","type":"function","inputs":[{"name":"_serviceId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"getImplementationAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"getInitializedVersion","type":"function","inputs":[],"outputs":[{"name":"","type":"uint64","internalType":"uint64"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"issueTokens","type":"function","inputs":[{"name":"_id","type":"string","internalType":"string"},{"name":"_to","type":"address","internalType":"address"},{"name":"_issuanceValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_reason","type":"string","internalType":"string"},{"name":"_locksValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_lockReleaseTimes","type":"uint64[]","internalType":"uint64[]"},{"name":"_collisionHash","type":"string","internalType":"string"},{"name":"_country","type":"string","internalType":"string"},{"name":"_attributeValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_attributeExpirations","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setDSService","type":"function","inputs":[{"name":"_serviceId","type":"uint256","internalType":"uint256"},{"name":"_address","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"ERC1967InvalidImplementation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC1967NonPayable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitialization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotInitializing\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UUPSUnauthorizedCallContext\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"UUPSUnsupportedProxiableUUID\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"serviceId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"serviceAddress\",\"type\":\"address\"}],\"name\":\"DSServiceSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"version\",\"type\":\"uint64\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BLACKLIST_MANAGER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COMPLIANCE_CONFIGURATION_SERVICE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COMPLIANCE_SERVICE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEPRECATED_ISSUER_MULTICALL\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEPRECATED_OMNIBUS_TBE_CONTROLLER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEPRECATED_PARTITIONS_MANAGER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEPRECATED_SECURITIZE_SWAP\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEPRECATED_TA_MULTICALL\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEPRECATED_TOKEN_REALLOCATOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DS_TOKEN\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"LOCK_MANAGER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REBASING_PROVIDER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REGISTRY_SERVICE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROLE_EXCHANGE\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROLE_ISSUER\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROLE_MASTER\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROLE_NONE\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"ROLE_TRANSFER_AGENT\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TOKEN_ISSUER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TRANSACTION_RELAYER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"TRUST_SERVICE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"UNUSED_1\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"UPGRADE_INTERFACE_VERSION\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WALLET_MANAGER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"WALLET_REGISTRAR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__BaseDSContract_init\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"__ServiceConsumer_init\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_serviceId\",\"type\":\"uint256\"}],\"name\":\"getDSService\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getImplementationAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getInitializedVersion\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_id\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"_issuanceValues\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"_reason\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"_locksValues\",\"type\":\"uint256[]\"},{\"internalType\":\"uint64[]\",\"name\":\"_lockReleaseTimes\",\"type\":\"uint64[]\"},{\"internalType\":\"string\",\"name\":\"_collisionHash\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_country\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"_attributeValues\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_attributeExpirations\",\"type\":\"uint256[]\"}],\"name\":\"issueTokens\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_serviceId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"setDSService\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"ERC1967InvalidImplementation(address)\":[{\"details\":\"The `implementation` of the proxy is invalid.\"}],\"ERC1967NonPayable()\":[{\"details\":\"An upgrade function sees `msg.value > 0` that may be lost.\"}],\"FailedCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"InvalidInitialization()\":[{\"details\":\"The contract is already initialized.\"}],\"NotInitializing()\":[{\"details\":\"The contract is not initializing.\"}],\"OwnableInvalidOwner(address)\":[{\"details\":\"The owner is not a valid owner account. (eg. `address(0)`)\"}],\"OwnableUnauthorizedAccount(address)\":[{\"details\":\"The caller account is not authorized to perform an operation.\"}],\"UUPSUnauthorizedCallContext()\":[{\"details\":\"The call is from an unauthorized context.\"}],\"UUPSUnsupportedProxiableUUID(bytes32)\":[{\"details\":\"The storage `slot` is unsupported as a UUID.\"}]},\"events\":{\"Initialized(uint64)\":{\"details\":\"Triggered when the contract has been initialized or reinitialized.\"},\"Upgraded(address)\":{\"details\":\"Emitted when the implementation is upgraded.\"}},\"kind\":\"dev\",\"methods\":{\"constructor\":{\"custom:oz-upgrades-unsafe-allow\":\"constructor\"},\"getImplementationAddress()\":{\"details\":\"returns proxy ERC1967 implementation address\"},\"getInitializedVersion()\":{\"details\":\"Returns the highest version that has been initialized. See {reinitializer}.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"proxiableUUID()\":{\"details\":\"Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"upgradeToAndCall(address,bytes)\":{\"custom:oz-upgrades-unsafe-allow-reachable\":\"delegatecall\",\"details\":\"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/issuance/TokenIssuer.sol\":\"TokenIssuer\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"keccak256\":\"0xc163fcf9bb10138631a9ba5564df1fa25db9adff73bd9ee868a8ae1858fe093a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9706d43a0124053d9880f6e31a59f31bc0a6a3dc1acd66ce0a16e1111658c5f6\",\"dweb:/ipfs/QmUFmfowzkRwGtDu36cXV9SPTBHJ3n7dG9xQiK5B28jTf2\"]},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"keccak256\":\"0xdb4d24ee2c087c391d587cd17adfe5b3f9d93b3110b1388c2ab6c7c0ad1dcd05\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ab7b6d5b9e2b88176312967fe0f0e78f3d9a1422fa5e4b64e2440c35869b5d08\",\"dweb:/ipfs/QmXKYWWyzcLg1B2k7Sb1qkEXgLCYfXecR9wYW5obRzWP1Q\"]},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"keccak256\":\"0x574a7451e42724f7de29e2855c392a8a5020acd695169466a18459467d719d63\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5bc189f63b639ee173dd7b6fecc39baf7113bf161776aea22b34c57fdd1872ec\",\"dweb:/ipfs/QmZAf2VtjDLRULqjJkde6LNsxAg12tUqpPqgUQQZbAjgtZ\"]},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"keccak256\":\"0xdbef5f0c787055227243a7318ef74c8a5a1108ca3a07f2b3a00ef67769e1e397\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://08e39f23d5b4692f9a40803e53a8156b72b4c1f9902a88cd65ba964db103dab9\",\"dweb:/ipfs/QmPKn6EYDgpga7KtpkA8wV2yJCYGMtc9K4LkJfhKX2RVSV\"]},\"@openzeppelin/contracts/interfaces/IERC1967.sol\":{\"keccak256\":\"0xbf2aefe54b76d7f7bcd4f6da1080b7b1662611937d870b880db584d09cea56b5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f5e7e2f12e0feec75296e57f51f82fdaa8bd1551f4b8cc6560442c0bf60f818c\",\"dweb:/ipfs/QmcW9wDMaQ8RbQibMarfp17a3bABzY5KraWe2YDwuUrUoz\"]},\"@openzeppelin/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d\",\"dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF\"]},\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\":{\"keccak256\":\"0x82f757819bf2429a0d4db141b99a4bbe5039e4ef86dfb94e2e6d40577ed5b28b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://37c30ed931e19fb71fdb806bb504cfdb9913b7127545001b64d4487783374422\",\"dweb:/ipfs/QmUBHpv4hm3ZmwJ4GH8BeVzK4mv41Q6vBbWXxn8HExPXza\"]},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\":{\"keccak256\":\"0xa1ad192cd45317c788618bef5cb1fb3ca4ce8b230f6433ac68cc1d850fb81618\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b43447bb85a53679d269a403c693b9d88d6c74177dfb35eddca63abaf7cf110a\",\"dweb:/ipfs/QmXSDmpd4bNZj1PDgegr6C4w1jDaWHXCconC3rYiw9TSkQ\"]},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"keccak256\":\"0x20462ddb2665e9521372c76b001d0ce196e59dbbd989de9af5576cad0bd5628b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f417fd12aeec8fbfaceaa30e3a08a0724c0bc39de363e2acf6773c897abbaf6d\",\"dweb:/ipfs/QmU4Hko6sApdweVM92CsiuLKkCk8HfyBeutF89PCTz5Tye\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303\",\"dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV\"]},\"@openzeppelin/contracts/utils/Address.sol\":{\"keccak256\":\"0x6d0ae6e206645341fd122d278c2cb643dea260c190531f2f3f6a0426e77b00c0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://032d1201d839435be2c85b72e33206b3ea980c569d6ebf7fa57d811ab580a82f\",\"dweb:/ipfs/QmeqQjAtMvdZT2tG7zm39itcRJkuwu8AEReK6WRnLJ18DD\"]},\"@openzeppelin/contracts/utils/Errors.sol\":{\"keccak256\":\"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf\",\"dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB\"]},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b\",\"dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM\"]},\"contracts/compliance/IDSBlackListManager.sol\":{\"keccak256\":\"0xc1405c507a45895c802d817933bce7abbeacc4919e036d87e772bcf4426fa254\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://a040e282878972622e246b02199f27760953c982ae66ee1cc3884c196a8051e4\",\"dweb:/ipfs/QmPw5XVRVZEgbgKvVn3ypZJhaUiWWXLdfMnCutNjS9vXkk\"]},\"contracts/compliance/IDSComplianceConfigurationService.sol\":{\"keccak256\":\"0xe276c42f1df8b7f778d37ab366a7141e94b8b0d668e12ea68137a8f5c1556a26\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://872af08636fc9242da0e1944ab2b1655530014d914ff7173e7d3e2c4a7416ff0\",\"dweb:/ipfs/QmSDYjkeXHEvm2ZjaS2kncm8PJiVMCzZdEWGCRUeprotff\"]},\"contracts/compliance/IDSComplianceService.sol\":{\"keccak256\":\"0x7ec87e6c3d9dbd0543c9a4ed311fc7f28d0f255085f354e2e66e0f59a925933d\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://eff19340b27ec907ca36db46c3b87188d8262319b9fcaa6a13c5aeb4cb7a9ac9\",\"dweb:/ipfs/QmYn4D2sNMwUh1L2qptXvpYVpwJoZbjfwnSVWAHEAhpU8a\"]},\"contracts/compliance/IDSLockManager.sol\":{\"keccak256\":\"0xb64ef40c572a0336f239b37dfc37a0c000aa5a95ed13e59e4ad93a98906b5ad5\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://a116afade793478786678d28a69102801e3b24cde5f4907bbd88d6f525471d38\",\"dweb:/ipfs/QmXmmMayfswQBQ81yZFjVzZvbmf88sK5i9L3PoEXWYMeaF\"]},\"contracts/compliance/IDSWalletManager.sol\":{\"keccak256\":\"0xe5dbfdbe8e6c335a9b0b43d10ebef5d108d6b29ab1d750a235e00e4918256a3e\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://a0bf5a92cdfcaef62da2e5b567fa8f212e32c0a0482834c7dea8bdc843e6acc7\",\"dweb:/ipfs/QmPgmNM94pwfFG1fnxwNYMBmwPnyeP646QBCph8gRFwteM\"]},\"contracts/data-stores/ServiceConsumerDataStore.sol\":{\"keccak256\":\"0x82c2d45eca38a7517d66caa2e923c00888c0d5c825784ae2c1e124f230763318\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://23b8ec1dd24d5a399bed4569247cd3a4527faf1ac310e1886646931eae64bb62\",\"dweb:/ipfs/QmQ9VLKuRAhECYwc5vz4RKU1mAioQXhG5Mjxrnq8DSZ6fV\"]},\"contracts/issuance/IDSTokenIssuer.sol\":{\"keccak256\":\"0x91a5ad17820efa5f2499f8d1031f75797b65aed3bd1caf95be327c90921a843f\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://7d3fbc2955b92151869c9940b63a341aaa5859b4c8bfdd5d8c4f625fa7bae4da\",\"dweb:/ipfs/QmdZq3uVKi262oq4U11SQwdFu5GVB2sPzW3tc8RTiWk7Yx\"]},\"contracts/issuance/TokenIssuer.sol\":{\"keccak256\":\"0x7ba8811146ec212ce028991209adb0ac93f94c0e2f8c36348400ad3c3a591b6d\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://efc33426d5431ee2d15037375a2c34e827549b090901cd62a4a416e306b88aef\",\"dweb:/ipfs/QmPt5BYCZ9XnTNBspWjMMM5cD3nES8yDVbaRcQWC8xZ6jw\"]},\"contracts/rebasing/ISecuritizeRebasingProvider.sol\":{\"keccak256\":\"0x01beb0ca06b9c6d9509da8ff68ccaa6cdfe105110cec23f36ad5791241170d15\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://25405ad76355dbe489d1c6ec903ccc955f061fb07ac4e12ab61332ec3c1c121c\",\"dweb:/ipfs/QmPQq8D6VQXhxqA2zgcHbK9hABZL1c13wdid4yffBotZ88\"]},\"contracts/registry/IDSRegistryService.sol\":{\"keccak256\":\"0x31818dbfd6d1a10a5be4ef4add1228a71a9a3529f313e431259ce143be51ebcb\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://573381bf8fb270e236c717a061a02873035cc29d9eb7437e476d792c5586a2d0\",\"dweb:/ipfs/QmcB8RSwBZAEryTGMw4RtBgsuCi9V63tDZTXjXEuiVKBQ3\"]},\"contracts/service/IDSServiceConsumer.sol\":{\"keccak256\":\"0x791c40e727af0329606e4ad273f30f068055bfb49f26adb9085e9b9e22857024\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://8fbaab8c3bb9a26ae295d8417b2bbd9745aa68811b128e713bc39ddddd244ba2\",\"dweb:/ipfs/Qmd4z6m5MjsJ9emGiKvhaxdGC72bSXAhtjpkPeUaN3xmpC\"]},\"contracts/service/ServiceConsumer.sol\":{\"keccak256\":\"0x9e7a76550715d0b28c56208e4dd8249c51f1c31d4c5384bb304a8409aef073a2\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://a8e8328ba98ea2ecc51cd1eadd37f531516ce06cb97ec43507a6896072c0c96b\",\"dweb:/ipfs/QmWsYGtaf31YsevFbYmVVeDqGWnxy4umZun5oFdeia8Uvk\"]},\"contracts/token/IDSToken.sol\":{\"keccak256\":\"0x5e37507a3ac1bb628635e6b9f2929b87cb63a687075fec9a0d586e0d21a66484\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://4497593a744c9d2b91fddcd3c77e4fb58c3566cc7db69718def60ce9c443b700\",\"dweb:/ipfs/QmNkU5D5JQLsNJzKzbm8wuxDLAyskqNEKhv2MnzE273Nyz\"]},\"contracts/trust/IDSTrustService.sol\":{\"keccak256\":\"0xeb6873df49c0fa79d817ac703465d4f2819ddfc3cd77ad305270c2101f785136\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://fcec4f776fdfa5b9a6060d78e7d8a50521e9d4c8ef289a5d5964dbfd2450bcb6\",\"dweb:/ipfs/QmcoGwD6WqWBEnKAGSx23erAawGK3M2xqdCvWV8XifJcac\"]},\"contracts/utils/BaseDSContract.sol\":{\"keccak256\":\"0xa99851762d66d1636db92494bfe8c5ab997b5995fd208d5b07e62284d1bee0b3\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://74132312667c478aa780ff6cdfa443245848421c7248b93083f4d6f83b80feff\",\"dweb:/ipfs/QmPEkeExbDNF9wjKGsRGE9Bf9qpH5XiQbd5nrsJkiBUd8S\"]},\"contracts/utils/CommonUtils.sol\":{\"keccak256\":\"0xb4e8316d25f76902ccd344f8336e22a15da939547b681a1193d6072a58ce9308\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://7aacf875230d1333848d63f73ddecf4d3fc8cc854f57ff842c836daf992e77bc\",\"dweb:/ipfs/QmXPhogwSYwELQ7DowjTJjpXX4AqGiLUX8REtQ4F7av7YY\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","errors":{"FailedCall()":[{"details":"A call to an address target failed. The target may have reverted."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"ERC1967NonPayable()":[{"details":"An upgrade function sees `msg.value > 0` that may be lost."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"AddressEmptyCode(address)":[{"details":"There's no code at `target` (it is not a contract)."}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"UUPSUnauthorizedCallContext()":[{"details":"The call is from an unauthorized context."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ERC1967InvalidImplementation(address)":[{"details":"The `implementation` of the proxy is invalid."}],"UUPSUnsupportedProxiableUUID(bytes32)":[{"details":"The storage `slot` is unsupported as a UUID."}]},"events":{"Upgraded(address)":{"details":"Emitted when the implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized or reinitialized."}},"methods":{"owner()":{"details":"Returns the address of the current owner."},"constructor":{"custom:oz-upgrades-unsafe-allow":"constructor"},"proxiableUUID()":{"details":"Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the implementation. It is used to validate the implementation's compatibility when performing an upgrade. IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"getInitializedVersion()":{"details":"Returns the highest version that has been initialized. See {reinitializer}."},"getImplementationAddress()":{"details":"returns proxy ERC1967 implementation address"},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"upgradeToAndCall(address,bytes)":{"details":"Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call encoded in `data`. Calls {_authorizeUpgrade}. Emits an {Upgraded} event.","custom:oz-upgrades-unsafe-allow-reachable":"delegatecall"}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_array(t_uint256)49_storage":{"base":"t_uint256","label":"uint256[49]","encoding":"inplace","numberOfBytes":"1568"},"t_mapping(t_uint256,t_address)":{"key":"t_uint256","label":"mapping(uint256 => address)","value":"t_address","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_uint256,t_address)","astId":2468,"label":"services","offset":0,"contract":"contracts/issuance/TokenIssuer.sol:TokenIssuer"},{"slot":"1","type":"t_array(t_uint256)49_storage","astId":2473,"label":"__gap","offset":0,"contract":"contracts/issuance/TokenIssuer.sol:TokenIssuer"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"928:2808:20:-:0;;;1171:4:2;1128:48;;1042:53:20;;;;;;;;;-1:-1:-1;1066:22:20;:20;:22::i;:::-;928:2808;;7709:422:1;3147:66;7898:15;;;;;;;7894:76;;;7936:23;;-1:-1:-1;;;7936:23:1;;;;;;;;;;;7894:76;7983:14;;-1:-1:-1;;;;;7983:14:1;;;:34;7979:146;;8033:33;;-1:-1:-1;;;;;;8033:33:1;-1:-1:-1;;;;;8033:33:1;;;;;8085:29;;158:50:29;;;8085:29:1;;146:2:29;131:18;8085:29:1;;;;;;;7979:146;7758:373;7709:422::o;14:200:29:-;928:2808:20;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"928:2808:20:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5074:220:24;;;;;;;;;;-1:-1:-1;5074:220:24;;;;;:::i;:::-;;:::i;:::-;;;616:14:29;;609:22;591:41;;579:2;564:18;5074:220:24;;;;;;;;2015:109;;;;;;;;;;;;;:::i;:::-;;1369:124:27;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;807:32:29;;;789:51;;777:2;762:18;1369:124:27;643:203:29;4943:125:24;;;;;;;;;;-1:-1:-1;4943:125:24;;;;;:::i;:::-;5015:7;5041:20;;;;;;;;;;;-1:-1:-1;;;;;5041:20:24;;4943:125;1817:48:23;;;;;;;;;;;;1861:4;1817:48;;;;;1182:25:29;;;1170:2;1155:18;1817:48:23;1036:177:29;779:36:23;;;;;;;;;;;;814:1;779:36;;1832:37:24;;;;;;;;;;;;1868:1;1832:37;;;;;1390:4:29;1378:17;;;1360:36;;1348:2;1333:18;1832:37:24;1218:184:29;1469:59:23;;;;;;;;;;;;1524:4;1469:59;;1763:48;;;;;;;;;;;;1807:4;1763:48;;1243:47;;;;;;;;;;;;1286:4;1243:47;;4161:214:2;;;;;;:::i;:::-;;:::i;3708:134::-;;;;;;;;;;;;;:::i;3155:101:0:-;;;;;;;;;;;;;:::i;1791:35:24:-;;;;;;;;;;;;1825:1;1791:35;;1875:37;;;;;;;;;;;;1911:1;1875:37;;1015:41:23;;;;;;;;;;;;1054:2;1015:41;;1101:100:20;;;;;;;;;;;;;:::i;1207:1198::-;;;;;;;;;;-1:-1:-1;1207:1198:20;;;;;:::i;:::-;;:::i;821:44:23:-;;;;;;;;;;;;864:1;821:44;;2441:144:0;;;;;;;;;;;;;:::i;966:43:23:-;;;;;;;;;;;;1007:2;966:43;;1819:58:2;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1819:58:2;;;;;;;;;;;;:::i;1195:42:23:-;;;;;;;;;;;;1234:3;1195:42;;1413:50;;;;;;;;;;;;1459:4;1413:50;;1642:51;;;;;;;;;;;;1692:1;1642:51;;1603:112:27;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;8444:31:29;;;8426:50;;8414:2;8399:18;1603:112:27;8282:200:29;732:41:23;;;;;;;;;;;;772:1;732:41;;1016:142:27;;;;;;;;;;;;;:::i;871:46:23:-;;;;;;;;;;;;916:1;871:46;;923:37;;;;;;;;;;;;958:2;923:37;;1127:62;;;;;;;;;;;;1186:3;1127:62;;1062:59;;;;;;;;;;;;1118:3;1062:59;;1918:39:24;;;;;;;;;;;;1956:1;1918:39;;1963:45;;;;;;;;;;;;2007:1;1963:45;;1296:64:23;;;;;;;;;;;;1356:4;1296:64;;1699:58;;;;;;;;;;;;1752:5;1699:58;;3405:215:0;;;;;;;;;;-1:-1:-1;3405:215:0;;;;;:::i;:::-;;:::i;5074:220:24:-;5170:4;2175:10;2164:7;:5;:7::i;:::-;-1:-1:-1;;;;;2164:21:24;;2160:116;;1868:1;2195:17;:15;:17::i;:::-;:37;;-1:-1:-1;;;2195:37:24;;2221:10;2195:37;;;789:51:29;-1:-1:-1;;;;;2195:25:24;;;;;;;762:18:29;;2195:37:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;;2187:89;;;;-1:-1:-1;;;2187:89:24;;;;;;;:::i;:::-;;;;;;;;;5186:8:::1;:20:::0;;;::::1;::::0;;;;;;;;:31;;-1:-1:-1;;;;;;5186:31:24::1;-1:-1:-1::0;;;;;5186:31:24;::::1;::::0;;::::1;::::0;;;5232:34;;9483:25:29;;;9524:18;;;9517:60;5232:34:24::1;::::0;9456:18:29;5232:34:24::1;;;;;;;-1:-1:-1::0;5283:4:24::1;5074:220:::0;;;;:::o;2015:109::-;6929:20:1;:18;:20::i;:::-;2091:26:24::1;2106:10;2091:14;:26::i;:::-;2015:109::o:0;1369:124:27:-;1428:7;1454:32;-1:-1:-1;;;;;;;;;;;1519:53:7;-1:-1:-1;;;;;1519:53:7;;1441:138;1454:32:27;1447:39;;1369:124;:::o;4161:214:2:-;2655:13;:11;:13::i;:::-;4276:36:::1;4294:17;4276;:36::i;:::-;4322:46;4344:17;4363:4;4322:21;:46::i;:::-;4161:214:::0;;:::o;3708:134::-;3777:7;2926:20;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;;3708:134:2;:::o;3155:101:0:-;2334:13;:11;:13::i;:::-;3219:30:::1;3246:1;3219:18;:30::i;1101:100:20:-:0;2655:13:2;:11;:13::i;:::-;3147:66:1;4302:15;;-1:-1:-1;;;4302:15:1;::::1;;;4301:16;::::0;-1:-1:-1;;;;;4348:14:1::1;4158:30;4724:16:::0;;:34;::::1;;;;4744:14;4724:34;4704:54;;4768:17;4788:11;-1:-1:-1::0;;;;;4788:16:1::1;4803:1;4788:16;:50;;;;-1:-1:-1::0;4816:4:1::1;4808:25;:30:::0;4788:50:::1;4768:70;;4854:12;4853:13;:30;;;;;4871:12;4870:13;4853:30;4849:91;;;4906:23;;-1:-1:-1::0;;;4906:23:1::1;;;;;;;;;;;4849:91;4949:18:::0;;-1:-1:-1;;4949:18:1::1;4966:1;4949:18;::::0;;4977:67;::::1;;;5011:22:::0;;-1:-1:-1;;;;5011:22:1::1;-1:-1:-1::0;;;5011:22:1::1;::::0;;4977:67:::1;1171:23:20::2;:21;:23::i;:::-;5068:14:1::1;5064:101;;;5098:23:::0;;-1:-1:-1;;;;5098:23:1::1;::::0;;5140:14:::1;::::0;-1:-1:-1;8426:50:29;;5140:14:1::1;::::0;8414:2:29;8399:18;5140:14:1::1;;;;;;;5064:101;4092:1079;;;;;1101:100:20:o:0;1207:1198::-;1643:4;2781:28:24;2812:17;:15;:17::i;:::-;2852:32;;-1:-1:-1;;;2852:32:24;;2873:10;2852:32;;;789:51:29;2781:48:24;;-1:-1:-1;2839:10:24;;-1:-1:-1;;;;;2852:20:24;;;;;762:18:29;;2852:32:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2839:45;-1:-1:-1;2902:19:24;;;1911:1;2902:19;;:42;;-1:-1:-1;2925:19:24;;;1868:1;2925:19;2902:42;2894:79;;;;-1:-1:-1;;;2894:79:24;;;;;;;:::i;:::-;1667:15:20::1;:22;1693:1;1667:27;1659:66;;;;-1:-1:-1::0;;;1659:66:20::1;;;;;;;:::i;:::-;1770:21;:28;1743:16;:23;:55;1735:94;;;;-1:-1:-1::0;;;1735:94:20::1;;;;;;;:::i;:::-;1870:17;:24;1847:12;:19;:47;1839:86;;;;-1:-1:-1::0;;;1839:86:20::1;;;;;;;:::i;:::-;1939:20;:18;:20::i;:::-;:34;::::0;-1:-1:-1;;;1939:34:20;;-1:-1:-1;;;;;807:32:29;;;1939:34:20::1;::::0;::::1;789:51:29::0;1939:29:20;;;::::1;::::0;::::1;::::0;762:18:29;;1939:34:20::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1935:305;;;1997:69;2023:20;:18;:20::i;:::-;:37;::::0;-1:-1:-1;;;2023:37:20;;-1:-1:-1;;;;;807:32:29;;;2023:37:20::1;::::0;::::1;789:51:29::0;2023:32:20;;;::::1;::::0;::::1;::::0;762:18:29;;2023:37:20::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;2023:37:20::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;2062:3;;1997:69;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;1997:25:20::1;::::0;-1:-1:-1;;;1997:69:20:i:1;:::-;1989:116;;;::::0;-1:-1:-1;;;1989:116:20;;11294:2:29;1989:116:20::1;::::0;::::1;11276:21:29::0;11333:2;11313:18;;;11306:30;11372:34;11352:18;;;11345:62;-1:-1:-1;;;11423:18:29;;;11416:32;11465:19;;1989:116:20::1;11092:398:29::0;1989:116:20::1;1935:305;;;2136:93;2153:3;;2136:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2158:3;2163:14;2179:8;2189:16;2207:21;2136:16;:93::i;:::-;814:1:23::0;5343:8:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;-1:-1:-1;;;;;2250:39:20::1;;2290:3;2295:15;2311:1;2295:18;;;;;;;;:::i;:::-;;;;;;;2315:15;2331:1;2315:18;;;;;;;;:::i;:::-;;;;;;;2335:12;2349:7;2358:17;2250:126;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;2394:4:20::1;::::0;1207:1198;-1:-1:-1;;;;;;;;;;;;;;1207:1198:20:o;2441:144:0:-;1313:22;2570:8;-1:-1:-1;;;;;2570:8:0;;2441:144::o;1603:112:27:-;1659:6;1684:24;3147:66:1;8323:39;-1:-1:-1;;;;;8323:39:1;;8241:128;1016:142:27;2655:13:2;:11;:13::i;:::-;6929:20:1::1;:18;:20::i;:::-;1093:24:27::2;:22;:24::i;:::-;1127;:22;:24::i;3405:215:0:-:0;2334:13;:11;:13::i;:::-;-1:-1:-1;;;;;3489:22:0;::::1;3485:91;;3534:31;::::0;-1:-1:-1;;;3534:31:0;;3562:1:::1;3534:31;::::0;::::1;789:51:29::0;762:18;;3534:31:0::1;643:203:29::0;3485:91:0::1;3585:28;3604:8;3585:18;:28::i;:::-;3405:215:::0;:::o;5415:135:24:-;772:1:23;5465:15:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;;1369:124:27:o;7082:141:1:-;3147:66;8558:40;-1:-1:-1;;;8558:40:1;;;;7144:73;;7189:17;;-1:-1:-1;;;7189:17:1;;;;;;;;;;;1847:127:0;6929:20:1;:18;:20::i;:::-;1929:38:0::1;1954:12;1929:24;:38::i;4578:312:2:-:0;4658:4;-1:-1:-1;;;;;4667:6:2;4650:23;;;:120;;;4764:6;-1:-1:-1;;;;;4728:42:2;:32;-1:-1:-1;;;;;;;;;;;1519:53:7;-1:-1:-1;;;;;1519:53:7;;1441:138;4728:32:2;-1:-1:-1;;;;;4728:42:2;;;4650:120;4633:251;;;4844:29;;-1:-1:-1;;;4844:29:2;;;;;;;;;;;1223:67:27;2175:10:24;2164:7;:5;:7::i;:::-;-1:-1:-1;;;;;2164:21:24;;2160:116;;1868:1;2195:17;:15;:17::i;:::-;:37;;-1:-1:-1;;;2195:37:24;;2221:10;2195:37;;;789:51:29;-1:-1:-1;;;;;2195:25:24;;;;;;;762:18:29;;2195:37:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;;2187:89;;;;-1:-1:-1;;;2187:89:24;;;;;;;:::i;6032:538:2:-;6149:17;-1:-1:-1;;;;;6131:50:2;;:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6131:52:2;;;;;;;;-1:-1:-1;;6131:52:2;;;;;;;;;;;;:::i;:::-;;;6127:437;;6493:60;;-1:-1:-1;;;6493:60:2;;-1:-1:-1;;;;;807:32:29;;6493:60:2;;;789:51:29;762:18;;6493:60:2;643:203:29;6127:437:2;-1:-1:-1;;;;;;;;;;;6225:40:2;;6221:120;;6292:34;;-1:-1:-1;;;6292:34:2;;;;;1182:25:29;;;1155:18;;6292:34:2;1036:177:29;6221:120:2;6354:54;6384:17;6403:4;6354:29;:54::i;:::-;6184:235;6032:538;;:::o;5007:213::-;5081:4;-1:-1:-1;;;;;5090:6:2;5073:23;;5069:145;;5174:29;;-1:-1:-1;;;5174:29:2;;;;;;;;;;;2658:162:0;966:10:3;2717:7:0;:5;:7::i;:::-;-1:-1:-1;;;;;2717:23:0;;2713:101;;2763:40;;-1:-1:-1;;;2763:40:0;;966:10:3;2763:40:0;;;789:51:29;762:18;;2763:40:0;643:203:29;3774:248:0;1313:22;3923:8;;-1:-1:-1;;;;;;3941:19:0;;-1:-1:-1;;;;;3941:19:0;;;;;;;;3975:40;;3923:8;;;;;3975:40;;3847:24;;3975:40;3837:185;;3774:248;:::o;5999:147:24:-;864:1:23;6052:18:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;;1369:124:27:o;880:154:28:-;968:4;1010:19;1023:5;1010:12;:19::i;:::-;987;1000:5;987:12;:19::i;:::-;:42;;880:154;-1:-1:-1;;;880:154:28:o;2411:1323:20:-;2674:34;2711:20;:18;:20::i;:::-;2852:23;;2674:57;;-1:-1:-1;2773:1:20;;2852:28;;:82;;;2911:23;2884:50;;:16;:23;:50;2852:82;2844:121;;;;-1:-1:-1;;;2844:121:20;;;;;;;:::i;:::-;2975:28;3044:23;3017:50;;:16;:23;:50;3013:378;;3111:23;3099:36;;-1:-1:-1;;;;;3099:36:20;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3099:36:20;;3083:52;;3168:15;-1:-1:-1;;;;;3168:28:20;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3149:13;3163:1;3149:16;;;;;;;;:::i;:::-;;;;;;:49;;;;;;;;;;;3231:15;-1:-1:-1;;;;;3231:26:20;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3212:13;3226:1;3212:16;;;;;;;;:::i;:::-;;;;;;:47;;;;;;;;;;;3292:15;-1:-1:-1;;;;;3292:25:20;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3273:13;3287:1;3273:16;;;;;;;;:::i;:::-;;;;;;:46;;;;;;;;;;;3013:378;;;-1:-1:-1;3366:14:20;;;3378:1;3366:14;;;;;;;;3013:378;3435:16;;;3449:1;3435:16;;;;;;;;;3400:32;;3435:16;;;;;;;;;;;-1:-1:-1;3435:16:20;3400:51;;3482:7;3461:15;3477:1;3461:18;;;;;;;;:::i;:::-;-1:-1:-1;;;;;3461:28:20;;;:18;;;;;;;;;:28;3499:228;;-1:-1:-1;;;3499:228:20;;:30;;;;;;:228;;3543:3;;3560:14;;3588:8;;3610:15;;3639:13;;3666:16;;3696:21;;3499:228;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;2664:1070;;;;2411:1323;;;;;;:::o;2970:67:2:-;6929:20:1;:18;:20::i;1980:235:0:-;6929:20:1;:18;:20::i;2264:344:7:-;2355:37;2374:17;2355:18;:37::i;:::-;2407:36;;-1:-1:-1;;;;;2407:36:7;;;;;;;;2458:11;;:15;2454:148;;2489:53;2518:17;2537:4;2489:28;:53::i;2454:148::-;2573:18;:16;:18::i;751:125:28:-;816:7;865:4;848:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;838:33;;;;;;831:40;;751:125;;;:::o;1671:281:7:-;1748:17;-1:-1:-1;;;;;1748:29:7;;1781:1;1748:34;1744:119;;1805:47;;-1:-1:-1;;;1805:47:7;;-1:-1:-1;;;;;807:32:29;;1805:47:7;;;789:51:29;762:18;;1805:47:7;643:203:29;1744:119:7;-1:-1:-1;;;;;;;;;;;1872:73:7;;-1:-1:-1;;;;;;1872:73:7;-1:-1:-1;;;;;1872:73:7;;;;;;;;;;1671:281::o;3916:253:10:-;3999:12;4024;4038:23;4065:6;-1:-1:-1;;;;;4065:19:10;4085:4;4065:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4023:67;;;;4107:55;4134:6;4142:7;4151:10;4107:26;:55::i;:::-;4100:62;3916:253;-1:-1:-1;;;;;3916:253:10:o;6113:122:7:-;6163:9;:13;6159:70;;6199:19;;-1:-1:-1;;;6199:19:7;;;;;;;;;;;4437:582:10;4581:12;4610:7;4605:408;;4633:19;4641:10;4633:7;:19::i;:::-;4605:408;;;4857:17;;:22;:49;;;;-1:-1:-1;;;;;;4883:18:10;;;:23;4857:49;4853:119;;;4933:24;;-1:-1:-1;;;4933:24:10;;-1:-1:-1;;;;;807:32:29;;4933:24:10;;;789:51:29;762:18;;4933:24:10;643:203:29;4853:119:10;-1:-1:-1;4992:10:10;4605:408;4437:582;;;;;:::o;5559:434::-;5690:17;;:21;5686:301;;5894:10;5888:17;5881:4;5869:10;5865:21;5858:48;5686:301;5957:19;;-1:-1:-1;;;5957:19:10;;;;;;;;;;;14:173:29;82:20;;-1:-1:-1;;;;;131:31:29;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;373:9;360:23;350:33;;402:38;436:2;425:9;421:18;402:38;:::i;:::-;392:48;;192:254;;;;;:::o;851:180::-;910:6;963:2;951:9;942:7;938:23;934:32;931:52;;;979:1;976;969:12;931:52;-1:-1:-1;1002:23:29;;851:180;-1:-1:-1;851:180:29:o;1407:127::-;1468:10;1463:3;1459:20;1456:1;1449:31;1499:4;1496:1;1489:15;1523:4;1520:1;1513:15;1539:275;1610:2;1604:9;1675:2;1656:13;;-1:-1:-1;;1652:27:29;1640:40;;-1:-1:-1;;;;;1695:34:29;;1731:22;;;1692:62;1689:88;;;1757:18;;:::i;:::-;1793:2;1786:22;1539:275;;-1:-1:-1;1539:275:29:o;1819:186::-;1867:4;-1:-1:-1;;;;;1892:6:29;1889:30;1886:56;;;1922:18;;:::i;:::-;-1:-1:-1;1988:2:29;1967:15;-1:-1:-1;;1963:29:29;1994:4;1959:40;;1819:186::o;2010:336::-;2074:5;2103:52;2119:35;2147:6;2119:35;:::i;:::-;2103:52;:::i;:::-;2094:61;;2178:6;2171:5;2164:21;2218:3;2209:6;2204:3;2200:16;2197:25;2194:45;;;2235:1;2232;2225:12;2194:45;2284:6;2279:3;2272:4;2265:5;2261:16;2248:43;2338:1;2331:4;2322:6;2315:5;2311:18;2307:29;2300:40;2010:336;;;;;:::o;2351:523::-;2428:6;2436;2489:2;2477:9;2468:7;2464:23;2460:32;2457:52;;;2505:1;2502;2495:12;2457:52;2528:29;2547:9;2528:29;:::i;:::-;2518:39;;2608:2;2597:9;2593:18;2580:32;-1:-1:-1;;;;;2627:6:29;2624:30;2621:50;;;2667:1;2664;2657:12;2621:50;2690:22;;2743:4;2735:13;;2731:27;-1:-1:-1;2721:55:29;;2772:1;2769;2762:12;2721:55;2795:73;2860:7;2855:2;2842:16;2837:2;2833;2829:11;2795:73;:::i;:::-;2785:83;;;2351:523;;;;;:::o;3061:348::-;3113:8;3123:6;3177:3;3170:4;3162:6;3158:17;3154:27;3144:55;;3195:1;3192;3185:12;3144:55;-1:-1:-1;3218:20:29;;-1:-1:-1;;;;;3250:30:29;;3247:50;;;3293:1;3290;3283:12;3247:50;3330:4;3322:6;3318:17;3306:29;;3382:3;3375:4;3366:6;3358;3354:19;3350:30;3347:39;3344:59;;;3399:1;3396;3389:12;3344:59;3061:348;;;;;:::o;3414:183::-;3474:4;-1:-1:-1;;;;;3499:6:29;3496:30;3493:56;;;3529:18;;:::i;:::-;-1:-1:-1;3574:1:29;3570:14;3586:4;3566:25;;3414:183::o;3602:668::-;3656:5;3709:3;3702:4;3694:6;3690:17;3686:27;3676:55;;3727:1;3724;3717:12;3676:55;3763:6;3750:20;3789:4;3813:60;3829:43;3869:2;3829:43;:::i;3813:60::-;3895:3;3919:2;3914:3;3907:15;3947:4;3942:3;3938:14;3931:21;;4004:4;3998:2;3995:1;3991:10;3983:6;3979:23;3975:34;3961:48;;4032:3;4024:6;4021:15;4018:35;;;4049:1;4046;4039:12;4018:35;4085:4;4077:6;4073:17;4099:142;4115:6;4110:3;4107:15;4099:142;;;4181:17;;4169:30;;4219:12;;;;4132;;4099:142;;;-1:-1:-1;4259:5:29;3602:668;-1:-1:-1;;;;;;3602:668:29:o;4275:221::-;4318:5;4371:3;4364:4;4356:6;4352:17;4348:27;4338:55;;4389:1;4386;4379:12;4338:55;4411:79;4486:3;4477:6;4464:20;4457:4;4449:6;4445:17;4411:79;:::i;4501:850::-;4554:5;4607:3;4600:4;4592:6;4588:17;4584:27;4574:55;;4625:1;4622;4615:12;4574:55;4661:6;4648:20;4687:4;4711:60;4727:43;4767:2;4727:43;:::i;4711:60::-;4793:3;4817:2;4812:3;4805:15;4845:4;4840:3;4836:14;4829:21;;4902:4;4896:2;4893:1;4889:10;4881:6;4877:23;4873:34;4859:48;;4930:3;4922:6;4919:15;4916:35;;;4947:1;4944;4937:12;4916:35;4983:4;4975:6;4971:17;4997:325;5013:6;5008:3;5005:15;4997:325;;;5093:3;5080:17;-1:-1:-1;;;;;5134:5:29;5130:30;5123:5;5120:41;5110:139;;5203:1;5232:2;5228;5221:14;5110:139;5262:18;;5300:12;;;;5030;;4997:325;;5356:2165;5662:6;5670;5678;5686;5694;5702;5710;5718;5726;5734;5742:7;5796:3;5784:9;5775:7;5771:23;5767:33;5764:53;;;5813:1;5810;5803:12;5764:53;-1:-1:-1;;;;;5894:2:29;5882:9;5869:23;5866:31;5863:51;;;5910:1;5907;5900:12;5863:51;5949:76;6017:7;6004:9;5991:23;5980:9;5976:39;5949:76;:::i;:::-;6044:8;;-1:-1:-1;6071:8:29;-1:-1:-1;6098:38:29;6132:2;6117:18;;6098:38;:::i;:::-;6088:48;;6185:2;6179;6168:9;6164:18;6151:32;6148:40;6145:60;;;6201:1;6198;6191:12;6145:60;6224:87;6303:7;6296:2;6285:9;6281:18;6268:32;6257:9;6253:48;6224:87;:::i;:::-;6214:97;;6360:2;6354;6343:9;6339:18;6326:32;6323:40;6320:60;;;6376:1;6373;6366:12;6320:60;6399:76;6467:7;6460:2;6449:9;6445:18;6432:32;6421:9;6417:48;6399:76;:::i;:::-;6389:86;;6525:2;6518:3;6507:9;6503:19;6490:33;6487:41;6484:61;;;6541:1;6538;6531:12;6484:61;6564:88;6644:7;6636:3;6625:9;6621:19;6608:33;6597:9;6593:49;6564:88;:::i;:::-;6554:98;;6702:2;6695:3;6684:9;6680:19;6667:33;6664:41;6661:61;;;6718:1;6715;6708:12;6661:61;6741:87;6820:7;6812:3;6801:9;6797:19;6784:33;6773:9;6769:49;6741:87;:::i;:::-;6731:97;;6878:2;6871:3;6860:9;6856:19;6843:33;6840:41;6837:61;;;6894:1;6891;6884:12;6837:61;6917:77;6986:7;6978:3;6967:9;6963:19;6950:33;6939:9;6935:49;6917:77;:::i;:::-;6907:87;;7044:2;7037:3;7026:9;7022:19;7009:33;7006:41;7003:61;;;7060:1;7057;7050:12;7003:61;7083:77;7152:7;7144:3;7133:9;7129:19;7116:33;7105:9;7101:49;7083:77;:::i;:::-;7073:87;;7210:2;7203:3;7192:9;7188:19;7175:33;7172:41;7169:61;;;7226:1;7223;7216:12;7169:61;7249:88;7329:7;7321:3;7310:9;7306:19;7293:33;7282:9;7278:49;7249:88;:::i;:::-;7239:98;;7387:2;7380:3;7369:9;7365:19;7352:33;7349:41;7346:61;;;7403:1;7400;7393:12;7346:61;;7427:88;7507:7;7499:3;7488:9;7484:19;7471:33;7460:9;7456:49;7427:88;:::i;:::-;7416:99;;5356:2165;;;;;;;;;;;;;;:::o;7526:250::-;7611:1;7621:113;7635:6;7632:1;7629:13;7621:113;;;7711:11;;;7705:18;7692:11;;;7685:39;7657:2;7650:10;7621:113;;;-1:-1:-1;;7768:1:29;7750:16;;7743:27;7526:250::o;7781:271::-;7823:3;7861:5;7855:12;7888:6;7883:3;7876:19;7904:76;7973:6;7966:4;7961:3;7957:14;7950:4;7943:5;7939:16;7904:76;:::i;:::-;8034:2;8013:15;-1:-1:-1;;8009:29:29;8000:39;;;;8041:4;7996:50;;7781:271;-1:-1:-1;;7781:271:29:o;8057:220::-;8206:2;8195:9;8188:21;8169:4;8226:45;8267:2;8256:9;8252:18;8244:6;8226:45;:::i;8487:186::-;8546:6;8599:2;8587:9;8578:7;8574:23;8570:32;8567:52;;;8615:1;8612;8605:12;8567:52;8638:29;8657:9;8638:29;:::i;8678:273::-;8746:6;8799:2;8787:9;8778:7;8774:23;8770:32;8767:52;;;8815:1;8812;8805:12;8767:52;8847:9;8841:16;8897:4;8890:5;8886:16;8879:5;8876:27;8866:55;;8917:1;8914;8907:12;8956:348;9158:2;9140:21;;;9197:2;9177:18;;;9170:30;9236:26;9231:2;9216:18;;9209:54;9295:2;9280:18;;8956:348::o;9802:350::-;10004:2;9986:21;;;10043:2;10023:18;;;10016:30;10082:28;10077:2;10062:18;;10055:56;10143:2;10128:18;;9802:350::o;10157:277::-;10224:6;10277:2;10265:9;10256:7;10252:23;10248:32;10245:52;;;10293:1;10290;10283:12;10245:52;10325:9;10319:16;10378:5;10371:13;10364:21;10357:5;10354:32;10344:60;;10400:1;10397;10390:12;10439:648;10519:6;10572:2;10560:9;10551:7;10547:23;10543:32;10540:52;;;10588:1;10585;10578:12;10540:52;10621:9;10615:16;-1:-1:-1;;;;;10646:6:29;10643:30;10640:50;;;10686:1;10683;10676:12;10640:50;10709:22;;10762:4;10754:13;;10750:27;-1:-1:-1;10740:55:29;;10791:1;10788;10781:12;10740:55;10820:2;10814:9;10845:48;10861:31;10889:2;10861:31;:::i;10845:48::-;10916:2;10909:5;10902:17;10956:7;10951:2;10946;10942;10938:11;10934:20;10931:33;10928:53;;;10977:1;10974;10967:12;10928:53;10990:67;11054:2;11049;11042:5;11038:14;11033:2;11029;11025:11;10990:67;:::i;11495:127::-;11556:10;11551:3;11547:20;11544:1;11537:31;11587:4;11584:1;11577:15;11611:4;11608:1;11601:15;11627:439;11680:3;11718:5;11712:12;11745:6;11740:3;11733:19;11771:4;11800;11795:3;11791:14;11784:21;;11839:4;11832:5;11828:16;11862:1;11872:169;11886:6;11883:1;11880:13;11872:169;;;11947:13;;11935:26;;11981:12;;;;12016:15;;;;11908:1;11901:9;11872:169;;;-1:-1:-1;12057:3:29;;11627:439;-1:-1:-1;;;;;11627:439:29:o;12071:1233::-;12487:1;12483;12478:3;12474:11;12470:19;12462:6;12458:32;12447:9;12440:51;12421:4;12510:2;12548:6;12543:2;12532:9;12528:18;12521:34;12591:6;12586:2;12575:9;12571:18;12564:34;12634:3;12629:2;12618:9;12614:18;12607:31;12661:57;12713:3;12702:9;12698:19;12690:6;12661:57;:::i;:::-;12767:9;12759:6;12755:22;12749:3;12738:9;12734:19;12727:51;12801:33;12827:6;12819;12801:33;:::i;:::-;12871:22;;;12865:3;12850:19;;12843:51;12943:13;;12965:22;;;13015:2;13041:15;;;;-1:-1:-1;13003:15:29;;;;13074:1;13084:194;13098:6;13095:1;13092:13;13084:194;;;13163:13;;-1:-1:-1;;;;;13159:38:29;13147:51;;13253:15;;;;13218:12;;;;13120:1;13113:9;13084:194;;;-1:-1:-1;13295:3:29;;12071:1233;-1:-1:-1;;;;;;;;;;;12071:1233:29:o;13309:184::-;13379:6;13432:2;13420:9;13411:7;13407:23;13403:32;13400:52;;;13448:1;13445;13438:12;13400:52;-1:-1:-1;13471:16:29;;13309:184;-1:-1:-1;13309:184:29:o;13498:448::-;13549:3;13587:5;13581:12;13614:6;13609:3;13602:19;13640:4;13669;13664:3;13660:14;13653:21;;13708:4;13701:5;13697:16;13731:1;13741:180;13755:6;13752:1;13749:13;13741:180;;;13820:13;;13835:4;13816:24;13804:37;;13861:12;;;;13896:15;;;;13777:1;13770:9;13741:180;;13951:1694;14504:3;14493:9;14486:22;14467:4;14531:46;14572:3;14561:9;14557:19;14549:6;14531:46;:::i;:::-;14596:2;14646:9;14638:6;14634:22;14629:2;14618:9;14614:18;14607:50;14680:33;14706:6;14698;14680:33;:::i;:::-;14666:47;;14761:9;14753:6;14749:22;14744:2;14733:9;14729:18;14722:50;14795:33;14821:6;14813;14795:33;:::i;:::-;14864:22;;;14859:2;14844:18;;14837:50;14936:13;;14958:22;;;15008:2;15034:15;;;;-1:-1:-1;14996:15:29;;;;15067:1;15077:195;15091:6;15088:1;15085:13;15077:195;;;15156:13;;-1:-1:-1;;;;;15152:39:29;15140:52;;15247:15;;;;15212:12;;;;15188:1;15106:9;15077:195;;;15081:3;;15318:9;15313:3;15309:19;15303:3;15292:9;15288:19;15281:48;15352:39;15387:3;15379:6;15352:39;:::i;:::-;15338:53;;;;15440:9;15432:6;15428:22;15422:3;15411:9;15407:19;15400:51;15474:44;15511:6;15503;15474:44;:::i;:::-;15460:58;;15567:9;15559:6;15555:22;15549:3;15538:9;15534:19;15527:51;15595:44;15632:6;15624;15595:44;:::i;:::-;15587:52;13951:1694;-1:-1:-1;;;;;;;;;;13951:1694:29:o;15650:289::-;15781:3;15819:6;15813:13;15835:66;15894:6;15889:3;15882:4;15874:6;15870:17;15835:66;:::i;:::-;15917:16;;;;;15650:289;-1:-1:-1;;15650:289:29:o","linkReferences":{},"immutableReferences":{"482":[{"start":3589,"length":32},{"start":3630,"length":32},{"start":4119,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"__BaseDSContract_init()","signatureHash4":"0xb820a829","signatureHash32":"0xb820a829871351cc2574ca48e5d1b671eb3caa34d4d8b8959fa46d9537c56cfb"},{"signature":"BLACKLIST_MANAGER()","signatureHash4":"0x14ff5e4b","signatureHash32":"0x14ff5e4b51a16e3bc2ba4674d4243a0978b092e4c318367b56e850b078eb30e6"},{"signature":"COMPLIANCE_CONFIGURATION_SERVICE()","signatureHash4":"0xc7540150","signatureHash32":"0xc7540150551681407f5a27a0257090d6248e40544efb40de8f8e2f151138234d"},{"signature":"COMPLIANCE_SERVICE()","signatureHash4":"0xb8632a04","signatureHash32":"0xb8632a041cdd4a2e9fe2f55f315f315a70f817f8e9ddc04be227c14e0cb5a2f2"},{"signature":"DEPRECATED_ISSUER_MULTICALL()","signatureHash4":"0xbf02f4f2","signatureHash32":"0xbf02f4f2ced650a994016aa10a87515f6f5211e009da4f1462d49f2beb024b5f"},{"signature":"DEPRECATED_OMNIBUS_TBE_CONTROLLER()","signatureHash4":"0xe24a473e","signatureHash32":"0xe24a473ed67ba8a4218791a714f550dcd720977f971569a98af4525a2c2a5abd"},{"signature":"DEPRECATED_PARTITIONS_MANAGER()","signatureHash4":"0xcdf76fcb","signatureHash32":"0xcdf76fcb01b5ab32f69bab9a5c0301de2f6c04957cca3c47a7442ab25c1e7185"},{"signature":"DEPRECATED_SECURITIZE_SWAP()","signatureHash4":"0xecf85efb","signatureHash32":"0xecf85efb22be5dee4d4b8a784b8deddfa3d0e87b3b3a7e80e110dcebf186608a"},{"signature":"DEPRECATED_TA_MULTICALL()","signatureHash4":"0xb0a42f91","signatureHash32":"0xb0a42f91df0e9a5ef5efd7950cce4826906d6e1ed45bfcc50b6f16d98b320f9c"},{"signature":"DEPRECATED_TOKEN_REALLOCATOR()","signatureHash4":"0x471c7606","signatureHash32":"0x471c7606d44b4011eda896cb04b96588b97ca8704ebdbbd0cac611ed7eb0822a"},{"signature":"DS_TOKEN()","signatureHash4":"0x4021d0a2","signatureHash32":"0x4021d0a2379dcb555dca4133d4dab75f87eb8acbace4e4fe8f9da22b1d679c5e"},{"signature":"getDSService(uint256)","signatureHash4":"0x0e5324be","signatureHash32":"0x0e5324bec8d6c26e4aa2cf8dc8d449b5403c5742a3b688418309cdd11a89616f"},{"signature":"getImplementationAddress()","signatureHash4":"0x0cbcae70","signatureHash32":"0x0cbcae703cbb5622353987af14989187a05d5595b02f5fe74eff2522ecfbe573"},{"signature":"getInitializedVersion()","signatureHash4":"0xb3c65015","signatureHash32":"0xb3c6501575cc52d327e7fa0594e085f910398bcc38e0b7576716266059649711"},{"signature":"initialize()","signatureHash4":"0x8129fc1c","signatureHash32":"0x8129fc1cf5a76b8b9d76c7ab5059b1685decddb2380c6e4cebb774b7c17ae83f"},{"signature":"issueTokens(string,address,uint256[],string,uint256[],uint64[],string,string,uint256[],uint256[])","signatureHash4":"0x88854f22","signatureHash32":"0x88854f22f2df68e6265f82ab9be5e1cea3cfe748224516ac793f49b78904dff8"},{"signature":"LOCK_MANAGER()","signatureHash4":"0x7f407235","signatureHash32":"0x7f4072351e7750657af062b690de263ce4b76b7dd150912bf058c05ed90583f9"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"proxiableUUID()","signatureHash4":"0x52d1902d","signatureHash32":"0x52d1902ddf94a87b87c42e6ab3aff7da3c30beb57dc65dd86cb2543522a55a4c"},{"signature":"REBASING_PROVIDER()","signatureHash4":"0x4ae07184","signatureHash32":"0x4ae0718453b922d32def056f97f6c35a640a4b792e9cd0baf458b45ac1f6435f"},{"signature":"REGISTRY_SERVICE()","signatureHash4":"0x897c002e","signatureHash32":"0x897c002edef9c839810e8dbcfad43faddf3f14b34bd2bda6f7759d81a53af997"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"ROLE_EXCHANGE()","signatureHash4":"0xd3f61d70","signatureHash32":"0xd3f61d708a7a10bacbd51e43af3749f98910152b7d5378a327c111455fa8e999"},{"signature":"ROLE_ISSUER()","signatureHash4":"0x794d3850","signatureHash32":"0x794d3850b2dfe02b71fd8ed1b86be1ef93c6637a26a5d7b47fc5b29e7d4f3944"},{"signature":"ROLE_MASTER()","signatureHash4":"0x40801b6c","signatureHash32":"0x40801b6c65ded09d971e4dbf4c01df2cbf18181a86d3aff74da7faafb150f36a"},{"signature":"ROLE_NONE()","signatureHash4":"0x77cc16e0","signatureHash32":"0x77cc16e0b8a3bd51d33cd2c967c1f69227cbd3bd87de775865071443c000cc95"},{"signature":"ROLE_TRANSFER_AGENT()","signatureHash4":"0xd8486d29","signatureHash32":"0xd8486d29a3b36fafa25aa598cf90334c1c912f4bfaa9f0f03f924203f613cf2d"},{"signature":"__ServiceConsumer_init()","signatureHash4":"0x0b2ae63d","signatureHash32":"0x0b2ae63df045acfafed9050da3d7f25b554f224891de53083bdf329e40f6f7d4"},{"signature":"setDSService(uint256,address)","signatureHash4":"0x082af7c0","signatureHash32":"0x082af7c06ae2c516bf5d1c69e67c8430e3c187e2e84fa0d9da0c48213976887e"},{"signature":"TOKEN_ISSUER()","signatureHash4":"0xadd37739","signatureHash32":"0xadd377397e86d2344238c64467a45ae5fd5f8561f7d6d6556de6f37029118d27"},{"signature":"TRANSACTION_RELAYER()","signatureHash4":"0xae22901d","signatureHash32":"0xae22901d94e83c6bbf6dccc57eadb6a50a0857cfbcdb0fba0eb300d47731664e"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"TRUST_SERVICE()","signatureHash4":"0xb696bf02","signatureHash32":"0xb696bf02987106f2a98cad14ab2e4577c72089967e1f54efcc15644a626f5fba"},{"signature":"UNUSED_1()","signatureHash4":"0xc4b8c5a0","signatureHash32":"0xc4b8c5a03b903b37934f52f9e8dc7fe4a1f78505056c4292cc5a63345a318b60"},{"signature":"UPGRADE_INTERFACE_VERSION()","signatureHash4":"0xad3cb1cc","signatureHash32":"0xad3cb1cc5c2df3b903ea43f30f77a80ecfeefbed7932a4a8e68c92af99e41dfd"},{"signature":"upgradeToAndCall(address,bytes)","signatureHash4":"0x4f1ef286","signatureHash32":"0x4f1ef2866b98625bdfefae89411f7a82754ac4089eff8e78c8832329a538337f"},{"signature":"WALLET_MANAGER()","signatureHash4":"0x9c37b8e1","signatureHash32":"0x9c37b8e16b3c75e499a628d2e764f9796fd6edc04cb86711583b485a12da6de3"},{"signature":"WALLET_REGISTRAR()","signatureHash4":"0x4c83c126","signatureHash32":"0x4c83c126bbf9bfbbe18d5deb2fbc75563d0e02800a41d3bf670c2cec250b74be"}],"event":[{"signature":"DSServiceSet(uint256,address)","signatureHash4":"0x8a9dba1d","signatureHash32":"0x8a9dba1dc2a1daab74cedc87602df39dcebeacc96d1f5bf104159897a96bebaf"},{"signature":"Initialized(uint64)","signatureHash4":"0xc7f505b2","signatureHash32":"0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Upgraded(address)","signatureHash4":"0xbc7cd75a","signatureHash32":"0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b"}],"error":[{"signature":"AddressEmptyCode(address)","signatureHash4":"0x9996b315","signatureHash32":"0x9996b315c842ff135b8fc4a08ad5df1c344efbc03d2687aecc0678050d2aac89"},{"signature":"ERC1967InvalidImplementation(address)","signatureHash4":"0x4c9c8ce3","signatureHash32":"0x4c9c8ce3ceb3130f17f7cdba48d89b5b0129f266a8bac114e6e315a41879b617"},{"signature":"ERC1967NonPayable()","signatureHash4":"0xb398979f","signatureHash32":"0xb398979fa84f543c8e222f17890372c487baf85e062276c127fef521eea7224b"},{"signature":"FailedCall()","signatureHash4":"0xd6bda275","signatureHash32":"0xd6bda27508c0fb6d8a39b4b122878dab26f731a7d4e4abe711dd3731899052a4"},{"signature":"InvalidInitialization()","signatureHash4":"0xf92ee8a9","signatureHash32":"0xf92ee8a957075833165f68c320933b1a1294aafc84ee6e0dd3fb178008f9aaf5"},{"signature":"NotInitializing()","signatureHash4":"0xd7e6bcf8","signatureHash32":"0xd7e6bcf8597daa127dc9f0048d2f08d5ef140a2cb659feabd700beff1f7a8302"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"UUPSUnauthorizedCallContext()","signatureHash4":"0xe07c8dba","signatureHash32":"0xe07c8dba242a06571ac65fe4bbe20522c9fb111cb33599b799ff8039c1ed18f4"},{"signature":"UUPSUnsupportedProxiableUUID(bytes32)","signatureHash4":"0xaa1d49a4","signatureHash32":"0xaa1d49a4c084bfa9aeeee2a0be65267a7f19ba7e1476b114dac513d2c14cb563"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x4ef34664cCBF1979180A9f3Cb21f033e069713ba"}