{"matchId":"42752527","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-07-22T20:27:23Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"926:968:22:-:0;;;1171:4:2;1128:48;;1048:53:22;;;;;;;;;-1:-1:-1;1072:22:22;:20;:22::i;:::-;926:968;;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:-;926:968:22;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220160ebe03dee8126adb18b97ed8d6a221f58b80ac054611ec7f866d96816112f964736f6c63430008160033","offset":6366}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"0x6080604052600436106102255760003560e01c80638da5cb5b11610123578063b8632a04116100ab578063d3f61d701161006f578063d3f61d7014610597578063d8486d29146105ac578063e24a473e146105c1578063ecf85efb146105d7578063f2fde38b146105ed57600080fd5b8063b8632a0414610542578063bf02f4f2146104d5578063c4b8c5a014610557578063c75401501461056c578063cdf76fcb1461058257600080fd5b8063ae22901d116100f2578063ae22901d146104bf578063b0a42f91146104d5578063b3c65015146104ea578063b696bf0214610518578063b820a8291461052d57600080fd5b80638da5cb5b146104415780639c37b8e114610456578063ad3cb1cc1461046b578063add37739146104a957600080fd5b80634ae07184116101b157806377cc16e01161017557806377cc16e0146103d8578063794d3850146103ed5780637f407235146104025780638129fc1c14610417578063897c002e1461042c57600080fd5b80634ae071841461036f5780634c83c126146103855780634f1ef2861461039b57806352d1902d146103ae578063715018a6146103c357600080fd5b806314ff5e4b116101f857806314ff5e4b146102d957806325d9084b146102fd5780634021d0a21461031d57806340801b6c14610332578063471c76061461035957600080fd5b8063082af7c01461022a5780630b2ae63d1461025f5780630cbcae70146102765780630e5324be146102a3575b600080fd5b34801561023657600080fd5b5061024a610245366004611115565b61060d565b60405190151581526020015b60405180910390f35b34801561026b57600080fd5b5061027461072c565b005b34801561028257600080fd5b5061028b61073f565b6040516001600160a01b039091168152602001610256565b3480156102af57600080fd5b5061028b6102be366004611141565b6000908152602081905260409020546001600160a01b031690565b3480156102e557600080fd5b506102ef61200581565b604051908152602001610256565b34801561030957600080fd5b5061024a6103183660046113b1565b610765565b34801561032957600080fd5b506102ef600281565b34801561033e57600080fd5b50610347600181565b60405160ff9091168152602001610256565b34801561036557600080fd5b506102ef61200081565b34801561037b57600080fd5b506102ef61200481565b34801561039157600080fd5b506102ef61040081565b6102746103a93660046114d6565b61095e565b3480156103ba57600080fd5b506102ef61097d565b3480156103cf57600080fd5b5061027461099a565b3480156103e457600080fd5b50610347600081565b3480156103f957600080fd5b50610347600281565b34801561040e57600080fd5b506102ef604081565b34801561042357600080fd5b506102746109ac565b34801561043857600080fd5b506102ef600481565b34801561044d57600080fd5b5061028b610ac2565b34801561046257600080fd5b506102ef602081565b34801561047757600080fd5b5061049c604051806040016040528060058152602001640352e302e360dc1b81525081565b6040516102569190611588565b3480156104b557600080fd5b506102ef61020081565b3480156104cb57600080fd5b506102ef61100081565b3480156104e157600080fd5b506102ef600081565b3480156104f657600080fd5b506104ff610af0565b60405167ffffffffffffffff9091168152602001610256565b34801561052457600080fd5b506102ef600181565b34801561053957600080fd5b50610274610b24565b34801561054e57600080fd5b506102ef600881565b34801561056357600080fd5b506102ef601081565b34801561057857600080fd5b506102ef61010081565b34801561058e57600080fd5b506102ef608081565b3480156105a357600080fd5b50610347600481565b3480156105b857600080fd5b50610347600881565b3480156105cd57600080fd5b506102ef61080081565b3480156105e357600080fd5b506102ef61400081565b3480156105f957600080fd5b5061027461060836600461159b565b610b44565b600033610618610ac2565b6001600160a01b0316146106c3576001610630610b82565b604051634427673360e01b81523360048201526001600160a01b039190911690634427673390602401602060405180830381865afa158015610676573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061069a91906115b6565b60ff16146106c35760405162461bcd60e51b81526004016106ba906115d3565b60405180910390fd5b6000838152602081815260409182902080546001600160a01b0319166001600160a01b0386169081179091558251868152918201527f8a9dba1dc2a1daab74cedc87602df39dcebeacc96d1f5bf104159897a96bebaf910160405180910390a150600192915050565b610734610bba565b61073d33610c03565b565b60006107606000805160206117c1833981519152546001600160a01b031690565b905090565b600033610770610ac2565b6001600160a01b03161461088e576000610788610b82565b604051634427673360e01b81523360048201529091506002906001600160a01b03831690634427673390602401602060405180830381865afa1580156107d2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107f691906115b6565b60ff1614806108705750604051634427673360e01b81523360048201526001906001600160a01b03831690634427673390602401602060405180830381865afa158015610847573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061086b91906115b6565b60ff16145b61088c5760405162461bcd60e51b81526004016106ba906115d3565b505b60006108cb600460009081526020527f52d75039926638d3c558b2bdefb945d5be8dae29dedd1c313212a4d472d9fde5546001600160a01b031690565b9050806001600160a01b031663ba9be7ed8c8a8a8a8f8f8c8c8c6040518a63ffffffff1660e01b8152600401610909999897969594939291906116b6565b6020604051808303816000875af1158015610928573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061094c9190611769565b5060019b9a5050505050505050505050565b610966610c14565b61096f82610cb9565b6109798282610d64565b5050565b6000610987610e26565b506000805160206117c183398151915290565b6109a2610e6f565b61073d6000610ea1565b6109b4610c14565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a008054600160401b810460ff16159067ffffffffffffffff166000811580156109fa5750825b905060008267ffffffffffffffff166001148015610a175750303b155b905081158015610a25575080155b15610a435760405163f92ee8a960e01b815260040160405180910390fd5b845467ffffffffffffffff191660011785558315610a6d57845460ff60401b1916600160401b1785555b610a75610b24565b8315610abb57845460ff60401b19168555604051600181527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d29060200160405180910390a15b5050505050565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300546001600160a01b031690565b60006107607ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a005467ffffffffffffffff1690565b610b2c610c14565b610b34610bba565b610b3c610f12565b61073d61072c565b610b4c610e6f565b6001600160a01b038116610b7657604051631e4fbdf760e01b8152600060048201526024016106ba565b610b7f81610ea1565b50565b600160009081526020527fada5013122d395ba3c54772283fb069b10426056ef8ca54750cb9bb552a59e7d546001600160a01b031690565b7ff0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a0054600160401b900460ff1661073d57604051631afcd79f60e31b815260040160405180910390fd5b610c0b610bba565b610b7f81610f1a565b306001600160a01b037f000000000000000000000000b886f567219a39b49a68115207787dce0a10b9e6161480610c9b57507f000000000000000000000000b886f567219a39b49a68115207787dce0a10b9e66001600160a01b0316610c8f6000805160206117c1833981519152546001600160a01b031690565b6001600160a01b031614155b1561073d5760405163703e46dd60e11b815260040160405180910390fd5b33610cc2610ac2565b6001600160a01b031614610b7f576001610cda610b82565b604051634427673360e01b81523360048201526001600160a01b039190911690634427673390602401602060405180830381865afa158015610d20573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d4491906115b6565b60ff1614610b7f5760405162461bcd60e51b81526004016106ba906115d3565b816001600160a01b03166352d1902d6040518163ffffffff1660e01b8152600401602060405180830381865afa925050508015610dbe575060408051601f3d908101601f19168201909252610dbb9181019061178b565b60015b610de657604051634c9c8ce360e01b81526001600160a01b03831660048201526024016106ba565b6000805160206117c18339815191528114610e1757604051632a87526960e21b8152600481018290526024016106ba565b610e218383610f22565b505050565b306001600160a01b037f000000000000000000000000b886f567219a39b49a68115207787dce0a10b9e6161461073d5760405163703e46dd60e11b815260040160405180910390fd5b33610e78610ac2565b6001600160a01b03161461073d5760405163118cdaa760e01b81523360048201526024016106ba565b7f9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c19930080546001600160a01b031981166001600160a01b03848116918217845560405192169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3505050565b61073d610bba565b610b4c610bba565b610f2b82610f78565b6040516001600160a01b038316907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a2805115610f7057610e218282610fdd565b610979611053565b806001600160a01b03163b600003610fae57604051634c9c8ce360e01b81526001600160a01b03821660048201526024016106ba565b6000805160206117c183398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b6060600080846001600160a01b031684604051610ffa91906117a4565b600060405180830381855af49150503d8060008114611035576040519150601f19603f3d011682016040523d82523d6000602084013e61103a565b606091505b509150915061104a858383611072565b95945050505050565b341561073d5760405163b398979f60e01b815260040160405180910390fd5b60608261108757611082826110d1565b6110ca565b815115801561109e57506001600160a01b0384163b155b156110c757604051639996b31560e01b81526001600160a01b03851660048201526024016106ba565b50805b9392505050565b8051156110e057805160208201fd5b60405163d6bda27560e01b815260040160405180910390fd5b80356001600160a01b038116811461111057600080fd5b919050565b6000806040838503121561112857600080fd5b82359150611138602084016110f9565b90509250929050565b60006020828403121561115357600080fd5b5035919050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff811182821017156111995761119961115a565b604052919050565b600067ffffffffffffffff8311156111bb576111bb61115a565b6111ce601f8401601f1916602001611170565b90508281528383830111156111e257600080fd5b828260208301376000602084830101529392505050565b600082601f83011261120a57600080fd5b6110ca838335602085016111a1565b60008083601f84011261122b57600080fd5b50813567ffffffffffffffff81111561124357600080fd5b6020830191508360208260051b850101111561125e57600080fd5b9250929050565b60008083601f84011261127757600080fd5b50813567ffffffffffffffff81111561128f57600080fd5b60208301915083602082850101111561125e57600080fd5b600067ffffffffffffffff8211156112c1576112c161115a565b5060051b60200190565b60ff81168114610b7f57600080fd5b600082601f8301126112eb57600080fd5b813560206113006112fb836112a7565b611170565b8083825260208201915060208460051b87010193508684111561132257600080fd5b602086015b8481101561134757803561133a816112cb565b8352918301918301611327565b509695505050505050565b600082601f83011261136357600080fd5b813560206113736112fb836112a7565b8083825260208201915060208460051b87010193508684111561139557600080fd5b602086015b84811015611347578035835291830191830161139a565b600080600080600080600080600060e08a8c0312156113cf57600080fd5b893567ffffffffffffffff808211156113e757600080fd5b6113f38d838e016111f9565b9a5060208c013591508082111561140957600080fd5b6114158d838e01611219565b909a50985060408c013591508082111561142e57600080fd5b61143a8d838e01611265565b909850965060608c013591508082111561145357600080fd5b61145f8d838e016111f9565b955060808c013591508082111561147557600080fd5b6114818d838e016112da565b945060a08c013591508082111561149757600080fd5b6114a38d838e01611352565b935060c08c01359150808211156114b957600080fd5b506114c68c828d01611352565b9150509295985092959850929598565b600080604083850312156114e957600080fd5b6114f2836110f9565b9150602083013567ffffffffffffffff81111561150e57600080fd5b8301601f8101851361151f57600080fd5b61152e858235602084016111a1565b9150509250929050565b60005b8381101561155357818101518382015260200161153b565b50506000910152565b60008151808452611574816020860160208601611538565b601f01601f19169290920160200192915050565b6020815260006110ca602083018461155c565b6000602082840312156115ad57600080fd5b6110ca826110f9565b6000602082840312156115c857600080fd5b81516110ca816112cb565b60208082526018908201527f496e73756666696369656e74207472757374206c6576656c0000000000000000604082015260600190565b8183526000602080850194508260005b85811015611646576001600160a01b03611633836110f9565b168752958201959082019060010161161a565b509495945050505050565b60008151808452602080850194506020840160005b8381101561164657815160ff1687529582019590820190600101611666565b60008151808452602080850194506020840160005b838110156116465781518752958201959082019060010161169a565b60e0815260006116c960e083018c61155c565b8281036020840152898152898b6020830137600060208b83010152601f19601f8b0116810190506020838203016040840152611708602082018a61155c565b9050828103606084015261171d81888a61160a565b905082810360808401526117318187611651565b905082810360a08401526117458186611685565b905082810360c08401526117598185611685565b9c9b505050505050505050505050565b60006020828403121561177b57600080fd5b815180151581146110ca57600080fd5b60006020828403121561179d57600080fd5b5051919050565b600082516117b6818460208701611538565b919091019291505056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbca2646970667358221220160ebe03dee8126adb18b97ed8d6a221f58b80ac054611ec7f866d96816112f964736f6c63430008160033","recompiledBytecode":"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","sourceMap":"926:968:22:-: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;1213:679:22;;;;;;;;;;-1:-1:-1;1213:679:22;;;;;:::i;:::-;;:::i;779:36:23:-;;;;;;;;;;;;814:1;779:36;;1832:37:24;;;;;;;;;;;;1868:1;1832:37;;;;;6714:4:29;6702:17;;;6684:36;;6672:2;6657:18;1832:37:24;6542: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;;1107:100:22;;;;;;;;;;;;;:::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;:::-;;;8372:18:29;8360:31;;;8342:50;;8330:2;8315:18;1603:112:27;8198: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;;9373:25:29;;;9414:18;;;9407:60;5232:34:24::1;::::0;9346: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;1213:679:22:-;1558:4;4686:10:24;4675:7;:5;:7::i;:::-;-1:-1:-1;;;;;4675:21:24;;4672:248;;4712:28;4743:17;:15;:17::i;:::-;4782:32;;-1:-1:-1;;;4782:32:24;;4803:10;4782:32;;;789:51:29;4712:48:24;;-1:-1:-1;1911:1:24;;-1:-1:-1;;;;;4782:20:24;;;;;762:18:29;;4782:32:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:47;;;:98;;;-1:-1:-1;4833:32:24;;-1:-1:-1;;;4833:32:24;;4854:10;4833:32;;;789:51:29;1868:1:24;;-1:-1:-1;;;;;4833:20:24;;;;;762:18:29;;4833:32:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:47;;;4782:98;4774:135;;;;-1:-1:-1;;;4774:135:24;;;;;;;:::i;:::-;4698:222;4672:248;1574:34:22::1;1611:20;864:1:23::0;6052:18:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;;1369:124:27;1611:20:22::1;1574:57;;1642:15;-1:-1:-1::0;;;;;1642:30:22::1;;1686:3;1703:14;;1731:8;1753;;1775:13;1802:16;1832:21;1642:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;1881:4:22::1;::::0;1213:679;-1:-1:-1;;;;;;;;;;;1213:679:22: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;1107:100:22:-:0;2655:13:2;:11;:13::i;:::-;3147:66:1;4302:15;;-1:-1:-1;;;4302:15:1;::::1;;;4301:16;::::0;4348:14:::1;;4158:30;4724:16:::0;;:34;::::1;;;;4744:14;4724:34;4704:54;;4768:17;4788:11;:16;;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;1177:23:22::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;8342:50:29;;5140:14:1::1;::::0;8330:2:29;8315:18;5140:14:1::1;;;;;;;5064:101;4092:1079;;;;;1107:100:22:o:0;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;;;;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;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;1671:281::-;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;1218:127::-;1279:10;1274:3;1270:20;1267:1;1260:31;1310:4;1307:1;1300:15;1334:4;1331:1;1324:15;1350:275;1421:2;1415:9;1486:2;1467:13;;-1:-1:-1;;1463:27:29;1451:40;;1521:18;1506:34;;1542:22;;;1503:62;1500:88;;;1568:18;;:::i;:::-;1604:2;1597:22;1350:275;;-1:-1:-1;1350:275:29:o;1630:407::-;1695:5;1729:18;1721:6;1718:30;1715:56;;;1751:18;;:::i;:::-;1789:57;1834:2;1813:15;;-1:-1:-1;;1809:29:29;1840:4;1805:40;1789:57;:::i;:::-;1780:66;;1869:6;1862:5;1855:21;1909:3;1900:6;1895:3;1891:16;1888:25;1885:45;;;1926:1;1923;1916:12;1885:45;1975:6;1970:3;1963:4;1956:5;1952:16;1939:43;2029:1;2022:4;2013:6;2006:5;2002:18;1998:29;1991:40;1630:407;;;;;:::o;2042:222::-;2085:5;2138:3;2131:4;2123:6;2119:17;2115:27;2105:55;;2156:1;2153;2146:12;2105:55;2178:80;2254:3;2245:6;2232:20;2225:4;2217:6;2213:17;2178:80;:::i;2269:367::-;2332:8;2342:6;2396:3;2389:4;2381:6;2377:17;2373:27;2363:55;;2414:1;2411;2404:12;2363:55;-1:-1:-1;2437:20:29;;2480:18;2469:30;;2466:50;;;2512:1;2509;2502:12;2466:50;2549:4;2541:6;2537:17;2525:29;;2609:3;2602:4;2592:6;2589:1;2585:14;2577:6;2573:27;2569:38;2566:47;2563:67;;;2626:1;2623;2616:12;2563:67;2269:367;;;;;:::o;2641:348::-;2693:8;2703:6;2757:3;2750:4;2742:6;2738:17;2734:27;2724:55;;2775:1;2772;2765:12;2724:55;-1:-1:-1;2798:20:29;;2841:18;2830:30;;2827:50;;;2873:1;2870;2863:12;2827:50;2910:4;2902:6;2898:17;2886:29;;2962:3;2955:4;2946:6;2938;2934:19;2930:30;2927:39;2924:59;;;2979:1;2976;2969:12;2994:181;3052:4;3085:18;3077:6;3074:30;3071:56;;;3107:18;;:::i;:::-;-1:-1:-1;3152:1:29;3148:14;3164:4;3144:25;;2994:181::o;3180:114::-;3264:4;3257:5;3253:16;3246:5;3243:27;3233:55;;3284:1;3281;3274:12;3299:737;3351:5;3404:3;3397:4;3389:6;3385:17;3381:27;3371:55;;3422:1;3419;3412:12;3371:55;3458:6;3445:20;3484:4;3508:58;3524:41;3562:2;3524:41;:::i;:::-;3508:58;:::i;:::-;3588:3;3612:2;3607:3;3600:15;3640:4;3635:3;3631:14;3624:21;;3697:4;3691:2;3688:1;3684:10;3676:6;3672:23;3668:34;3654:48;;3725:3;3717:6;3714:15;3711:35;;;3742:1;3739;3732:12;3711:35;3778:4;3770:6;3766:17;3792:215;3808:6;3803:3;3800:15;3792:215;;;3888:3;3875:17;3905:29;3928:5;3905:29;:::i;:::-;3947:18;;3985:12;;;;3825;;3792:215;;;-1:-1:-1;4025:5:29;3299:737;-1:-1:-1;;;;;;3299:737:29:o;4041:666::-;4095:5;4148:3;4141:4;4133:6;4129:17;4125:27;4115:55;;4166:1;4163;4156:12;4115:55;4202:6;4189:20;4228:4;4252:58;4268:41;4306:2;4268:41;:::i;4252:58::-;4332:3;4356:2;4351:3;4344:15;4384:4;4379:3;4375:14;4368:21;;4441:4;4435:2;4432:1;4428:10;4420:6;4416:23;4412:34;4398:48;;4469:3;4461:6;4458:15;4455:35;;;4486:1;4483;4476:12;4455:35;4522:4;4514:6;4510:17;4536:142;4552:6;4547:3;4544:15;4536:142;;;4618:17;;4606:30;;4656:12;;;;4569;;4536:142;;4712:1825;4957:6;4965;4973;4981;4989;4997;5005;5013;5021;5074:3;5062:9;5053:7;5049:23;5045:33;5042:53;;;5091:1;5088;5081:12;5042:53;5131:9;5118:23;5160:18;5201:2;5193:6;5190:14;5187:34;;;5217:1;5214;5207:12;5187:34;5240:50;5282:7;5273:6;5262:9;5258:22;5240:50;:::i;:::-;5230:60;;5343:2;5332:9;5328:18;5315:32;5299:48;;5372:2;5362:8;5359:16;5356:36;;;5388:1;5385;5378:12;5356:36;5427:72;5491:7;5480:8;5469:9;5465:24;5427:72;:::i;:::-;5518:8;;-1:-1:-1;5401:98:29;-1:-1:-1;5606:2:29;5591:18;;5578:32;;-1:-1:-1;5622:16:29;;;5619:36;;;5651:1;5648;5641:12;5619:36;5690:61;5743:7;5732:8;5721:9;5717:24;5690:61;:::i;:::-;5770:8;;-1:-1:-1;5664:87:29;-1:-1:-1;5858:2:29;5843:18;;5830:32;;-1:-1:-1;5874:16:29;;;5871:36;;;5903:1;5900;5893:12;5871:36;5926:52;5970:7;5959:8;5948:9;5944:24;5926:52;:::i;:::-;5916:62;;6031:3;6020:9;6016:19;6003:33;5987:49;;6061:2;6051:8;6048:16;6045:36;;;6077:1;6074;6067:12;6045:36;6100:61;6153:7;6142:8;6131:9;6127:24;6100:61;:::i;:::-;6090:71;;6214:3;6203:9;6199:19;6186:33;6170:49;;6244:2;6234:8;6231:16;6228:36;;;6260:1;6257;6250:12;6228:36;6283:63;6338:7;6327:8;6316:9;6312:24;6283:63;:::i;:::-;6273:73;;6399:3;6388:9;6384:19;6371:33;6355:49;;6429:2;6419:8;6416:16;6413:36;;;6445:1;6442;6435:12;6413:36;;6468:63;6523:7;6512:8;6501:9;6497:24;6468:63;:::i;:::-;6458:73;;;4712:1825;;;;;;;;;;;:::o;6731:524::-;6808:6;6816;6869:2;6857:9;6848:7;6844:23;6840:32;6837:52;;;6885:1;6882;6875:12;6837:52;6908:29;6927:9;6908:29;:::i;:::-;6898:39;;6988:2;6977:9;6973:18;6960:32;7015:18;7007:6;7004:30;7001:50;;;7047:1;7044;7037:12;7001:50;7070:22;;7123:4;7115:13;;7111:27;-1:-1:-1;7101:55:29;;7152:1;7149;7142:12;7101:55;7175:74;7241:7;7236:2;7223:16;7218:2;7214;7210:11;7175:74;:::i;:::-;7165:84;;;6731:524;;;;;:::o;7442:250::-;7527:1;7537:113;7551:6;7548:1;7545:13;7537:113;;;7627:11;;;7621:18;7608:11;;;7601:39;7573:2;7566:10;7537:113;;;-1:-1:-1;;7684:1:29;7666:16;;7659:27;7442:250::o;7697:271::-;7739:3;7777:5;7771:12;7804:6;7799:3;7792:19;7820:76;7889:6;7882:4;7877:3;7873:14;7866:4;7859:5;7855:16;7820:76;:::i;:::-;7950:2;7929:15;-1:-1:-1;;7925:29:29;7916:39;;;;7957:4;7912:50;;7697:271;-1:-1:-1;;7697:271:29:o;7973:220::-;8122:2;8111:9;8104:21;8085:4;8142:45;8183:2;8172:9;8168:18;8160:6;8142:45;:::i;8403:186::-;8462:6;8515:2;8503:9;8494:7;8490:23;8486:32;8483:52;;;8531:1;8528;8521:12;8483:52;8554:29;8573:9;8554:29;:::i;8594:247::-;8662:6;8715:2;8703:9;8694:7;8690:23;8686:32;8683:52;;;8731:1;8728;8721:12;8683:52;8763:9;8757:16;8782:29;8805:5;8782:29;:::i;8846:348::-;9048:2;9030:21;;;9087:2;9067:18;;;9060:30;9126:26;9121:2;9106:18;;9099:54;9185:2;9170:18;;8846:348::o;9478:449::-;9578:6;9573:3;9566:19;9548:3;9604:4;9633;9628:3;9624:14;9617:21;;9661:5;9684:1;9694:208;9708:6;9705:1;9702:13;9694:208;;;-1:-1:-1;;;;;9773:26:29;9792:6;9773:26;:::i;:::-;9769:52;9757:65;;9842:12;;;;9877:15;;;;9730:1;9723:9;9694:208;;;-1:-1:-1;9918:3:29;;9478:449;-1:-1:-1;;;;;9478:449:29:o;9932:448::-;9983:3;10021:5;10015:12;10048:6;10043:3;10036:19;10074:4;10103;10098:3;10094:14;10087:21;;10142:4;10135:5;10131:16;10165:1;10175:180;10189:6;10186:1;10183:13;10175:180;;;10254:13;;10269:4;10250:24;10238:37;;10295:12;;;;10330:15;;;;10211:1;10204:9;10175:180;;10385:439;10438:3;10476:5;10470:12;10503:6;10498:3;10491:19;10529:4;10558;10553:3;10549:14;10542:21;;10597:4;10590:5;10586:16;10620:1;10630:169;10644:6;10641:1;10638:13;10630:169;;;10705:13;;10693:26;;10739:12;;;;10774:15;;;;10666:1;10659:9;10630:169;;10829:1546;11402:3;11391:9;11384:22;11365:4;11429:46;11470:3;11459:9;11455:19;11447:6;11429:46;:::i;:::-;11523:9;11515:6;11511:22;11506:2;11495:9;11491:18;11484:50;11558:6;11550;11543:22;11612:6;11604;11599:2;11591:6;11587:15;11574:45;11665:1;11660:2;11651:6;11643;11639:19;11635:28;11628:39;11723:2;11719:7;11714:2;11706:6;11702:15;11698:29;11690:6;11686:42;11676:52;;11788:2;11776:9;11772:2;11768:18;11764:27;11759:2;11748:9;11744:18;11737:55;11815:38;11849:2;11845;11841:11;11833:6;11815:38;:::i;:::-;11801:52;;11901:9;11893:6;11889:22;11884:2;11873:9;11869:18;11862:50;11935:61;11989:6;11981;11973;11935:61;:::i;:::-;11921:75;;12045:9;12037:6;12033:22;12027:3;12016:9;12012:19;12005:51;12079:42;12114:6;12106;12079:42;:::i;:::-;12065:56;;12170:9;12162:6;12158:22;12152:3;12141:9;12137:19;12130:51;12204:44;12241:6;12233;12204:44;:::i;:::-;12190:58;;12297:9;12289:6;12285:22;12279:3;12268:9;12264:19;12257:51;12325:44;12362:6;12354;12325:44;:::i;:::-;12317:52;10829:1546;-1:-1:-1;;;;;;;;;;;;10829:1546:29:o;12380:277::-;12447:6;12500:2;12488:9;12479:7;12475:23;12471:32;12468:52;;;12516:1;12513;12506:12;12468:52;12548:9;12542:16;12601:5;12594:13;12587:21;12580:5;12577:32;12567:60;;12623:1;12620;12613:12;12876:184;12946:6;12999:2;12987:9;12978:7;12974:23;12970:32;12967:52;;;13015:1;13012;13005:12;12967:52;-1:-1:-1;13038:16:29;;12876:184;-1:-1:-1;12876:184:29:o;13065:287::-;13194:3;13232:6;13226:13;13248:66;13307:6;13302:3;13295:4;13287:6;13283:17;13248:66;:::i;:::-;13330:16;;;;;13065:287;-1:-1:-1;;13065:287:29:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220160ebe03dee8126adb18b97ed8d6a221f58b80ac054611ec7f866d96816112f964736f6c63430008160033","offset":6113}},"immutableReferences":{"482":[{"start":3103,"length":32},{"start":3144,"length":32},{"start":3633,"length":32}]},"transformations":[{"id":"482","type":"replace","offset":3103,"reason":"immutable"},{"id":"482","type":"replace","offset":3144,"reason":"immutable"},{"id":"482","type":"replace","offset":3633,"reason":"immutable"}],"transformationValues":{"immutables":{"482":"0x000000000000000000000000b886f567219a39b49a68115207787dce0a10b9e6"}}},"deployment":{"transactionHash":"0xbd8dd01caa8468f4db6f50faf1987f73aa6321e198a170a8e98b09fcee1453fc","blockNumber":"25590648","transactionIndex":"187","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/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/registry/IDSWalletRegistrar.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 IDSWalletRegistrar {\n\n    function initialize() public virtual;\n\n    function registerWallet(\n        string memory _id,\n        address[] calldata _wallets,\n        string calldata _collisionHash,\n        string memory _country,\n        uint8[] memory _attributeIds,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations /*onlyOwner*/\n    ) public virtual returns (bool);\n}\n"},"contracts/registry/WalletRegistrar.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 {IDSWalletRegistrar} from \"./IDSWalletRegistrar.sol\";\nimport {BaseDSContract} from \"../utils/BaseDSContract.sol\";\nimport {IDSRegistryService} from \"./IDSRegistryService.sol\";\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\ncontract WalletRegistrar is IDSWalletRegistrar, 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 registerWallet(\n        string memory _id,\n        address[] calldata _wallets,\n        string calldata _collisionHash,\n        string memory _country,\n        uint8[] memory _attributeIds,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations\n    ) public override onlyOwnerOrIssuerOrAbove returns (bool) {\n        IDSRegistryService registryService = getRegistryService();\n\n        registryService.updateInvestor(\n            _id,\n            _collisionHash,\n            _country,\n            _wallets,\n            _attributeIds,\n            _attributeValues,\n            _attributeExpirations\n        );\n\n        return true;\n    }\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":"WalletRegistrar","fullyQualifiedName":"contracts/registry/WalletRegistrar.sol:WalletRegistrar"},"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":"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":"registerWallet","type":"function","inputs":[{"name":"_id","type":"string","internalType":"string"},{"name":"_wallets","type":"address[]","internalType":"address[]"},{"name":"_collisionHash","type":"string","internalType":"string"},{"name":"_country","type":"string","internalType":"string"},{"name":"_attributeIds","type":"uint8[]","internalType":"uint8[]"},{"name":"_attributeValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_attributeExpirations","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"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":[],"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":[{"internalType":"string","name":"_id","type":"string"},{"internalType":"address[]","name":"_wallets","type":"address[]"},{"internalType":"string","name":"_collisionHash","type":"string"},{"internalType":"string","name":"_country","type":"string"},{"internalType":"uint8[]","name":"_attributeIds","type":"uint8[]"},{"internalType":"uint256[]","name":"_attributeValues","type":"uint256[]"},{"internalType":"uint256[]","name":"_attributeExpirations","type":"uint256[]"}],"name":"registerWallet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","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/registry/WalletRegistrar.sol":"WalletRegistrar"},"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/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/registry/IDSWalletRegistrar.sol":{"keccak256":"0xd6f9ec65127da744535d51d31963aaef48ab61987ed0de9e2b68ad89eb3e760d","license":"Apache-2.0","urls":["bzz-raw://1c9d5bd66c0b95f29d02abad93c27d12688ca2c40fb099494c535dfbd210745e","dweb:/ipfs/Qmc9StSQC4oZ4ndHYfEoH1g1dos48iLFcGKJ9Kq77Efv3S"]},"contracts/registry/WalletRegistrar.sol":{"keccak256":"0x5581b589f7b4ad485897c36bbe9ea9a2442ceb1f21d9b2f03b11de8e7ff039f0","license":"Apache-2.0","urls":["bzz-raw://541aa872df6f3f360e0f3714978b74cfb77c1dacdf4ab29cc37661a33b606125","dweb:/ipfs/QmbvteTAPRz4LDSi5Ccp8hVFQ2ZTxzofJjgRvUa99c8KSW"]},"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/registry/WalletRegistrar.sol:WalletRegistrar"},{"slot":"1","type":"t_array(t_uint256)49_storage","astId":2473,"label":"__gap","offset":0,"contract":"contracts/registry/WalletRegistrar.sol:WalletRegistrar"}]},"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/utils/BaseDSContract.sol":{"id":27},"contracts/trust/IDSTrustService.sol":{"id":26},"contracts/service/ServiceConsumer.sol":{"id":24},"contracts/registry/WalletRegistrar.sol":{"id":22},"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":20},"contracts/registry/IDSWalletRegistrar.sol":{"id":21},"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":19},"@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/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/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/registry/WalletRegistrar.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 {IDSWalletRegistrar} from \"./IDSWalletRegistrar.sol\";\nimport {BaseDSContract} from \"../utils/BaseDSContract.sol\";\nimport {IDSRegistryService} from \"./IDSRegistryService.sol\";\nimport {CommonUtils} from \"../utils/CommonUtils.sol\";\n\ncontract WalletRegistrar is IDSWalletRegistrar, 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 registerWallet(\n        string memory _id,\n        address[] calldata _wallets,\n        string calldata _collisionHash,\n        string memory _country,\n        uint8[] memory _attributeIds,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations\n    ) public override onlyOwnerOrIssuerOrAbove returns (bool) {\n        IDSRegistryService registryService = getRegistryService();\n\n        registryService.updateInvestor(\n            _id,\n            _collisionHash,\n            _country,\n            _wallets,\n            _attributeIds,\n            _attributeValues,\n            _attributeExpirations\n        );\n\n        return true;\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/registry/IDSWalletRegistrar.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 IDSWalletRegistrar {\n\n    function initialize() public virtual;\n\n    function registerWallet(\n        string memory _id,\n        address[] calldata _wallets,\n        string calldata _collisionHash,\n        string memory _country,\n        uint8[] memory _attributeIds,\n        uint256[] memory _attributeValues,\n        uint256[] memory _attributeExpirations /*onlyOwner*/\n    ) public virtual returns (bool);\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/utils/BaseDSContract.sol":{"id":27},"contracts/trust/IDSTrustService.sol":{"id":26},"contracts/service/ServiceConsumer.sol":{"id":24},"contracts/registry/WalletRegistrar.sol":{"id":22},"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":20},"contracts/registry/IDSWalletRegistrar.sol":{"id":21},"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":19},"@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/registry/WalletRegistrar.sol":{"WalletRegistrar":{"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":"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":"registerWallet","type":"function","inputs":[{"name":"_id","type":"string","internalType":"string"},{"name":"_wallets","type":"address[]","internalType":"address[]"},{"name":"_collisionHash","type":"string","internalType":"string"},{"name":"_country","type":"string","internalType":"string"},{"name":"_attributeIds","type":"uint8[]","internalType":"uint8[]"},{"name":"_attributeValues","type":"uint256[]","internalType":"uint256[]"},{"name":"_attributeExpirations","type":"uint256[]","internalType":"uint256[]"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"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\":[],\"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\":[{\"internalType\":\"string\",\"name\":\"_id\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"_wallets\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"_collisionHash\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_country\",\"type\":\"string\"},{\"internalType\":\"uint8[]\",\"name\":\"_attributeIds\",\"type\":\"uint8[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_attributeValues\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_attributeExpirations\",\"type\":\"uint256[]\"}],\"name\":\"registerWallet\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"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/registry/WalletRegistrar.sol\":\"WalletRegistrar\"},\"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/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/registry/IDSWalletRegistrar.sol\":{\"keccak256\":\"0xd6f9ec65127da744535d51d31963aaef48ab61987ed0de9e2b68ad89eb3e760d\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://1c9d5bd66c0b95f29d02abad93c27d12688ca2c40fb099494c535dfbd210745e\",\"dweb:/ipfs/Qmc9StSQC4oZ4ndHYfEoH1g1dos48iLFcGKJ9Kq77Efv3S\"]},\"contracts/registry/WalletRegistrar.sol\":{\"keccak256\":\"0x5581b589f7b4ad485897c36bbe9ea9a2442ceb1f21d9b2f03b11de8e7ff039f0\",\"license\":\"Apache-2.0\",\"urls\":[\"bzz-raw://541aa872df6f3f360e0f3714978b74cfb77c1dacdf4ab29cc37661a33b606125\",\"dweb:/ipfs/QmbvteTAPRz4LDSi5Ccp8hVFQ2ZTxzofJjgRvUa99c8KSW\"]},\"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/registry/WalletRegistrar.sol:WalletRegistrar"},{"slot":"1","type":"t_array(t_uint256)49_storage","astId":2473,"label":"__gap","offset":0,"contract":"contracts/registry/WalletRegistrar.sol:WalletRegistrar"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"926:968:22:-:0;;;1171:4:2;1128:48;;1048:53:22;;;;;;;;;-1:-1:-1;1072:22:22;:20;:22::i;:::-;926:968;;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:-;926:968:22;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"926:968:22:-: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;1213:679:22;;;;;;;;;;-1:-1:-1;1213:679:22;;;;;:::i;:::-;;:::i;779:36:23:-;;;;;;;;;;;;814:1;779:36;;1832:37:24;;;;;;;;;;;;1868:1;1832:37;;;;;6714:4:29;6702:17;;;6684:36;;6672:2;6657:18;1832:37:24;6542: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;;1107:100:22;;;;;;;;;;;;;:::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;:::-;;;8372:18:29;8360:31;;;8342:50;;8330:2;8315:18;1603:112:27;8198: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;;9373:25:29;;;9414:18;;;9407:60;5232:34:24::1;::::0;9346: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;1213:679:22:-;1558:4;4686:10:24;4675:7;:5;:7::i;:::-;-1:-1:-1;;;;;4675:21:24;;4672:248;;4712:28;4743:17;:15;:17::i;:::-;4782:32;;-1:-1:-1;;;4782:32:24;;4803:10;4782:32;;;789:51:29;4712:48:24;;-1:-1:-1;1911:1:24;;-1:-1:-1;;;;;4782:20:24;;;;;762:18:29;;4782:32:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:47;;;:98;;;-1:-1:-1;4833:32:24;;-1:-1:-1;;;4833:32:24;;4854:10;4833:32;;;789:51:29;1868:1:24;;-1:-1:-1;;;;;4833:20:24;;;;;762:18:29;;4833:32:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:47;;;4782:98;4774:135;;;;-1:-1:-1;;;4774:135:24;;;;;;;:::i;:::-;4698:222;4672:248;1574:34:22::1;1611:20;864:1:23::0;6052:18:24;5041:20;;;;;;;-1:-1:-1;;;;;5041:20:24;;1369:124:27;1611:20:22::1;1574:57;;1642:15;-1:-1:-1::0;;;;;1642:30:22::1;;1686:3;1703:14;;1731:8;1753;;1775:13;1802:16;1832:21;1642:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;1881:4:22::1;::::0;1213:679;-1:-1:-1;;;;;;;;;;;1213:679:22: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;1107:100:22:-:0;2655:13:2;:11;:13::i;:::-;3147:66:1;4302:15;;-1:-1:-1;;;4302:15:1;::::1;;;4301:16;::::0;4348:14:::1;;4158:30;4724:16:::0;;:34;::::1;;;;4744:14;4724:34;4704:54;;4768:17;4788:11;:16;;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;1177:23:22::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;8342:50:29;;5140:14:1::1;::::0;8330:2:29;8315:18;5140:14:1::1;;;;;;;5064:101;4092:1079;;;;;1107:100:22:o:0;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;;;;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;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;1671:281::-;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;1218:127::-;1279:10;1274:3;1270:20;1267:1;1260:31;1310:4;1307:1;1300:15;1334:4;1331:1;1324:15;1350:275;1421:2;1415:9;1486:2;1467:13;;-1:-1:-1;;1463:27:29;1451:40;;1521:18;1506:34;;1542:22;;;1503:62;1500:88;;;1568:18;;:::i;:::-;1604:2;1597:22;1350:275;;-1:-1:-1;1350:275:29:o;1630:407::-;1695:5;1729:18;1721:6;1718:30;1715:56;;;1751:18;;:::i;:::-;1789:57;1834:2;1813:15;;-1:-1:-1;;1809:29:29;1840:4;1805:40;1789:57;:::i;:::-;1780:66;;1869:6;1862:5;1855:21;1909:3;1900:6;1895:3;1891:16;1888:25;1885:45;;;1926:1;1923;1916:12;1885:45;1975:6;1970:3;1963:4;1956:5;1952:16;1939:43;2029:1;2022:4;2013:6;2006:5;2002:18;1998:29;1991:40;1630:407;;;;;:::o;2042:222::-;2085:5;2138:3;2131:4;2123:6;2119:17;2115:27;2105:55;;2156:1;2153;2146:12;2105:55;2178:80;2254:3;2245:6;2232:20;2225:4;2217:6;2213:17;2178:80;:::i;2269:367::-;2332:8;2342:6;2396:3;2389:4;2381:6;2377:17;2373:27;2363:55;;2414:1;2411;2404:12;2363:55;-1:-1:-1;2437:20:29;;2480:18;2469:30;;2466:50;;;2512:1;2509;2502:12;2466:50;2549:4;2541:6;2537:17;2525:29;;2609:3;2602:4;2592:6;2589:1;2585:14;2577:6;2573:27;2569:38;2566:47;2563:67;;;2626:1;2623;2616:12;2563:67;2269:367;;;;;:::o;2641:348::-;2693:8;2703:6;2757:3;2750:4;2742:6;2738:17;2734:27;2724:55;;2775:1;2772;2765:12;2724:55;-1:-1:-1;2798:20:29;;2841:18;2830:30;;2827:50;;;2873:1;2870;2863:12;2827:50;2910:4;2902:6;2898:17;2886:29;;2962:3;2955:4;2946:6;2938;2934:19;2930:30;2927:39;2924:59;;;2979:1;2976;2969:12;2994:181;3052:4;3085:18;3077:6;3074:30;3071:56;;;3107:18;;:::i;:::-;-1:-1:-1;3152:1:29;3148:14;3164:4;3144:25;;2994:181::o;3180:114::-;3264:4;3257:5;3253:16;3246:5;3243:27;3233:55;;3284:1;3281;3274:12;3299:737;3351:5;3404:3;3397:4;3389:6;3385:17;3381:27;3371:55;;3422:1;3419;3412:12;3371:55;3458:6;3445:20;3484:4;3508:58;3524:41;3562:2;3524:41;:::i;:::-;3508:58;:::i;:::-;3588:3;3612:2;3607:3;3600:15;3640:4;3635:3;3631:14;3624:21;;3697:4;3691:2;3688:1;3684:10;3676:6;3672:23;3668:34;3654:48;;3725:3;3717:6;3714:15;3711:35;;;3742:1;3739;3732:12;3711:35;3778:4;3770:6;3766:17;3792:215;3808:6;3803:3;3800:15;3792:215;;;3888:3;3875:17;3905:29;3928:5;3905:29;:::i;:::-;3947:18;;3985:12;;;;3825;;3792:215;;;-1:-1:-1;4025:5:29;3299:737;-1:-1:-1;;;;;;3299:737:29:o;4041:666::-;4095:5;4148:3;4141:4;4133:6;4129:17;4125:27;4115:55;;4166:1;4163;4156:12;4115:55;4202:6;4189:20;4228:4;4252:58;4268:41;4306:2;4268:41;:::i;4252:58::-;4332:3;4356:2;4351:3;4344:15;4384:4;4379:3;4375:14;4368:21;;4441:4;4435:2;4432:1;4428:10;4420:6;4416:23;4412:34;4398:48;;4469:3;4461:6;4458:15;4455:35;;;4486:1;4483;4476:12;4455:35;4522:4;4514:6;4510:17;4536:142;4552:6;4547:3;4544:15;4536:142;;;4618:17;;4606:30;;4656:12;;;;4569;;4536:142;;4712:1825;4957:6;4965;4973;4981;4989;4997;5005;5013;5021;5074:3;5062:9;5053:7;5049:23;5045:33;5042:53;;;5091:1;5088;5081:12;5042:53;5131:9;5118:23;5160:18;5201:2;5193:6;5190:14;5187:34;;;5217:1;5214;5207:12;5187:34;5240:50;5282:7;5273:6;5262:9;5258:22;5240:50;:::i;:::-;5230:60;;5343:2;5332:9;5328:18;5315:32;5299:48;;5372:2;5362:8;5359:16;5356:36;;;5388:1;5385;5378:12;5356:36;5427:72;5491:7;5480:8;5469:9;5465:24;5427:72;:::i;:::-;5518:8;;-1:-1:-1;5401:98:29;-1:-1:-1;5606:2:29;5591:18;;5578:32;;-1:-1:-1;5622:16:29;;;5619:36;;;5651:1;5648;5641:12;5619:36;5690:61;5743:7;5732:8;5721:9;5717:24;5690:61;:::i;:::-;5770:8;;-1:-1:-1;5664:87:29;-1:-1:-1;5858:2:29;5843:18;;5830:32;;-1:-1:-1;5874:16:29;;;5871:36;;;5903:1;5900;5893:12;5871:36;5926:52;5970:7;5959:8;5948:9;5944:24;5926:52;:::i;:::-;5916:62;;6031:3;6020:9;6016:19;6003:33;5987:49;;6061:2;6051:8;6048:16;6045:36;;;6077:1;6074;6067:12;6045:36;6100:61;6153:7;6142:8;6131:9;6127:24;6100:61;:::i;:::-;6090:71;;6214:3;6203:9;6199:19;6186:33;6170:49;;6244:2;6234:8;6231:16;6228:36;;;6260:1;6257;6250:12;6228:36;6283:63;6338:7;6327:8;6316:9;6312:24;6283:63;:::i;:::-;6273:73;;6399:3;6388:9;6384:19;6371:33;6355:49;;6429:2;6419:8;6416:16;6413:36;;;6445:1;6442;6435:12;6413:36;;6468:63;6523:7;6512:8;6501:9;6497:24;6468:63;:::i;:::-;6458:73;;;4712:1825;;;;;;;;;;;:::o;6731:524::-;6808:6;6816;6869:2;6857:9;6848:7;6844:23;6840:32;6837:52;;;6885:1;6882;6875:12;6837:52;6908:29;6927:9;6908:29;:::i;:::-;6898:39;;6988:2;6977:9;6973:18;6960:32;7015:18;7007:6;7004:30;7001:50;;;7047:1;7044;7037:12;7001:50;7070:22;;7123:4;7115:13;;7111:27;-1:-1:-1;7101:55:29;;7152:1;7149;7142:12;7101:55;7175:74;7241:7;7236:2;7223:16;7218:2;7214;7210:11;7175:74;:::i;:::-;7165:84;;;6731:524;;;;;:::o;7442:250::-;7527:1;7537:113;7551:6;7548:1;7545:13;7537:113;;;7627:11;;;7621:18;7608:11;;;7601:39;7573:2;7566:10;7537:113;;;-1:-1:-1;;7684:1:29;7666:16;;7659:27;7442:250::o;7697:271::-;7739:3;7777:5;7771:12;7804:6;7799:3;7792:19;7820:76;7889:6;7882:4;7877:3;7873:14;7866:4;7859:5;7855:16;7820:76;:::i;:::-;7950:2;7929:15;-1:-1:-1;;7925:29:29;7916:39;;;;7957:4;7912:50;;7697:271;-1:-1:-1;;7697:271:29:o;7973:220::-;8122:2;8111:9;8104:21;8085:4;8142:45;8183:2;8172:9;8168:18;8160:6;8142:45;:::i;8403:186::-;8462:6;8515:2;8503:9;8494:7;8490:23;8486:32;8483:52;;;8531:1;8528;8521:12;8483:52;8554:29;8573:9;8554:29;:::i;8594:247::-;8662:6;8715:2;8703:9;8694:7;8690:23;8686:32;8683:52;;;8731:1;8728;8721:12;8683:52;8763:9;8757:16;8782:29;8805:5;8782:29;:::i;8846:348::-;9048:2;9030:21;;;9087:2;9067:18;;;9060:30;9126:26;9121:2;9106:18;;9099:54;9185:2;9170:18;;8846:348::o;9478:449::-;9578:6;9573:3;9566:19;9548:3;9604:4;9633;9628:3;9624:14;9617:21;;9661:5;9684:1;9694:208;9708:6;9705:1;9702:13;9694:208;;;-1:-1:-1;;;;;9773:26:29;9792:6;9773:26;:::i;:::-;9769:52;9757:65;;9842:12;;;;9877:15;;;;9730:1;9723:9;9694:208;;;-1:-1:-1;9918:3:29;;9478:449;-1:-1:-1;;;;;9478:449:29:o;9932:448::-;9983:3;10021:5;10015:12;10048:6;10043:3;10036:19;10074:4;10103;10098:3;10094:14;10087:21;;10142:4;10135:5;10131:16;10165:1;10175:180;10189:6;10186:1;10183:13;10175:180;;;10254:13;;10269:4;10250:24;10238:37;;10295:12;;;;10330:15;;;;10211:1;10204:9;10175:180;;10385:439;10438:3;10476:5;10470:12;10503:6;10498:3;10491:19;10529:4;10558;10553:3;10549:14;10542:21;;10597:4;10590:5;10586:16;10620:1;10630:169;10644:6;10641:1;10638:13;10630:169;;;10705:13;;10693:26;;10739:12;;;;10774:15;;;;10666:1;10659:9;10630:169;;10829:1546;11402:3;11391:9;11384:22;11365:4;11429:46;11470:3;11459:9;11455:19;11447:6;11429:46;:::i;:::-;11523:9;11515:6;11511:22;11506:2;11495:9;11491:18;11484:50;11558:6;11550;11543:22;11612:6;11604;11599:2;11591:6;11587:15;11574:45;11665:1;11660:2;11651:6;11643;11639:19;11635:28;11628:39;11723:2;11719:7;11714:2;11706:6;11702:15;11698:29;11690:6;11686:42;11676:52;;11788:2;11776:9;11772:2;11768:18;11764:27;11759:2;11748:9;11744:18;11737:55;11815:38;11849:2;11845;11841:11;11833:6;11815:38;:::i;:::-;11801:52;;11901:9;11893:6;11889:22;11884:2;11873:9;11869:18;11862:50;11935:61;11989:6;11981;11973;11935:61;:::i;:::-;11921:75;;12045:9;12037:6;12033:22;12027:3;12016:9;12012:19;12005:51;12079:42;12114:6;12106;12079:42;:::i;:::-;12065:56;;12170:9;12162:6;12158:22;12152:3;12141:9;12137:19;12130:51;12204:44;12241:6;12233;12204:44;:::i;:::-;12190:58;;12297:9;12289:6;12285:22;12279:3;12268:9;12264:19;12257:51;12325:44;12362:6;12354;12325:44;:::i;:::-;12317:52;10829:1546;-1:-1:-1;;;;;;;;;;;;10829:1546:29:o;12380:277::-;12447:6;12500:2;12488:9;12479:7;12475:23;12471:32;12468:52;;;12516:1;12513;12506:12;12468:52;12548:9;12542:16;12601:5;12594:13;12587:21;12580:5;12577:32;12567:60;;12623:1;12620;12613:12;12876:184;12946:6;12999:2;12987:9;12978:7;12974:23;12970:32;12967:52;;;13015:1;13012;13005:12;12967:52;-1:-1:-1;13038:16:29;;12876:184;-1:-1:-1;12876:184:29:o;13065:287::-;13194:3;13232:6;13226:13;13248:66;13307:6;13302:3;13295:4;13287:6;13283:17;13248:66;:::i;:::-;13330:16;;;;;13065:287;-1:-1:-1;;13065:287:29:o","linkReferences":{},"immutableReferences":{"482":[{"start":3103,"length":32},{"start":3144,"length":32},{"start":3633,"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":"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":"registerWallet(string,address[],string,string,uint8[],uint256[],uint256[])","signatureHash4":"0x25d9084b","signatureHash32":"0x25d9084b873d7aa68caa9c31575735936716044f82db9a1770a4b207b464a506"},{"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":"0xb886F567219A39B49A68115207787DCe0A10b9E6"}