{"matchId":"51416842","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-09-21T08:57:39Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x60a060405234801561001057600080fd5b5060405161122338038061122383398101604081905261002f91610070565b600280546001600160a01b0319166001600160a01b03928316179055166080526100a3565b80516001600160a01b038116811461006b57600080fd5b919050565b6000806040838503121561008357600080fd5b61008c83610054565b915061009a60208401610054565b90509250929050565b6080516111506100d3600039600081816104fa01528181610819015281816109970152610aaa01526111506000f3fe608060405234801561001057600080fd5b506004361061011b5760003560e01c8063ad6129ac116100b2578063d17bc78311610081578063dfadc79411610066578063dfadc79414610291578063f3fef3a3146102a4578063ff3c43e1146102b757600080fd5b8063d17bc78314610276578063d9fb43531461027e57600080fd5b8063ad6129ac14610210578063b5f680ae14610218578063bbac3b8d1461022b578063c53b3fbe1461025257600080fd5b806350eea0c8116100ee57806350eea0c8146101ad57806362744405146101c05780639d754dde146101e85780639f856b8d146101fb57600080fd5b80631de4161314610120578063371abc951461015a5780634738761c1461018557806348a50fcf14610198575b600080fd5b6101477fb77a63f119f4dc2174dc6c76fc1a1565fa4f2b0dde50ed5c0465471cd9b331f681565b6040519081526020015b60405180910390f35b60005461016d906001600160a01b031681565b6040516001600160a01b039091168152602001610151565b60015461016d906001600160a01b031681565b6101ab6101a6366004610ff0565b6102ca565b005b6101ab6101bb366004610ff0565b6103ac565b6000546101d590600160b81b900461ffff1681565b60405161ffff9091168152602001610151565b60025461016d906001600160a01b031681565b6000546101d590600160a01b900461ffff1681565b6101ab610454565b6101ab610226366004610ff0565b6104bf565b6101477f63e58c34d94475ba3fc063e19800b940485850d84d09cd3c1f2c14192c559a6881565b60005461026690600160b01b900460ff1681565b6040519015158152602001610151565b6101ab610635565b6101ab61028c36600461100b565b6106c7565b6101ab61029f36600461102f565b6107ca565b6101ab6102b23660046110a4565b610948565b6101ab6102c536600461100b565b610a6f565b6002546001600160a01b031633146103295760405162461bcd60e51b815260206004820152601860248201527f6f6e6c7920616c676562726120666565206d616e61676572000000000000000060448201526064015b60405180910390fd5b6001600160a01b03811661033c57600080fd5b6001546001600160a01b039081169082160361035757600080fd5b600180546001600160a01b0319166001600160a01b0383169081179091556040519081527f34d1b5ef1c1c2c03a5000b91bef5c465790244c6751c794e5b45bed7657c38fd906020015b60405180910390a150565b6002546001600160a01b031633146104065760405162461bcd60e51b815260206004820152601860248201527f6f6e6c7920616c676562726120666565206d616e6167657200000000000000006044820152606401610320565b600380546001600160a01b0319166001600160a01b0383169081179091556040519081527fab6918ba7303f2f81e46e324b5f34af4bda562577c1da710e2034980fee1e82a906020016103a1565b6003546001600160a01b0316331461046b57600080fd5b60028054336001600160a01b031991821681179092556003805490911690556040519081527fecf97a11fb2f2bcc38d1b6881865ecc04405af2d8b953004c79b3ab398732d029060200160405180910390a1565b60405163e8ae2b6960e01b81527f63e58c34d94475ba3fc063e19800b940485850d84d09cd3c1f2c14192c559a6860048201523360248201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169063e8ae2b6990604401602060405180830381865afa158015610549573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061056d91906110ce565b6105b95760405162461bcd60e51b815260206004820152601260248201527f6f6e6c792061646d696e6973747261746f7200000000000000000000000000006044820152606401610320565b6001600160a01b0381166105cc57600080fd5b6000546001600160a01b03908116908216036105e757600080fd5b600080546001600160a01b0319166001600160a01b0383169081179091556040519081527f2f4db788b994a5908051d68a2340153f49870447185a244d2326861e60cc4186906020016103a1565b6002546001600160a01b0316331461068f5760405162461bcd60e51b815260206004820152601860248201527f6f6e6c7920616c676562726120666565206d616e6167657200000000000000006044820152606401610320565b6000805462ffffff60b01b191681556040517f9f4bbade0736edbd2ec12c598bdac4573af13a3b57820ae4c7da5c61703eaaff9190a1565b6002546001600160a01b031633146107215760405162461bcd60e51b815260206004820152601860248201527f6f6e6c7920616c676562726120666565206d616e6167657200000000000000006044820152606401610320565b6103e861ffff8216111561073457600080fd5b60005461ffff828116600160b81b9092041614801590610764575060005461ffff828116600160a01b9092041614155b61076d57600080fd5b6000805461ffff8316600160b81b0262ffffff60b01b1990911617600160b01b1790556040517f2d6ac59d6da98f80c7ea481d17c670ea310b000fff5cf1732d94d93652dd25b7906103a190839061ffff91909116815260200190565b6002546001600160a01b031633148061088c575060405163e8ae2b6960e01b81527fb77a63f119f4dc2174dc6c76fc1a1565fa4f2b0dde50ed5c0465471cd9b331f660048201523360248201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169063e8ae2b6990604401602060405180830381865afa158015610868573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061088c91906110ce565b6108ca5760405162461bcd60e51b815260206004820152600f60248201526e37b7363c903bb4ba34323930bbb2b960891b6044820152606401610320565b80600080806108d7610c94565b92509250925060005b8481101561093f576109378787838181106108fd576108fd6110f0565b6109139260206040909202019081019150610ff0565b83898985818110610926576109266110f0565b905060400201602001358787610d6a565b6001016108e0565b50505050505050565b6002546001600160a01b0316331480610a0a575060405163e8ae2b6960e01b81527fb77a63f119f4dc2174dc6c76fc1a1565fa4f2b0dde50ed5c0465471cd9b331f660048201523360248201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169063e8ae2b6990604401602060405180830381865afa1580156109e6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a0a91906110ce565b610a485760405162461bcd60e51b815260206004820152600f60248201526e37b7363c903bb4ba34323930bbb2b960891b6044820152606401610320565b6000806000610a55610c94565b925092509250610a688582868686610d6a565b5050505050565b60405163e8ae2b6960e01b81527f63e58c34d94475ba3fc063e19800b940485850d84d09cd3c1f2c14192c559a6860048201523360248201527f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03169063e8ae2b6990604401602060405180830381865afa158015610af9573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b1d91906110ce565b610b695760405162461bcd60e51b815260206004820152601260248201527f6f6e6c792061646d696e6973747261746f7200000000000000000000000000006044820152606401610320565b600054600160b01b900460ff16610bc25760405162461bcd60e51b815260206004820152600c60248201527f6e6f742070726f706f73656400000000000000000000000000000000000000006044820152606401610320565b60005461ffff828116600160b81b9092041614610c215760405162461bcd60e51b815260206004820152600f60248201527f696e76616c6964206e65772066656500000000000000000000000000000000006044820152606401610320565b600080547fffffffffffffff0000000000ffffffffffffffffffffffffffffffffffffffff16600160a01b61ffff841690810262ffffff60b01b1916919091179091556040519081527fda1e1a9a6410acc0398b3b64e0c0110b8df57e29bfe69a419cdd9ae12718c307906020016103a1565b60005460015461ffff600160a01b830416916001600160a01b0391821691168215610d0f576001600160a01b038216610d0f5760405162461bcd60e51b815260206004820152601c60248201527f696e76616c696420616c676562726120666565207265636569766572000000006044820152606401610320565b6001600160a01b038116610d655760405162461bcd60e51b815260206004820152601060248201527f696e76616c6964207265636569766572000000000000000000000000000000006044820152606401610320565b909192565b8261ffff831615610df0576000610d888261ffff86166103e8610e50565b9050610d948183611106565b9150610da1878483610ed1565b826001600160a01b0316876001600160a01b03167fb7ee7fc9dacb957cfa93faeb8ca1826292de295e18e287a347dddfde7ab48b4083604051610de691815260200190565b60405180910390a3505b610dfb868683610ed1565b846001600160a01b0316866001600160a01b03167f7a629b77ef27ad337abe438773206187960a90abfb43607826bef77d650e84b983604051610e4091815260200190565b60405180910390a3505050505050565b6000831580610e7157505082820282848281610e6e57610e6e61112d565b04145b15610e925760008211610e8357600080fd5b81810490829006151501610eca565b610e9d848484610f3b565b905060008280610eaf57610eaf61112d565b8486091115610eca576000198110610ec657600080fd5b6001015b9392505050565b600060405163a9059cbb60e01b6000526001600160a01b03841660045282602452602060006044600080895af19150813d1560203d146001600051141617169150806040525080610f3557604051637232c81f60e11b815260040160405180910390fd5b50505050565b60008383028160001985870982811083820303915050808411610f5d57600080fd5b80600003610f7057508290049050610eca565b8385870960008581038616958690049560026003880281188089028203028089028203028089028203028089028203028089028203028089029091030291819003819004600101858411909403939093029190930391909104170290509392505050565b80356001600160a01b0381168114610feb57600080fd5b919050565b60006020828403121561100257600080fd5b610eca82610fd4565b60006020828403121561101d57600080fd5b813561ffff81168114610eca57600080fd5b6000806020838503121561104257600080fd5b823567ffffffffffffffff8082111561105a57600080fd5b818501915085601f83011261106e57600080fd5b81358181111561107d57600080fd5b8660208260061b850101111561109257600080fd5b60209290920196919550909350505050565b600080604083850312156110b757600080fd5b6110c083610fd4565b946020939093013593505050565b6000602082840312156110e057600080fd5b81518015158114610eca57600080fd5b634e487b7160e01b600052603260045260246000fd5b8181038181111561112757634e487b7160e01b600052601160045260246000fd5b92915050565b634e487b7160e01b600052601260045260246000fdfea164736f6c6343000814000a","sourceMap":"432:6230:0:-:0;;;2063:130;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2137:17;2127:61;;-1:-1:-1;;;;;;2127:61:0;-1:-1:-1;;;;;2127:61:0;;;;;;;;;432:6230;;14:177:8;93:13;;-1:-1:-1;;;;;135:31:8;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;:::-;432:6230:0;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c6343000814000a","offset":4631}},"transformations":[{"type":"insert","offset":4643,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x00000000000000000000000044b7fbd4d87149efa5347c451e74b9fd18e89c55000000000000000000000000c815b4e0abae3155f8f4f9e404f17c9fa6928eb8"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"432:6230:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;546:93;;602:37;546:93;;;;;160:25:8;;;148:2;133:18;546:93:0;;;;;;;;910:35;;;;;-1:-1:-1;;;;;910:35:0;;;;;;-1:-1:-1;;;;;360:55:8;;;342:74;;330:2;315:18;910:35:0;196:226:8;1356:33:0;;;;;-1:-1:-1;;;;;1356:33:0;;;6342:318;;;;;;:::i;:::-;;:::i;:::-;;5145:228;;;;;;:::i;:::-;;:::i;1252:35::-;;;;;-1:-1:-1;;;1252:35:0;;;;;;;;;993:6:8;981:19;;;963:38;;951:2;936:18;1252:35:0;819:188:8;1438:32:0;;;;;-1:-1:-1;;;;;1438:32:0;;;1066:24;;;;;-1:-1:-1;;;1066:24:0;;;;;;5418:235;;;:::i;4713:332::-;;;;;;:::i;:::-;;:::i;696:106::-;;756:46;696:106;;1170:36;;;;;-1:-1:-1;;;1170:36:0;;;;;;;;;1177:14:8;;1170:22;1152:41;;1140:2;1125:18;1170:36:0;1012:187:8;6105:192:0;;;:::i;5698:362::-;;;;;;:::i;:::-;;:::i;2578:436::-;;;;;;:::i;:::-;;:::i;2238:295::-;;;;;;:::i;:::-;;:::i;4190:478::-;;;;;;:::i;:::-;;:::i;6342:318::-;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;;;;;;;;;-1:-1:-1;;;;;6461:35:0;::::1;6453:44;;;::::0;::::1;;6536:18;::::0;-1:-1:-1;;;;;6536:18:0;;::::1;6511:43:::0;;::::1;::::0;6503:52:::1;;;::::0;::::1;;6561:18;:42:::0;;-1:-1:-1;;;;;;6561:42:0::1;-1:-1:-1::0;;;;;6561:42:0;::::1;::::0;;::::1;::::0;;;6614:41:::1;::::0;342:74:8;;;6614:41:0::1;::::0;330:2:8;315:18;6614:41:0::1;;;;;;;;6342:318:::0;:::o;5145:228::-;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;2399:348:8;1979:68:0;5261:25:::1;:49:::0;;-1:-1:-1;;;;;;5261:49:0::1;-1:-1:-1::0;;;;;5261:49:0;::::1;::::0;;::::1;::::0;;;5321:47:::1;::::0;342:74:8;;;5321:47:0::1;::::0;330:2:8;315:18;5321:47:0::1;196:226:8::0;5418:235:0;5503:25;;-1:-1:-1;;;;;5503:25:0;5489:10;:39;5481:48;;;;;;5563:17;5535:73;;5597:10;-1:-1:-1;;;;;;5535:73:0;;;;;;;;5536:25;5535:73;;;;;;;5619:29;;342:74:8;;;5619:29:0;;330:2:8;315:18;5619:29:0;;;;;;;5418:235::o;4713:332::-;1622:86;;-1:-1:-1;;;1622:86:0;;756:46;1622:86;;;2926:25:8;1697:10:0;2967:18:8;;;2960:83;1638:7:0;-1:-1:-1;;;;;1622:39:0;;;;2899:18:8;;1622:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1614:117;;;;-1:-1:-1;;;1614:117:0;;3538:2:8;1614:117:0;;;3520:21:8;3577:2;3557:18;;;3550:30;3616:20;3596:18;;;3589:48;3654:18;;1614:117:0;3336:342:8;1614:117:0;-1:-1:-1;;;;;4832:37:0;::::1;4824:46;;;::::0;::::1;;4911:20;::::0;-1:-1:-1;;;;;4911:20:0;;::::1;4884:47:::0;;::::1;::::0;4876:56:::1;;;::::0;::::1;;4938:20;:46:::0;;-1:-1:-1;;;;;;4938:46:0::1;-1:-1:-1::0;;;;;4938:46:0;::::1;::::0;;::::1;::::0;;;4995:45:::1;::::0;342:74:8;;;4995:45:0::1;::::0;330:2:8;315:18;4995:45:0::1;196:226:8::0;6105:192:0;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;2399:348:8;1979:68:0;6246:1:::1;6193:62:::0;;-1:-1:-1;;;;6193:62:0;;;6266:26:::1;::::0;::::1;::::0;6246:1;6266:26:::1;6105:192::o:0;5698:362::-;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;2399:348:8;1979:68:0;1570:4:::1;5807:40;::::0;::::1;;;5799:49;;;::::0;::::1;;5879:21;::::0;::::1;5862:38:::0;;::::1;-1:-1:-1::0;;;5879:21:0;;::::1;;5862:38;::::0;::::1;::::0;:69:::1;;-1:-1:-1::0;5921:10:0::1;::::0;::::1;5904:27:::0;;::::1;-1:-1:-1::0;;;5921:10:0;;::::1;;5904:27;;5862:69;5854:78;;;::::0;::::1;;5939:21;5938:73:::0;;::::1;::::0;::::1;-1:-1:-1::0;;;5938:73:0::1;-1:-1:-1::0;;;;5938:73:0;;;;-1:-1:-1;;;5938:73:0;;;6022:33:::1;::::0;::::1;::::0;::::1;::::0;5991:13;;993:6:8;981:19;;;;963:38;;951:2;936:18;;819:188;2578:436:0;1801:17;;-1:-1:-1;;;;;1801:17:0;1787:10;:31;;:117;;-1:-1:-1;1822:82:0;;-1:-1:-1;;;1822:82:0;;602:37;1822:82;;;2926:25:8;1893:10:0;2967:18:8;;;2960:83;1838:7:0;-1:-1:-1;;;;;1822:39:0;;;;2899:18:8;;1822:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1779:145;;;;-1:-1:-1;;;1779:145:0;;3885:2:8;1779:145:0;;;3867:21:8;3924:2;3904:18;;;3897:30;-1:-1:-1;;;3943:18:8;;;3936:45;3998:18;;1779:145:0;3683:339:8;1779:145:0;2704:6;2681:20:::1;::::0;;2806:32:::1;:30;:32::i;:::-;2723:115;;;;;;2868:9;2863:140;2883:12;2879:1;:16;2863:140;;;2902:101;2912:6;;2919:1;2912:9;;;;;;;:::i;:::-;:15;::::0;::::1;:9;::::0;;::::1;;:15:::0;;::::1;::::0;-1:-1:-1;2912:15:0::1;:::i;:::-;2929:21;2952:6;;2959:1;2952:9;;;;;;;:::i;:::-;;;;;;:16;;;2970:11;2983:19;2902:9;:101::i;:::-;2897:3;;2863:140;;;;2675:339;;;;2578:436:::0;;:::o;2238:295::-;1801:17;;-1:-1:-1;;;;;1801:17:0;1787:10;:31;;:117;;-1:-1:-1;1822:82:0;;-1:-1:-1;;;1822:82:0;;602:37;1822:82;;;2926:25:8;1893:10:0;2967:18:8;;;2960:83;1838:7:0;-1:-1:-1;;;;;1822:39:0;;;;2899:18:8;;1822:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1779:145;;;;-1:-1:-1;;;1779:145:0;;3885:2:8;1779:145:0;;;3867:21:8;3924:2;3904:18;;;3897:30;-1:-1:-1;;;3943:18:8;;;3936:45;3998:18;;1779:145:0;3683:339:8;1779:145:0;2327:18:::1;2347:27:::0;2376:29:::1;2409:32;:30;:32::i;:::-;2326:115;;;;;;2447:81;2457:5;2464:21;2487:6;2495:11;2508:19;2447:9;:81::i;:::-;2320:213;;;2238:295:::0;;:::o;4190:478::-;1622:86;;-1:-1:-1;;;1622:86:0;;756:46;1622:86;;;2926:25:8;1697:10:0;2967:18:8;;;2960:83;1638:7:0;-1:-1:-1;;;;;1622:39:0;;;;2899:18:8;;1622:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1614:117;;;;-1:-1:-1;;;1614:117:0;;3538:2:8;1614:117:0;;;3520:21:8;3577:2;3557:18;;;3550:30;3616:20;3596:18;;;3589:48;3654:18;;1614:117:0;3336:342:8;1614:117:0;4302:24:::1;::::0;-1:-1:-1;;;4302:24:0;::::1;;;4294:49;;;::::0;-1:-1:-1;;;4294:49:0;;4361:2:8;4294:49:0::1;::::0;::::1;4343:21:8::0;4400:2;4380:18;;;4373:30;4439:14;4419:18;;;4412:42;4471:18;;4294:49:0::1;4159:336:8::0;4294:49:0::1;4374:21;::::0;::::1;4357:38:::0;;::::1;-1:-1:-1::0;;;4374:21:0;;::::1;;4357:38;4349:66;;;::::0;-1:-1:-1;;;4349:66:0;;4702:2:8;4349:66:0::1;::::0;::::1;4684:21:8::0;4741:2;4721:18;;;4714:30;4780:17;4760:18;;;4753:45;4815:18;;4349:66:0::1;4500:339:8::0;4349:66:0::1;4533:10;:26:::0;;4565:62;;-1:-1:-1;;;4533:26:0::1;::::0;::::1;::::0;;::::1;-1:-1:-1::0;;;;4565:62:0;;;;;;;;4638:25:::1;::::0;963:38:8;;;4638:25:0::1;::::0;951:2:8;936:18;4638:25:0::1;819:188:8::0;3018:441:0;3082:18;3229:10;3241:18;;3229:10;-1:-1:-1;;;3229:10:0;;;;-1:-1:-1;;;;;3241:18:0;;;;3261:20;3292:16;;3288:96;;-1:-1:-1;;;;;3318:33:0;;3310:74;;;;-1:-1:-1;;;3310:74:0;;5046:2:8;3310:74:0;;;5028:21:8;5085:2;5065:18;;;5058:30;5124;5104:18;;;5097:58;5172:18;;3310:74:0;4844:352:8;3310:74:0;-1:-1:-1;;;;;3398:35:0;;3390:64;;;;-1:-1:-1;;;3390:64:0;;5403:2:8;3390:64:0;;;5385:21:8;5442:2;5422:18;;;5415:30;5481:18;5461;;;5454:46;5517:18;;3390:64:0;5201:340:8;3390:64:0;3018:441;;;:::o;3463:625::-;3613:6;3629:16;;;;3625:346;;3655:24;3682:79;3708:14;3682:79;;;1570:4;3682:25;:79::i;:::-;3655:106;-1:-1:-1;3769:34:0;3655:106;3769:34;;:::i;:::-;;;3811:71;3837:5;3844:19;3865:16;3811:25;:71::i;:::-;3926:19;-1:-1:-1;;;;;3895:69:0;3919:5;-1:-1:-1;;;;;3895:69:0;;3947:16;3895:69;;;;160:25:8;;148:2;133:18;;14:177;3895:69:0;;;;;;;;3647:324;3625:346;3977:52;4003:5;4010:2;4014:14;3977:25;:52::i;:::-;4064:2;-1:-1:-1;;;;;4040:43:0;4057:5;-1:-1:-1;;;;;4040:43:0;;4068:14;4040:43;;;;160:25:8;;148:2;133:18;;14:177;4040:43:0;;;;;;;;3582:506;3463:625;;;;;:::o;4485:521:6:-;4577:14;4621:6;;;:37;;-1:-1:-1;;4642:5:6;;;4656:1;4651;4642:5;4651:1;4632:20;;;;:::i;:::-;;:25;4621:37;4617:379;;;4692:1;4678:11;:15;4670:24;;;;;;4739;;;4768;;;;4765:31;;4735:62;4617:379;;;4840:25;4847:1;4850;4853:11;4840:6;:25::i;:::-;4831:34;;4907:1;4892:11;4879:25;;;;;:::i;:::-;4889:1;4886;4879:25;:29;4875:113;;;-1:-1:-1;;4930:6:6;:26;4922:35;;;;;;4969:8;;4875:113;4485:521;;;;;:::o;865:967:7:-;945:12;1011:4;1005:11;-1:-1:-1;;;1067:4:7;1060:80;-1:-1:-1;;;;;1204:2:7;1200:51;1194:4;1187:65;1303:6;1297:4;1290:20;1433:4;1430:1;1424:4;1421:1;1418;1411:5;1404;1399:39;1388:50;;1673:7;1645:16;1638:24;1632:2;1614:16;1611:24;1607:1;1603;1597:8;1594:15;1590:46;1587:76;1456:232;1445:243;;1708:17;1702:4;1695:31;;1776:7;1771:56;;1792:35;;-1:-1:-1;;;1792:35:7;;;;;;;;;;;1771:56;939:893;865:967;;;:::o;727:3488:6:-;809:14;1158:5;;;809:14;-1:-1:-1;;1162:1:6;1158;1310:20;1375:5;1371:2;1368:13;1360:5;1356:2;1352:14;1348:34;1339:43;;;1511:5;1497:11;:19;1489:28;;;;;;1586:5;1595:1;1586:10;1582:121;;-1:-1:-1;1639:23:6;;;;-1:-1:-1;1681:13:6;;1582:121;2072:11;2069:1;2066;2059:25;2322:12;2338:15;;;2337:31;;2454:22;;;;;3217:1;3198;:15;;3197:21;;3436:17;;;3432:21;;3425:28;3492:17;;;3488:21;;3481:28;3549:17;;;3545:21;;3538:28;3606:17;;;3602:21;;3595:28;3663:17;;;3659:21;;3652:28;3721:17;;;3717:21;;;3710:28;2802:12;;;;2798:23;;;2823:1;2794:31;2113:20;;;2102:32;;;2849:12;;;;2152:21;;;;2572:16;;;;2840:21;4172:11;;-1:-1:-1;727:3488:6;;;;;:::o;427:196:8:-;495:20;;-1:-1:-1;;;;;544:54:8;;534:65;;524:93;;613:1;610;603:12;524:93;427:196;;;:::o;628:186::-;687:6;740:2;728:9;719:7;715:23;711:32;708:52;;;756:1;753;746:12;708:52;779:29;798:9;779:29;:::i;1204:272::-;1262:6;1315:2;1303:9;1294:7;1290:23;1286:32;1283:52;;;1331:1;1328;1321:12;1283:52;1370:9;1357:23;1420:6;1413:5;1409:18;1402:5;1399:29;1389:57;;1442:1;1439;1432:12;1481:654;1606:6;1614;1667:2;1655:9;1646:7;1642:23;1638:32;1635:52;;;1683:1;1680;1673:12;1635:52;1723:9;1710:23;1752:18;1793:2;1785:6;1782:14;1779:34;;;1809:1;1806;1799:12;1779:34;1847:6;1836:9;1832:22;1822:32;;1892:7;1885:4;1881:2;1877:13;1873:27;1863:55;;1914:1;1911;1904:12;1863:55;1954:2;1941:16;1980:2;1972:6;1969:14;1966:34;;;1996:1;1993;1986:12;1966:34;2049:7;2044:2;2034:6;2031:1;2027:14;2023:2;2019:23;2015:32;2012:45;2009:65;;;2070:1;2067;2060:12;2009:65;2101:2;2093:11;;;;;2123:6;;-1:-1:-1;1481:654:8;;-1:-1:-1;;;;1481:654:8:o;2140:254::-;2208:6;2216;2269:2;2257:9;2248:7;2244:23;2240:32;2237:52;;;2285:1;2282;2275:12;2237:52;2308:29;2327:9;2308:29;:::i;:::-;2298:39;2384:2;2369:18;;;;2356:32;;-1:-1:-1;;;2140:254:8:o;3054:277::-;3121:6;3174:2;3162:9;3153:7;3149:23;3145:32;3142:52;;;3190:1;3187;3180:12;3142:52;3222:9;3216:16;3275:5;3268:13;3261:21;3254:5;3251:32;3241:60;;3297:1;3294;3287:12;4027:127;4088:10;4083:3;4079:20;4076:1;4069:31;4119:4;4116:1;4109:15;4143:4;4140:1;4133:15;5546:225;5613:9;;;5634:11;;;5631:134;;;5687:10;5682:3;5678:20;5675:1;5668:31;5722:4;5719:1;5712:15;5750:4;5747:1;5740:15;5631:134;5546:225;;;;:::o;5958:127::-;6019:10;6014:3;6010:20;6007:1;6000:31;6050:4;6047:1;6040:15;6074:4;6071:1;6064:15","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c6343000814000a","offset":4420}},"immutableReferences":{"22":[{"start":1274,"length":32},{"start":2073,"length":32},{"start":2455,"length":32},{"start":2730,"length":32}]},"transformations":[{"id":"22","type":"replace","offset":1274,"reason":"immutable"},{"id":"22","type":"replace","offset":2073,"reason":"immutable"},{"id":"22","type":"replace","offset":2455,"reason":"immutable"},{"id":"22","type":"replace","offset":2730,"reason":"immutable"}],"transformationValues":{"immutables":{"22":"0x00000000000000000000000044b7fbd4d87149efa5347c451e74b9fd18e89c55"}}},"deployment":{"transactionHash":"0x74a78c469db20e114dc13fe0af14b5813ba9e553ed1599c758102be719d9a11d","blockNumber":"24420333","transactionIndex":"7","deployer":"0xe09077b24996d122d681cD085328Bd7853a58AC2"},"sources":{"contracts/libraries/FullMath.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Contains 512-bit math functions\n/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision\n/// @dev Handles \"phantom overflow\" i.e., allows multiplication and division where an intermediate value overflows 256 bits\nlibrary FullMath {\n  /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n  /// @param a The multiplicand\n  /// @param b The multiplier\n  /// @param denominator The divisor\n  /// @return result The 256-bit result\n  /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv\n  function mulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {\n    unchecked {\n      // 512-bit multiply [prod1 prod0] = a * b\n      // Compute the product mod 2**256 and mod 2**256 - 1\n      // then use the Chinese Remainder Theorem to reconstruct\n      // the 512 bit result. The result is stored in two 256\n      // variables such that product = prod1 * 2**256 + prod0\n      uint256 prod0 = a * b; // Least significant 256 bits of the product\n      uint256 prod1; // Most significant 256 bits of the product\n      assembly {\n        let mm := mulmod(a, b, not(0))\n        prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n      }\n\n      // Make sure the result is less than 2**256.\n      // Also prevents denominator == 0\n      require(denominator > prod1);\n\n      // Handle non-overflow cases, 256 by 256 division\n      if (prod1 == 0) {\n        assembly {\n          result := div(prod0, denominator)\n        }\n        return result;\n      }\n\n      ///////////////////////////////////////////////\n      // 512 by 256 division.\n      ///////////////////////////////////////////////\n\n      // Make division exact by subtracting the remainder from [prod1 prod0]\n      // Compute remainder using mulmod\n      // Subtract 256 bit remainder from 512 bit number\n      assembly {\n        let remainder := mulmod(a, b, denominator)\n        prod1 := sub(prod1, gt(remainder, prod0))\n        prod0 := sub(prod0, remainder)\n      }\n\n      // Factor powers of two out of denominator\n      // Compute largest power of two divisor of denominator.\n      // Always >= 1.\n      uint256 twos = (0 - denominator) & denominator;\n      // Divide denominator by power of two\n      assembly {\n        denominator := div(denominator, twos)\n      }\n\n      // Divide [prod1 prod0] by the factors of two\n      assembly {\n        prod0 := div(prod0, twos)\n      }\n      // Shift in bits from prod1 into prod0. For this we need\n      // to flip `twos` such that it is 2**256 / twos.\n      // If twos is zero, then it becomes one\n      assembly {\n        twos := add(div(sub(0, twos), twos), 1)\n      }\n      prod0 |= prod1 * twos;\n\n      // Invert denominator mod 2**256\n      // Now that denominator is an odd number, it has an inverse\n      // modulo 2**256 such that denominator * inv = 1 mod 2**256.\n      // Compute the inverse by starting with a seed that is correct\n      // correct for four bits. That is, denominator * inv = 1 mod 2**4\n      uint256 inv = (3 * denominator) ^ 2;\n      // Now use Newton-Raphson iteration to improve the precision.\n      // Thanks to Hensel's lifting lemma, this also works in modular\n      // arithmetic, doubling the correct bits in each step.\n      inv *= 2 - denominator * inv; // inverse mod 2**8\n      inv *= 2 - denominator * inv; // inverse mod 2**16\n      inv *= 2 - denominator * inv; // inverse mod 2**32\n      inv *= 2 - denominator * inv; // inverse mod 2**64\n      inv *= 2 - denominator * inv; // inverse mod 2**128\n      inv *= 2 - denominator * inv; // inverse mod 2**256\n\n      // Because the division is now exact we can divide by multiplying\n      // with the modular inverse of denominator. This will give us the\n      // correct result modulo 2**256. Since the preconditions guarantee\n      // that the outcome is less than 2**256, this is the final result.\n      // We don't need to compute the high bits of the result and prod1\n      // is no longer required.\n      result = prod0 * inv;\n      return result;\n    }\n  }\n\n  /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n  /// @param a The multiplicand\n  /// @param b The multiplier\n  /// @param denominator The divisor\n  /// @return result The 256-bit result\n  function mulDivRoundingUp(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {\n    unchecked {\n      if (a == 0 || ((result = a * b) / a == b)) {\n        require(denominator > 0);\n        assembly {\n          result := add(div(result, denominator), gt(mod(result, denominator), 0))\n        }\n      } else {\n        result = mulDiv(a, b, denominator);\n        if (mulmod(a, b, denominator) > 0) {\n          require(result < type(uint256).max);\n          result++;\n        }\n      }\n    }\n  }\n\n  /// @notice Returns ceil(x / y)\n  /// @dev division by 0 has unspecified behavior, and must be checked externally\n  /// @param x The dividend\n  /// @param y The divisor\n  /// @return z The quotient, ceil(x / y)\n  function unsafeDivRoundingUp(uint256 x, uint256 y) internal pure returns (uint256 z) {\n    assembly {\n      z := add(div(x, y), gt(mod(x, y), 0))\n    }\n  }\n}\n"},"contracts/AlgebraCommunityVault.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity =0.8.20;\n\nimport './libraries/SafeTransfer.sol';\nimport './libraries/FullMath.sol';\n\nimport './interfaces/IAlgebraFactory.sol';\nimport './interfaces/vault/IAlgebraCommunityVault.sol';\n\n/// @title Algebra community fee vault\n/// @notice Community fee from pools is sent here, if it is enabled\n/// @dev Role system is used to withdraw tokens\n/// @dev Version: Algebra Integral 1.0\ncontract AlgebraCommunityVault is IAlgebraCommunityVault {\n  /// @dev The role can be granted in AlgebraFactory\n  bytes32 public constant COMMUNITY_FEE_WITHDRAWER_ROLE = keccak256('COMMUNITY_FEE_WITHDRAWER');\n  /// @dev The role can be granted in AlgebraFactory\n  bytes32 public constant COMMUNITY_FEE_VAULT_ADMINISTRATOR = keccak256('COMMUNITY_FEE_VAULT_ADMINISTRATOR');\n  address private immutable factory;\n\n  /// @notice Address to which community fees are sent from vault\n  address public communityFeeReceiver;\n  /// @notice The percentage of the protocol fee that Algebra will receive\n  /// @dev Value in thousandths,i.e. 1e-3\n  uint16 public algebraFee;\n  /// @notice Represents whether there is a new Algebra fee proposal or not\n  bool public hasNewAlgebraFeeProposal;\n  /// @notice Suggested Algebra fee value\n  uint16 public proposedNewAlgebraFee;\n  /// @notice Address of recipient Algebra part of community fee\n  address public algebraFeeReceiver;\n  /// @notice Address of Algebra fee manager\n  address public algebraFeeManager;\n  address private _pendingAlgebraFeeManager;\n\n  uint16 private constant ALGEBRA_FEE_DENOMINATOR = 1000;\n\n  modifier onlyAdministrator() {\n    require(IAlgebraFactory(factory).hasRoleOrOwner(COMMUNITY_FEE_VAULT_ADMINISTRATOR, msg.sender), 'only administrator');\n    _;\n  }\n\n  modifier onlyWithdrawer() {\n    require(msg.sender == algebraFeeManager || IAlgebraFactory(factory).hasRoleOrOwner(COMMUNITY_FEE_WITHDRAWER_ROLE, msg.sender), 'only withdrawer');\n    _;\n  }\n\n  modifier onlyAlgebraFeeManager() {\n    require(msg.sender == algebraFeeManager, 'only algebra fee manager');\n    _;\n  }\n\n  constructor(address _factory, address _algebraFeeManager) {\n    (factory, algebraFeeManager) = (_factory, _algebraFeeManager);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function withdraw(address token, uint256 amount) external override onlyWithdrawer {\n    (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) = _readAndVerifyWithdrawSettings();\n    _withdraw(token, _communityFeeReceiver, amount, _algebraFee, _algebraFeeReceiver);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function withdrawTokens(WithdrawTokensParams[] calldata params) external override onlyWithdrawer {\n    uint256 paramsLength = params.length;\n    (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) = _readAndVerifyWithdrawSettings();\n\n    unchecked {\n      for (uint256 i; i < paramsLength; ++i) _withdraw(params[i].token, _communityFeeReceiver, params[i].amount, _algebraFee, _algebraFeeReceiver);\n    }\n  }\n\n  function _readAndVerifyWithdrawSettings() private view returns (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) {\n    (_algebraFee, _algebraFeeReceiver, _communityFeeReceiver) = (algebraFee, algebraFeeReceiver, communityFeeReceiver);\n    if (_algebraFee != 0) require(_algebraFeeReceiver != address(0), 'invalid algebra fee receiver');\n    require(_communityFeeReceiver != address(0), 'invalid receiver');\n  }\n\n  function _withdraw(address token, address to, uint256 amount, uint16 _algebraFee, address _algebraFeeReceiver) private {\n    uint256 withdrawAmount = amount;\n    if (_algebraFee != 0) {\n      uint256 algebraFeeAmount = FullMath.mulDivRoundingUp(withdrawAmount, _algebraFee, ALGEBRA_FEE_DENOMINATOR);\n      withdrawAmount -= algebraFeeAmount;\n      SafeTransfer.safeTransfer(token, _algebraFeeReceiver, algebraFeeAmount);\n      emit AlgebraTokensWithdrawal(token, _algebraFeeReceiver, algebraFeeAmount);\n    }\n\n    SafeTransfer.safeTransfer(token, to, withdrawAmount);\n    emit TokensWithdrawal(token, to, withdrawAmount);\n  }\n\n  // ### algebra factory owner permissioned actions ###\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function acceptAlgebraFeeChangeProposal(uint16 newAlgebraFee) external override onlyAdministrator {\n    require(hasNewAlgebraFeeProposal, 'not proposed');\n    require(newAlgebraFee == proposedNewAlgebraFee, 'invalid new fee');\n\n    // note that the new value will be used for previously accumulated tokens that have not yet been withdrawn\n    algebraFee = newAlgebraFee;\n    (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (0, false);\n    emit AlgebraFee(newAlgebraFee);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function changeCommunityFeeReceiver(address newCommunityFeeReceiver) external override onlyAdministrator {\n    require(newCommunityFeeReceiver != address(0));\n    require(newCommunityFeeReceiver != communityFeeReceiver);\n    communityFeeReceiver = newCommunityFeeReceiver;\n    emit CommunityFeeReceiver(newCommunityFeeReceiver);\n  }\n\n  // ### algebra fee manager permissioned actions ###\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function transferAlgebraFeeManagerRole(address _newAlgebraFeeManager) external override onlyAlgebraFeeManager {\n    _pendingAlgebraFeeManager = _newAlgebraFeeManager;\n    emit PendingAlgebraFeeManager(_newAlgebraFeeManager);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function acceptAlgebraFeeManagerRole() external override {\n    require(msg.sender == _pendingAlgebraFeeManager);\n    (_pendingAlgebraFeeManager, algebraFeeManager) = (address(0), msg.sender);\n    emit AlgebraFeeManager(msg.sender);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function proposeAlgebraFeeChange(uint16 newAlgebraFee) external override onlyAlgebraFeeManager {\n    require(newAlgebraFee <= ALGEBRA_FEE_DENOMINATOR);\n    require(newAlgebraFee != proposedNewAlgebraFee && newAlgebraFee != algebraFee);\n    (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (newAlgebraFee, true);\n    emit AlgebraFeeProposal(newAlgebraFee);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function cancelAlgebraFeeChangeProposal() external override onlyAlgebraFeeManager {\n    (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (0, false);\n    emit CancelAlgebraFeeProposal();\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function changeAlgebraFeeReceiver(address newAlgebraFeeReceiver) external override onlyAlgebraFeeManager {\n    require(newAlgebraFeeReceiver != address(0));\n    require(newAlgebraFeeReceiver != algebraFeeReceiver);\n    algebraFeeReceiver = newAlgebraFeeReceiver;\n    emit AlgebraFeeReceiver(newAlgebraFeeReceiver);\n  }\n}\n"},"contracts/libraries/SafeTransfer.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.4 <0.9.0;\n\nimport '../interfaces/pool/IAlgebraPoolErrors.sol';\n\n/// @title SafeTransfer\n/// @notice Safe ERC20 transfer library that gracefully handles missing return values.\n/// @dev Credit to Solmate under MIT license: https://github.com/transmissions11/solmate/blob/ed67feda67b24fdeff8ad1032360f0ee6047ba0a/src/utils/SafeTransferLib.sol\n/// @dev Please note that this library does not check if the token has a code! That responsibility is delegated to the caller.\nlibrary SafeTransfer {\n  /// @notice Transfers tokens to a recipient\n  /// @dev Calls transfer on token contract, errors with transferFailed() if transfer fails\n  /// @param token The contract address of the token which will be transferred\n  /// @param to The recipient of the transfer\n  /// @param amount The amount of the token to transfer\n  function safeTransfer(address token, address to, uint256 amount) internal {\n    bool success;\n    assembly {\n      let freeMemoryPointer := mload(0x40) // we will need to restore 0x40 slot\n      mstore(0x00, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) // \"transfer(address,uint256)\" selector\n      mstore(0x04, and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // append cleaned \"to\" address\n      mstore(0x24, amount)\n      // now we use 0x00 - 0x44 bytes (68), freeMemoryPointer is dirty\n      success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n      success := and(\n        // set success to true if call isn't reverted and returned exactly 1 (can't just be non-zero data) or nothing\n        or(and(eq(mload(0), 1), eq(returndatasize(), 32)), iszero(returndatasize())),\n        success\n      )\n      mstore(0x40, freeMemoryPointer) // restore the freeMemoryPointer\n    }\n\n    if (!success) revert IAlgebraPoolErrors.transferFailed();\n  }\n}\n"},"contracts/interfaces/IAlgebraFactory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\npragma abicoder v2;\n\nimport './plugin/IAlgebraPluginFactory.sol';\nimport './vault/IAlgebraVaultFactory.sol';\n\n/// @title The interface for the Algebra Factory\n/// @dev Credit to Uniswap Labs under GPL-2.0-or-later license:\n/// https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces\ninterface IAlgebraFactory {\n  /// @notice Emitted when a process of ownership renounce is started\n  /// @param timestamp The timestamp of event\n  /// @param finishTimestamp The timestamp when ownership renounce will be possible to finish\n  event RenounceOwnershipStart(uint256 timestamp, uint256 finishTimestamp);\n\n  /// @notice Emitted when a process of ownership renounce cancelled\n  /// @param timestamp The timestamp of event\n  event RenounceOwnershipStop(uint256 timestamp);\n\n  /// @notice Emitted when a process of ownership renounce finished\n  /// @param timestamp The timestamp of ownership renouncement\n  event RenounceOwnershipFinish(uint256 timestamp);\n\n  /// @notice Emitted when a pool is created\n  /// @param token0 The first token of the pool by address sort order\n  /// @param token1 The second token of the pool by address sort order\n  /// @param pool The address of the created pool\n  event Pool(address indexed token0, address indexed token1, address pool);\n\n  /// @notice Emitted when the default community fee is changed\n  /// @param newDefaultCommunityFee The new default community fee value\n  event DefaultCommunityFee(uint16 newDefaultCommunityFee);\n\n  /// @notice Emitted when the default tickspacing is changed\n  /// @param newDefaultTickspacing The new default tickspacing value\n  event DefaultTickspacing(int24 newDefaultTickspacing);\n\n  /// @notice Emitted when the default fee is changed\n  /// @param newDefaultFee The new default fee value\n  event DefaultFee(uint16 newDefaultFee);\n\n  /// @notice Emitted when the defaultPluginFactory address is changed\n  /// @param defaultPluginFactoryAddress The new defaultPluginFactory address\n  event DefaultPluginFactory(address defaultPluginFactoryAddress);\n\n  /// @notice Emitted when the vaultFactory address is changed\n  /// @param newVaultFactory The new vaultFactory address\n  event VaultFactory(address newVaultFactory);\n\n  /// @notice role that can change communityFee and tickspacing in pools\n  /// @return The hash corresponding to this role\n  function POOLS_ADMINISTRATOR_ROLE() external view returns (bytes32);\n\n  /// @notice Returns `true` if `account` has been granted `role` or `account` is owner.\n  /// @param role The hash corresponding to the role\n  /// @param account The address for which the role is checked\n  /// @return bool Whether the address has this role or the owner role or not\n  function hasRoleOrOwner(bytes32 role, address account) external view returns (bool);\n\n  /// @notice Returns the current owner of the factory\n  /// @dev Can be changed by the current owner via transferOwnership(address newOwner)\n  /// @return The address of the factory owner\n  function owner() external view returns (address);\n\n  /// @notice Returns the current poolDeployerAddress\n  /// @return The address of the poolDeployer\n  function poolDeployer() external view returns (address);\n\n  /// @notice Returns the default community fee\n  /// @return Fee which will be set at the creation of the pool\n  function defaultCommunityFee() external view returns (uint16);\n\n  /// @notice Returns the default fee\n  /// @return Fee which will be set at the creation of the pool\n  function defaultFee() external view returns (uint16);\n\n  /// @notice Returns the default tickspacing\n  /// @return Tickspacing which will be set at the creation of the pool\n  function defaultTickspacing() external view returns (int24);\n\n  /// @notice Return the current pluginFactory address\n  /// @dev This contract is used to automatically set a plugin address in new liquidity pools\n  /// @return Algebra plugin factory\n  function defaultPluginFactory() external view returns (IAlgebraPluginFactory);\n\n  /// @notice Return the current vaultFactory address\n  /// @dev This contract is used to automatically set a vault address in new liquidity pools\n  /// @return Algebra vault factory\n  function vaultFactory() external view returns (IAlgebraVaultFactory);\n\n  /// @notice Returns the default communityFee, tickspacing, fee and communityFeeVault for pool\n  /// @param pool the address of liquidity pool\n  /// @return communityFee which will be set at the creation of the pool\n  /// @return tickSpacing which will be set at the creation of the pool\n  /// @return fee which will be set at the creation of the pool\n  /// @return communityFeeVault the address of communityFeeVault\n  function defaultConfigurationForPool(\n    address pool\n  ) external view returns (uint16 communityFee, int24 tickSpacing, uint16 fee, address communityFeeVault);\n\n  /// @notice Deterministically computes the pool address given the token0 and token1\n  /// @dev The method does not check if such a pool has been created\n  /// @param token0 first token\n  /// @param token1 second token\n  /// @return pool The contract address of the Algebra pool\n  function computePoolAddress(address token0, address token1) external view returns (address pool);\n\n  /// @notice Returns the pool address for a given pair of tokens, or address 0 if it does not exist\n  /// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order\n  /// @param tokenA The contract address of either token0 or token1\n  /// @param tokenB The contract address of the other token\n  /// @return pool The pool address\n  function poolByPair(address tokenA, address tokenB) external view returns (address pool);\n\n  /// @notice returns keccak256 of AlgebraPool init bytecode.\n  /// @dev the hash value changes with any change in the pool bytecode\n  /// @return Keccak256 hash of AlgebraPool contract init bytecode\n  function POOL_INIT_CODE_HASH() external view returns (bytes32);\n\n  /// @return timestamp The timestamp of the beginning of the renounceOwnership process\n  function renounceOwnershipStartTimestamp() external view returns (uint256 timestamp);\n\n  /// @notice Creates a pool for the given two tokens\n  /// @param tokenA One of the two tokens in the desired pool\n  /// @param tokenB The other of the two tokens in the desired pool\n  /// @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0.\n  /// The call will revert if the pool already exists or the token arguments are invalid.\n  /// @return pool The address of the newly created pool\n  function createPool(address tokenA, address tokenB) external returns (address pool);\n\n  /// @dev updates default community fee for new pools\n  /// @param newDefaultCommunityFee The new community fee, _must_ be <= MAX_COMMUNITY_FEE\n  function setDefaultCommunityFee(uint16 newDefaultCommunityFee) external;\n\n  /// @dev updates default fee for new pools\n  /// @param newDefaultFee The new  fee, _must_ be <= MAX_DEFAULT_FEE\n  function setDefaultFee(uint16 newDefaultFee) external;\n\n  /// @dev updates default tickspacing for new pools\n  /// @param newDefaultTickspacing The new tickspacing, _must_ be <= MAX_TICK_SPACING and >= MIN_TICK_SPACING\n  function setDefaultTickspacing(int24 newDefaultTickspacing) external;\n\n  /// @dev updates pluginFactory address\n  /// @param newDefaultPluginFactory address of new plugin factory\n  function setDefaultPluginFactory(address newDefaultPluginFactory) external;\n\n  /// @dev updates vaultFactory address\n  /// @param newVaultFactory address of new vault factory\n  function setVaultFactory(address newVaultFactory) external;\n\n  /// @notice Starts process of renounceOwnership. After that, a certain period\n  /// of time must pass before the ownership renounce can be completed.\n  function startRenounceOwnership() external;\n\n  /// @notice Stops process of renounceOwnership and removes timer.\n  function stopRenounceOwnership() external;\n}\n"},"contracts/interfaces/pool/IAlgebraPoolErrors.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.8.4;\n\n/// @title Errors emitted by a pool\n/// @notice Contains custom errors emitted by the pool\n/// @dev Custom errors are separated from the common pool interface for compatibility with older versions of Solidity\ninterface IAlgebraPoolErrors {\n  // ####  pool errors  ####\n\n  /// @notice Emitted by the reentrancy guard\n  error locked();\n\n  /// @notice Emitted if arithmetic error occurred\n  error arithmeticError();\n\n  /// @notice Emitted if an attempt is made to initialize the pool twice\n  error alreadyInitialized();\n\n  /// @notice Emitted if an attempt is made to mint or swap in uninitialized pool\n  error notInitialized();\n\n  /// @notice Emitted if 0 is passed as amountRequired to swap function\n  error zeroAmountRequired();\n\n  /// @notice Emitted if invalid amount is passed as amountRequired to swap function\n  error invalidAmountRequired();\n\n  /// @notice Emitted if the pool received fewer tokens than it should have\n  error insufficientInputAmount();\n\n  /// @notice Emitted if there was an attempt to mint zero liquidity\n  error zeroLiquidityDesired();\n  /// @notice Emitted if actual amount of liquidity is zero (due to insufficient amount of tokens received)\n  error zeroLiquidityActual();\n\n  /// @notice Emitted if the pool received fewer tokens0 after flash than it should have\n  error flashInsufficientPaid0();\n  /// @notice Emitted if the pool received fewer tokens1 after flash than it should have\n  error flashInsufficientPaid1();\n\n  /// @notice Emitted if limitSqrtPrice param is incorrect\n  error invalidLimitSqrtPrice();\n\n  /// @notice Tick must be divisible by tickspacing\n  error tickIsNotSpaced();\n\n  /// @notice Emitted if a method is called that is accessible only to the factory owner or dedicated role\n  error notAllowed();\n\n  /// @notice Emitted if new tick spacing exceeds max allowed value\n  error invalidNewTickSpacing();\n  /// @notice Emitted if new community fee exceeds max allowed value\n  error invalidNewCommunityFee();\n\n  /// @notice Emitted if an attempt is made to manually change the fee value, but dynamic fee is enabled\n  error dynamicFeeActive();\n  /// @notice Emitted if an attempt is made by plugin to change the fee value, but dynamic fee is disabled\n  error dynamicFeeDisabled();\n  /// @notice Emitted if an attempt is made to change the plugin configuration, but the plugin is not connected\n  error pluginIsNotConnected();\n  /// @notice Emitted if a plugin returns invalid selector after hook call\n  /// @param expectedSelector The expected selector\n  error invalidHookResponse(bytes4 expectedSelector);\n\n  // ####  LiquidityMath errors  ####\n\n  /// @notice Emitted if liquidity underflows\n  error liquiditySub();\n  /// @notice Emitted if liquidity overflows\n  error liquidityAdd();\n\n  // ####  TickManagement errors  ####\n\n  /// @notice Emitted if the topTick param not greater then the bottomTick param\n  error topTickLowerOrEqBottomTick();\n  /// @notice Emitted if the bottomTick param is lower than min allowed value\n  error bottomTickLowerThanMIN();\n  /// @notice Emitted if the topTick param is greater than max allowed value\n  error topTickAboveMAX();\n  /// @notice Emitted if the liquidity value associated with the tick exceeds MAX_LIQUIDITY_PER_TICK\n  error liquidityOverflow();\n  /// @notice Emitted if an attempt is made to interact with an uninitialized tick\n  error tickIsNotInitialized();\n  /// @notice Emitted if there is an attempt to insert a new tick into the list of ticks with incorrect indexes of the previous and next ticks\n  error tickInvalidLinks();\n\n  // ####  SafeTransfer errors  ####\n\n  /// @notice Emitted if token transfer failed internally\n  error transferFailed();\n\n  // ####  TickMath errors  ####\n\n  /// @notice Emitted if tick is greater than the maximum or less than the minimum allowed value\n  error tickOutOfRange();\n  /// @notice Emitted if price is greater than the maximum or less than the minimum allowed value\n  error priceOutOfRange();\n}\n"},"contracts/interfaces/vault/IAlgebraVaultFactory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\n/// @title The interface for the Algebra Vault Factory\n/// @notice This contract can be used for automatic vaults creation\n/// @dev Version: Algebra Integral\ninterface IAlgebraVaultFactory {\n  /// @notice returns address of the community fee vault for the pool\n  /// @param pool the address of Algebra Integral pool\n  /// @return communityFeeVault the address of community fee vault\n  function getVaultForPool(address pool) external view returns (address communityFeeVault);\n\n  /// @notice creates the community fee vault for the pool if needed\n  /// @param pool the address of Algebra Integral pool\n  /// @return communityFeeVault the address of community fee vault\n  function createVaultForPool(address pool) external returns (address communityFeeVault);\n}\n"},"contracts/interfaces/plugin/IAlgebraPluginFactory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\n/// @title An interface for a contract that is capable of deploying Algebra plugins\n/// @dev Such a factory is needed if the plugin should be automatically created and connected to each new pool\ninterface IAlgebraPluginFactory {\n  /// @notice Deploys new plugin contract for pool\n  /// @param pool The address of the pool for which the new plugin will be created\n  /// @param token0 First token of the pool\n  /// @param token1 Second token of the pool\n  /// @return New plugin address\n  function createPlugin(address pool, address token0, address token1) external returns (address);\n}\n"},"contracts/interfaces/vault/IAlgebraCommunityVault.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\n/// @title The interface for the Algebra community fee vault\n/// @notice Community fee from pools is sent here, if it is enabled\n/// @dev Version: Algebra Integral\ninterface IAlgebraCommunityVault {\n  /// @notice Event emitted when a fees has been claimed\n  /// @param token The address of token fee\n  /// @param to The address where claimed rewards were sent to\n  /// @param amount The amount of fees tokens claimed by communityFeeReceiver\n  event TokensWithdrawal(address indexed token, address indexed to, uint256 amount);\n\n  /// @notice Event emitted when a fees has been claimed\n  /// @param token The address of token fee\n  /// @param to The address where claimed rewards were sent to\n  /// @param amount The amount of fees tokens claimed by Algebra\n  event AlgebraTokensWithdrawal(address indexed token, address indexed to, uint256 amount);\n\n  /// @notice Emitted when a AlgebraFeeReceiver address changed\n  /// @param newAlgebraFeeReceiver New Algebra fee receiver address\n  event AlgebraFeeReceiver(address newAlgebraFeeReceiver);\n\n  /// @notice Emitted when a AlgebraFeeManager address change proposed\n  /// @param pendingAlgebraFeeManager New pending Algebra fee manager address\n  event PendingAlgebraFeeManager(address pendingAlgebraFeeManager);\n\n  /// @notice Emitted when a new Algebra fee value proposed\n  /// @param proposedNewAlgebraFee The new proposed Algebra fee value\n  event AlgebraFeeProposal(uint16 proposedNewAlgebraFee);\n\n  /// @notice Emitted when a Algebra fee proposal canceled\n  event CancelAlgebraFeeProposal();\n\n  /// @notice Emitted when a AlgebraFeeManager address changed\n  /// @param newAlgebraFeeManager New Algebra fee manager address\n  event AlgebraFeeManager(address newAlgebraFeeManager);\n\n  /// @notice Emitted when the Algebra fee is changed\n  /// @param newAlgebraFee The new Algebra fee value\n  event AlgebraFee(uint16 newAlgebraFee);\n\n  /// @notice Emitted when a CommunityFeeReceiver address changed\n  /// @param newCommunityFeeReceiver New fee receiver address\n  event CommunityFeeReceiver(address newCommunityFeeReceiver);\n\n  /// @notice Withdraw protocol fees from vault\n  /// @dev Can only be called by algebraFeeManager or communityFeeReceiver\n  /// @param token The token address\n  /// @param amount The amount of token\n  function withdraw(address token, uint256 amount) external;\n\n  struct WithdrawTokensParams {\n    address token;\n    uint256 amount;\n  }\n\n  /// @notice Withdraw protocol fees from vault. Used to claim fees for multiple tokens\n  /// @dev Can be called by algebraFeeManager or communityFeeReceiver\n  /// @param params Array of WithdrawTokensParams objects containing token addresses and amounts to withdraw\n  function withdrawTokens(WithdrawTokensParams[] calldata params) external;\n\n  // ### algebra factory owner permissioned actions ###\n\n  /// @notice Accepts the proposed new Algebra fee\n  /// @dev Can only be called by the factory owner.\n  /// The new value will also be used for previously accumulated tokens that have not yet been withdrawn\n  /// @param newAlgebraFee New Algebra fee value\n  function acceptAlgebraFeeChangeProposal(uint16 newAlgebraFee) external;\n\n  /// @notice Change community fee receiver address\n  /// @dev Can only be called by the factory owner\n  /// @param newCommunityFeeReceiver New community fee receiver address\n  function changeCommunityFeeReceiver(address newCommunityFeeReceiver) external;\n\n  // ### algebra fee manager permissioned actions ###\n\n  /// @notice Transfers Algebra fee manager role\n  /// @param _newAlgebraFeeManager new Algebra fee manager address\n  function transferAlgebraFeeManagerRole(address _newAlgebraFeeManager) external;\n\n  /// @notice accept Algebra FeeManager role\n  function acceptAlgebraFeeManagerRole() external;\n\n  /// @notice Proposes new Algebra fee value for protocol\n  /// @dev the new value will also be used for previously accumulated tokens that have not yet been withdrawn\n  /// @param newAlgebraFee new Algebra fee value\n  function proposeAlgebraFeeChange(uint16 newAlgebraFee) external;\n\n  /// @notice Cancels Algebra fee change proposal\n  function cancelAlgebraFeeChangeProposal() external;\n\n  /// @notice Change Algebra community fee part receiver\n  /// @param newAlgebraFeeReceiver The address of new Algebra fee receiver\n  function changeAlgebraFeeReceiver(address newAlgebraFeeReceiver) external;\n}\n"},"@flarenetwork/flare-periphery-contracts/flare/RewardsV2Interface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.7.6 <0.9;\n\n/**\n * Rewards V2 long term support interface.\n */\ninterface RewardsV2Interface {\n\n    /// Claim type enum.\n    enum ClaimType { DIRECT, FEE, WNAT, MIRROR, CCHAIN }\n\n   /// Struct used for claiming rewards with Merkle proof.\n    struct RewardClaimWithProof {\n        bytes32[] merkleProof;\n        RewardClaim body;\n    }\n\n    /// Struct used in Merkle tree for storing reward claims.\n    struct RewardClaim {\n        uint24 rewardEpochId;\n        bytes20 beneficiary; // c-chain address or node id (bytes20) in case of type MIRROR\n        uint120 amount; // in wei\n        ClaimType claimType;\n    }\n\n    /// Struct used for returning state of rewards.\n    struct RewardState {\n        uint24 rewardEpochId;\n        bytes20 beneficiary; // c-chain address or node id (bytes20) in case of type MIRROR\n        uint120 amount; // in wei\n        ClaimType claimType;\n        bool initialised;\n    }\n\n    /**\n     * Claim rewards for `_rewardOwner` and transfer them to `_recipient`.\n     * It can be called by reward owner or its authorized executor.\n     * @param _rewardOwner Address of the reward owner.\n     * @param _recipient Address of the reward recipient.\n     * @param _rewardEpochId Id of the reward epoch up to which the rewards are claimed.\n     * @param _wrap Indicates if the reward should be wrapped (deposited) to the WNAT contract.\n     * @param _proofs Array of reward claims with merkle proofs.\n     * @return _rewardAmountWei Amount of rewarded native tokens (wei).\n     */\n    function claim(\n        address _rewardOwner,\n        address payable _recipient,\n        uint24 _rewardEpochId,\n        bool _wrap,\n        RewardClaimWithProof[] calldata _proofs\n    )\n        external\n        returns (uint256 _rewardAmountWei);\n\n    /**\n     * Indicates if the contract is active - claims are enabled.\n     */\n    function active() external view returns (bool);\n\n    /**\n     * Returns the start and the end of the reward epoch range for which the reward is claimable.\n     * @return _startEpochId The oldest epoch id that allows reward claiming.\n     * @return _endEpochId The newest epoch id that allows reward claiming.\n     */\n    function getRewardEpochIdsWithClaimableRewards()\n        external view\n        returns (\n            uint24 _startEpochId,\n            uint24 _endEpochId\n        );\n\n    /**\n     * Returns the next claimable reward epoch for a reward owner.\n     * @param _rewardOwner Address of the reward owner to query.\n     */\n    function getNextClaimableRewardEpochId(address _rewardOwner) external view returns (uint256);\n\n    /**\n     * Returns the state of rewards for a given address for all unclaimed reward epochs with claimable rewards.\n     * @param _rewardOwner Address of the reward owner.\n     * @return _rewardStates Array of reward states.\n     */\n    function getStateOfRewards(\n        address _rewardOwner\n    )\n        external view\n        returns (\n            RewardState[][] memory _rewardStates\n        );\n\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.20+commit.a1b79de6","compilerSettings":{"metadata":{"bytecodeHash":"none"},"libraries":{},"optimizer":{"runs":800,"enabled":true},"evmVersion":"paris","remappings":[]},"name":"AlgebraCommunityVault","fullyQualifiedName":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},"abi":[{"type":"constructor","inputs":[{"name":"_factory","type":"address","internalType":"address"},{"name":"_algebraFeeManager","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"transferFailed","type":"error","inputs":[]},{"name":"AlgebraFee","type":"event","inputs":[{"name":"newAlgebraFee","type":"uint16","indexed":false,"internalType":"uint16"}],"anonymous":false},{"name":"AlgebraFeeManager","type":"event","inputs":[{"name":"newAlgebraFeeManager","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"AlgebraFeeProposal","type":"event","inputs":[{"name":"proposedNewAlgebraFee","type":"uint16","indexed":false,"internalType":"uint16"}],"anonymous":false},{"name":"AlgebraFeeReceiver","type":"event","inputs":[{"name":"newAlgebraFeeReceiver","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"AlgebraTokensWithdrawal","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CancelAlgebraFeeProposal","type":"event","inputs":[],"anonymous":false},{"name":"CommunityFeeReceiver","type":"event","inputs":[{"name":"newCommunityFeeReceiver","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"PendingAlgebraFeeManager","type":"event","inputs":[{"name":"pendingAlgebraFeeManager","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"TokensWithdrawal","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"COMMUNITY_FEE_VAULT_ADMINISTRATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"COMMUNITY_FEE_WITHDRAWER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"acceptAlgebraFeeChangeProposal","type":"function","inputs":[{"name":"newAlgebraFee","type":"uint16","internalType":"uint16"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"acceptAlgebraFeeManagerRole","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"algebraFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"algebraFeeManager","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"algebraFeeReceiver","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"cancelAlgebraFeeChangeProposal","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"changeAlgebraFeeReceiver","type":"function","inputs":[{"name":"newAlgebraFeeReceiver","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"changeCommunityFeeReceiver","type":"function","inputs":[{"name":"newCommunityFeeReceiver","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"communityFeeReceiver","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"hasNewAlgebraFeeProposal","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"proposeAlgebraFeeChange","type":"function","inputs":[{"name":"newAlgebraFee","type":"uint16","internalType":"uint16"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proposedNewAlgebraFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"transferAlgebraFeeManagerRole","type":"function","inputs":[{"name":"_newAlgebraFeeManager","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdraw","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdrawTokens","type":"function","inputs":[{"name":"params","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct IAlgebraCommunityVault.WithdrawTokensParams[]"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.20+commit.a1b79de6"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_algebraFeeManager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"transferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"newAlgebraFee","type":"uint16"}],"name":"AlgebraFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newAlgebraFeeManager","type":"address"}],"name":"AlgebraFeeManager","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"proposedNewAlgebraFee","type":"uint16"}],"name":"AlgebraFeeProposal","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newAlgebraFeeReceiver","type":"address"}],"name":"AlgebraFeeReceiver","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AlgebraTokensWithdrawal","type":"event"},{"anonymous":false,"inputs":[],"name":"CancelAlgebraFeeProposal","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newCommunityFeeReceiver","type":"address"}],"name":"CommunityFeeReceiver","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pendingAlgebraFeeManager","type":"address"}],"name":"PendingAlgebraFeeManager","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensWithdrawal","type":"event"},{"inputs":[],"name":"COMMUNITY_FEE_VAULT_ADMINISTRATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"COMMUNITY_FEE_WITHDRAWER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"newAlgebraFee","type":"uint16"}],"name":"acceptAlgebraFeeChangeProposal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"acceptAlgebraFeeManagerRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"algebraFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"algebraFeeManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"algebraFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelAlgebraFeeChangeProposal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAlgebraFeeReceiver","type":"address"}],"name":"changeAlgebraFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newCommunityFeeReceiver","type":"address"}],"name":"changeCommunityFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"communityFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasNewAlgebraFeeProposal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"newAlgebraFee","type":"uint16"}],"name":"proposeAlgebraFeeChange","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proposedNewAlgebraFee","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newAlgebraFeeManager","type":"address"}],"name":"transferAlgebraFeeManagerRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IAlgebraCommunityVault.WithdrawTokensParams[]","name":"params","type":"tuple[]"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"details":"Role system is used to withdraw tokensVersion: Algebra Integral 1.0","events":{"AlgebraFee(uint16)":{"params":{"newAlgebraFee":"The new Algebra fee value"}},"AlgebraFeeManager(address)":{"params":{"newAlgebraFeeManager":"New Algebra fee manager address"}},"AlgebraFeeProposal(uint16)":{"params":{"proposedNewAlgebraFee":"The new proposed Algebra fee value"}},"AlgebraFeeReceiver(address)":{"params":{"newAlgebraFeeReceiver":"New Algebra fee receiver address"}},"AlgebraTokensWithdrawal(address,address,uint256)":{"params":{"amount":"The amount of fees tokens claimed by Algebra","to":"The address where claimed rewards were sent to","token":"The address of token fee"}},"CommunityFeeReceiver(address)":{"params":{"newCommunityFeeReceiver":"New fee receiver address"}},"PendingAlgebraFeeManager(address)":{"params":{"pendingAlgebraFeeManager":"New pending Algebra fee manager address"}},"TokensWithdrawal(address,address,uint256)":{"params":{"amount":"The amount of fees tokens claimed by communityFeeReceiver","to":"The address where claimed rewards were sent to","token":"The address of token fee"}}},"kind":"dev","methods":{"acceptAlgebraFeeChangeProposal(uint16)":{"details":"Can only be called by the factory owner. The new value will also be used for previously accumulated tokens that have not yet been withdrawn","params":{"newAlgebraFee":"New Algebra fee value"}},"changeAlgebraFeeReceiver(address)":{"params":{"newAlgebraFeeReceiver":"The address of new Algebra fee receiver"}},"changeCommunityFeeReceiver(address)":{"details":"Can only be called by the factory owner","params":{"newCommunityFeeReceiver":"New community fee receiver address"}},"proposeAlgebraFeeChange(uint16)":{"details":"the new value will also be used for previously accumulated tokens that have not yet been withdrawn","params":{"newAlgebraFee":"new Algebra fee value"}},"transferAlgebraFeeManagerRole(address)":{"params":{"_newAlgebraFeeManager":"new Algebra fee manager address"}},"withdraw(address,uint256)":{"details":"Can only be called by algebraFeeManager or communityFeeReceiver","params":{"amount":"The amount of token","token":"The token address"}},"withdrawTokens((address,uint256)[])":{"details":"Can be called by algebraFeeManager or communityFeeReceiver","params":{"params":"Array of WithdrawTokensParams objects containing token addresses and amounts to withdraw"}}},"stateVariables":{"COMMUNITY_FEE_VAULT_ADMINISTRATOR":{"details":"The role can be granted in AlgebraFactory"},"COMMUNITY_FEE_WITHDRAWER_ROLE":{"details":"The role can be granted in AlgebraFactory"},"algebraFee":{"details":"Value in thousandths,i.e. 1e-3"}},"title":"Algebra community fee vault","version":1},"userdoc":{"errors":{"transferFailed()":[{"notice":"Emitted if token transfer failed internally"}]},"events":{"AlgebraFee(uint16)":{"notice":"Emitted when the Algebra fee is changed"},"AlgebraFeeManager(address)":{"notice":"Emitted when a AlgebraFeeManager address changed"},"AlgebraFeeProposal(uint16)":{"notice":"Emitted when a new Algebra fee value proposed"},"AlgebraFeeReceiver(address)":{"notice":"Emitted when a AlgebraFeeReceiver address changed"},"AlgebraTokensWithdrawal(address,address,uint256)":{"notice":"Event emitted when a fees has been claimed"},"CancelAlgebraFeeProposal()":{"notice":"Emitted when a Algebra fee proposal canceled"},"CommunityFeeReceiver(address)":{"notice":"Emitted when a CommunityFeeReceiver address changed"},"PendingAlgebraFeeManager(address)":{"notice":"Emitted when a AlgebraFeeManager address change proposed"},"TokensWithdrawal(address,address,uint256)":{"notice":"Event emitted when a fees has been claimed"}},"kind":"user","methods":{"acceptAlgebraFeeChangeProposal(uint16)":{"notice":"Accepts the proposed new Algebra fee"},"acceptAlgebraFeeManagerRole()":{"notice":"accept Algebra FeeManager role"},"algebraFee()":{"notice":"The percentage of the protocol fee that Algebra will receive"},"algebraFeeManager()":{"notice":"Address of Algebra fee manager"},"algebraFeeReceiver()":{"notice":"Address of recipient Algebra part of community fee"},"cancelAlgebraFeeChangeProposal()":{"notice":"Cancels Algebra fee change proposal"},"changeAlgebraFeeReceiver(address)":{"notice":"Change Algebra community fee part receiver"},"changeCommunityFeeReceiver(address)":{"notice":"Change community fee receiver address"},"communityFeeReceiver()":{"notice":"Address to which community fees are sent from vault"},"hasNewAlgebraFeeProposal()":{"notice":"Represents whether there is a new Algebra fee proposal or not"},"proposeAlgebraFeeChange(uint16)":{"notice":"Proposes new Algebra fee value for protocol"},"proposedNewAlgebraFee()":{"notice":"Suggested Algebra fee value"},"transferAlgebraFeeManagerRole(address)":{"notice":"Transfers Algebra fee manager role"},"withdraw(address,uint256)":{"notice":"Withdraw protocol fees from vault"},"withdrawTokens((address,uint256)[])":{"notice":"Withdraw protocol fees from vault. Used to claim fees for multiple tokens"}},"notice":"Community fee from pools is sent here, if it is enabled","version":1}},"settings":{"compilationTarget":{"contracts/AlgebraCommunityVault.sol":"AlgebraCommunityVault"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":800},"remappings":[]},"sources":{"contracts/AlgebraCommunityVault.sol":{"keccak256":"0x708da82829dd47bfd351dc082991f1f84649222208ee8da83489576e29d1bac7","license":"BUSL-1.1","urls":["bzz-raw://7a2850248ee1d819561f980652e90f73b458af90d56f42f6dc8e5783d54be745","dweb:/ipfs/QmXj4wurPvBfNmoGtw527pU2efYetTSi1dCWDocBqxpJzB"]},"contracts/interfaces/IAlgebraFactory.sol":{"keccak256":"0x78c785057878fdf8f969b54f522f23bf5426e0494fa63814ba3c230b48d50e34","license":"GPL-2.0-or-later","urls":["bzz-raw://62de47c96e3ccc211ef2c364633d6da40ea1478bfb7bd700c04d163793b8411a","dweb:/ipfs/QmVft8RtPLSwtp7eGtYjcUQ7Fnci75uTthnuUuBaRb3d2a"]},"contracts/interfaces/plugin/IAlgebraPluginFactory.sol":{"keccak256":"0xd8e75579936551ecdf0cb1c50726c4f56313bf27373612448c1f974dd3cde9b1","license":"GPL-2.0-or-later","urls":["bzz-raw://645de0a900f86606825c196cebd2b4a722efc3918731aa8e7a89d1c523885e75","dweb:/ipfs/Qma3MaayiN1L9vLncnK6hGJo9kbKCHT7Qs1m5iRvrUnTaw"]},"contracts/interfaces/pool/IAlgebraPoolErrors.sol":{"keccak256":"0xafcb8fd756f7f2df870fdceac95502c321dc1ec4b08f059a14802664822c4c35","license":"GPL-2.0-or-later","urls":["bzz-raw://6d5ca050ff8a743b858a276ff0690070b009aef7654cb79dbbbbaa7de894992b","dweb:/ipfs/QmRNfEvReRsGAuxm5uDaPXZGjWVA3c5Emy6GMB4GYDaZx2"]},"contracts/interfaces/vault/IAlgebraCommunityVault.sol":{"keccak256":"0x24fad3648346700d372d65ca449494553db47dcb03d2cd0acaf7677a5f7b1391","license":"GPL-2.0-or-later","urls":["bzz-raw://c15473dd606ee905423bf27fba68ce7d9964b43f728611db22468dd36581caf4","dweb:/ipfs/QmSa7ratHBjLQ3xrAoNXvM3pBhtLYBqRuMx8rnYy5S2se4"]},"contracts/interfaces/vault/IAlgebraVaultFactory.sol":{"keccak256":"0xf3ac234d4cf208d9efa204130d624823fc5b594a25a2568371b9520662ef931a","license":"GPL-2.0-or-later","urls":["bzz-raw://e355b868946cbea89029bce9db7eb6cd469828a869ccabfc39f2507a3e357d99","dweb:/ipfs/QmS67vkjpXQkhK3qZpg2pvnVS54kADxRPiYzC2foFWhhC7"]},"contracts/libraries/FullMath.sol":{"keccak256":"0x6e562130eac2d18d5527fc12115e83a3aa0955f6be89531b6d0d5977f0784cf7","license":"MIT","urls":["bzz-raw://e5226566361b64a277a523430449d398434aa9956ec53ab96120bdb5eed0d36c","dweb:/ipfs/QmdmE85FDGgaZBFb9WDamJQpvSx6BrpYUutudSzoRVmxMv"]},"contracts/libraries/SafeTransfer.sol":{"keccak256":"0x14e91c94e35c50efcd97e13609f686499c1dfa726ee0b3f6078fa4b99bde9a0a","license":"MIT","urls":["bzz-raw://1d9a7efa21d03180ded0e99d7ba05abd5c8ebedf2439a5a78091b679eadc4064","dweb:/ipfs/QmVUZPhYPTb2yY9381AL242tfVsb3iWxmE2XwqcN9HG6eW"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint16":{"label":"uint16","encoding":"inplace","numberOfBytes":"2"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":25,"label":"communityFeeReceiver","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"0","type":"t_uint16","astId":28,"label":"algebraFee","offset":20,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"0","type":"t_bool","astId":31,"label":"hasNewAlgebraFeeProposal","offset":22,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"0","type":"t_uint16","astId":34,"label":"proposedNewAlgebraFee","offset":23,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"1","type":"t_address","astId":37,"label":"algebraFeeReceiver","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"2","type":"t_address","astId":40,"label":"algebraFeeManager","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"3","type":"t_address","astId":42,"label":"_pendingAlgebraFeeManager","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"transferFailed()":[{"notice":"Emitted if token transfer failed internally"}]},"events":{"AlgebraFee(uint16)":{"notice":"Emitted when the Algebra fee is changed"},"AlgebraFeeManager(address)":{"notice":"Emitted when a AlgebraFeeManager address changed"},"AlgebraFeeProposal(uint16)":{"notice":"Emitted when a new Algebra fee value proposed"},"CancelAlgebraFeeProposal()":{"notice":"Emitted when a Algebra fee proposal canceled"},"AlgebraFeeReceiver(address)":{"notice":"Emitted when a AlgebraFeeReceiver address changed"},"CommunityFeeReceiver(address)":{"notice":"Emitted when a CommunityFeeReceiver address changed"},"PendingAlgebraFeeManager(address)":{"notice":"Emitted when a AlgebraFeeManager address change proposed"},"TokensWithdrawal(address,address,uint256)":{"notice":"Event emitted when a fees has been claimed"},"AlgebraTokensWithdrawal(address,address,uint256)":{"notice":"Event emitted when a fees has been claimed"}},"notice":"Community fee from pools is sent here, if it is enabled","methods":{"algebraFee()":{"notice":"The percentage of the protocol fee that Algebra will receive"},"algebraFeeManager()":{"notice":"Address of Algebra fee manager"},"algebraFeeReceiver()":{"notice":"Address of recipient Algebra part of community fee"},"communityFeeReceiver()":{"notice":"Address to which community fees are sent from vault"},"proposedNewAlgebraFee()":{"notice":"Suggested Algebra fee value"},"withdraw(address,uint256)":{"notice":"Withdraw protocol fees from vault"},"hasNewAlgebraFeeProposal()":{"notice":"Represents whether there is a new Algebra fee proposal or not"},"acceptAlgebraFeeManagerRole()":{"notice":"accept Algebra FeeManager role"},"proposeAlgebraFeeChange(uint16)":{"notice":"Proposes new Algebra fee value for protocol"},"cancelAlgebraFeeChangeProposal()":{"notice":"Cancels Algebra fee change proposal"},"changeAlgebraFeeReceiver(address)":{"notice":"Change Algebra community fee part receiver"},"changeCommunityFeeReceiver(address)":{"notice":"Change community fee receiver address"},"withdrawTokens((address,uint256)[])":{"notice":"Withdraw protocol fees from vault. Used to claim fees for multiple tokens"},"acceptAlgebraFeeChangeProposal(uint16)":{"notice":"Accepts the proposed new Algebra fee"},"transferAlgebraFeeManagerRole(address)":{"notice":"Transfers Algebra fee manager role"}},"version":1},"devdoc":{"kind":"dev","title":"Algebra community fee vault","events":{"AlgebraFee(uint16)":{"params":{"newAlgebraFee":"The new Algebra fee value"}},"AlgebraFeeManager(address)":{"params":{"newAlgebraFeeManager":"New Algebra fee manager address"}},"AlgebraFeeProposal(uint16)":{"params":{"proposedNewAlgebraFee":"The new proposed Algebra fee value"}},"AlgebraFeeReceiver(address)":{"params":{"newAlgebraFeeReceiver":"New Algebra fee receiver address"}},"CommunityFeeReceiver(address)":{"params":{"newCommunityFeeReceiver":"New fee receiver address"}},"PendingAlgebraFeeManager(address)":{"params":{"pendingAlgebraFeeManager":"New pending Algebra fee manager address"}},"TokensWithdrawal(address,address,uint256)":{"params":{"to":"The address where claimed rewards were sent to","token":"The address of token fee","amount":"The amount of fees tokens claimed by communityFeeReceiver"}},"AlgebraTokensWithdrawal(address,address,uint256)":{"params":{"to":"The address where claimed rewards were sent to","token":"The address of token fee","amount":"The amount of fees tokens claimed by Algebra"}}},"details":"Role system is used to withdraw tokensVersion: Algebra Integral 1.0","methods":{"withdraw(address,uint256)":{"params":{"token":"The token address","amount":"The amount of token"},"details":"Can only be called by algebraFeeManager or communityFeeReceiver"},"proposeAlgebraFeeChange(uint16)":{"params":{"newAlgebraFee":"new Algebra fee value"},"details":"the new value will also be used for previously accumulated tokens that have not yet been withdrawn"},"changeAlgebraFeeReceiver(address)":{"params":{"newAlgebraFeeReceiver":"The address of new Algebra fee receiver"}},"changeCommunityFeeReceiver(address)":{"params":{"newCommunityFeeReceiver":"New community fee receiver address"},"details":"Can only be called by the factory owner"},"withdrawTokens((address,uint256)[])":{"params":{"params":"Array of WithdrawTokensParams objects containing token addresses and amounts to withdraw"},"details":"Can be called by algebraFeeManager or communityFeeReceiver"},"acceptAlgebraFeeChangeProposal(uint16)":{"params":{"newAlgebraFee":"New Algebra fee value"},"details":"Can only be called by the factory owner. The new value will also be used for previously accumulated tokens that have not yet been withdrawn"},"transferAlgebraFeeManagerRole(address)":{"params":{"_newAlgebraFeeManager":"new Algebra fee manager address"}}},"version":1,"stateVariables":{"algebraFee":{"details":"Value in thousandths,i.e. 1e-3"},"COMMUNITY_FEE_WITHDRAWER_ROLE":{"details":"The role can be granted in AlgebraFactory"},"COMMUNITY_FEE_VAULT_ADMINISTRATOR":{"details":"The role can be granted in AlgebraFactory"}}},"sourceIds":{"contracts/libraries/FullMath.sol":{"id":6},"contracts/AlgebraCommunityVault.sol":{"id":0},"contracts/libraries/SafeTransfer.sol":{"id":7},"contracts/interfaces/IAlgebraFactory.sol":{"id":1},"contracts/interfaces/pool/IAlgebraPoolErrors.sol":{"id":3},"contracts/interfaces/vault/IAlgebraVaultFactory.sol":{"id":5},"contracts/interfaces/plugin/IAlgebraPluginFactory.sol":{"id":2},"contracts/interfaces/vault/IAlgebraCommunityVault.sol":{"id":4}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/libraries/FullMath.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Contains 512-bit math functions\n/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision\n/// @dev Handles \"phantom overflow\" i.e., allows multiplication and division where an intermediate value overflows 256 bits\nlibrary FullMath {\n  /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n  /// @param a The multiplicand\n  /// @param b The multiplier\n  /// @param denominator The divisor\n  /// @return result The 256-bit result\n  /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv\n  function mulDiv(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {\n    unchecked {\n      // 512-bit multiply [prod1 prod0] = a * b\n      // Compute the product mod 2**256 and mod 2**256 - 1\n      // then use the Chinese Remainder Theorem to reconstruct\n      // the 512 bit result. The result is stored in two 256\n      // variables such that product = prod1 * 2**256 + prod0\n      uint256 prod0 = a * b; // Least significant 256 bits of the product\n      uint256 prod1; // Most significant 256 bits of the product\n      assembly {\n        let mm := mulmod(a, b, not(0))\n        prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n      }\n\n      // Make sure the result is less than 2**256.\n      // Also prevents denominator == 0\n      require(denominator > prod1);\n\n      // Handle non-overflow cases, 256 by 256 division\n      if (prod1 == 0) {\n        assembly {\n          result := div(prod0, denominator)\n        }\n        return result;\n      }\n\n      ///////////////////////////////////////////////\n      // 512 by 256 division.\n      ///////////////////////////////////////////////\n\n      // Make division exact by subtracting the remainder from [prod1 prod0]\n      // Compute remainder using mulmod\n      // Subtract 256 bit remainder from 512 bit number\n      assembly {\n        let remainder := mulmod(a, b, denominator)\n        prod1 := sub(prod1, gt(remainder, prod0))\n        prod0 := sub(prod0, remainder)\n      }\n\n      // Factor powers of two out of denominator\n      // Compute largest power of two divisor of denominator.\n      // Always >= 1.\n      uint256 twos = (0 - denominator) & denominator;\n      // Divide denominator by power of two\n      assembly {\n        denominator := div(denominator, twos)\n      }\n\n      // Divide [prod1 prod0] by the factors of two\n      assembly {\n        prod0 := div(prod0, twos)\n      }\n      // Shift in bits from prod1 into prod0. For this we need\n      // to flip `twos` such that it is 2**256 / twos.\n      // If twos is zero, then it becomes one\n      assembly {\n        twos := add(div(sub(0, twos), twos), 1)\n      }\n      prod0 |= prod1 * twos;\n\n      // Invert denominator mod 2**256\n      // Now that denominator is an odd number, it has an inverse\n      // modulo 2**256 such that denominator * inv = 1 mod 2**256.\n      // Compute the inverse by starting with a seed that is correct\n      // correct for four bits. That is, denominator * inv = 1 mod 2**4\n      uint256 inv = (3 * denominator) ^ 2;\n      // Now use Newton-Raphson iteration to improve the precision.\n      // Thanks to Hensel's lifting lemma, this also works in modular\n      // arithmetic, doubling the correct bits in each step.\n      inv *= 2 - denominator * inv; // inverse mod 2**8\n      inv *= 2 - denominator * inv; // inverse mod 2**16\n      inv *= 2 - denominator * inv; // inverse mod 2**32\n      inv *= 2 - denominator * inv; // inverse mod 2**64\n      inv *= 2 - denominator * inv; // inverse mod 2**128\n      inv *= 2 - denominator * inv; // inverse mod 2**256\n\n      // Because the division is now exact we can divide by multiplying\n      // with the modular inverse of denominator. This will give us the\n      // correct result modulo 2**256. Since the preconditions guarantee\n      // that the outcome is less than 2**256, this is the final result.\n      // We don't need to compute the high bits of the result and prod1\n      // is no longer required.\n      result = prod0 * inv;\n      return result;\n    }\n  }\n\n  /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n  /// @param a The multiplicand\n  /// @param b The multiplier\n  /// @param denominator The divisor\n  /// @return result The 256-bit result\n  function mulDivRoundingUp(uint256 a, uint256 b, uint256 denominator) internal pure returns (uint256 result) {\n    unchecked {\n      if (a == 0 || ((result = a * b) / a == b)) {\n        require(denominator > 0);\n        assembly {\n          result := add(div(result, denominator), gt(mod(result, denominator), 0))\n        }\n      } else {\n        result = mulDiv(a, b, denominator);\n        if (mulmod(a, b, denominator) > 0) {\n          require(result < type(uint256).max);\n          result++;\n        }\n      }\n    }\n  }\n\n  /// @notice Returns ceil(x / y)\n  /// @dev division by 0 has unspecified behavior, and must be checked externally\n  /// @param x The dividend\n  /// @param y The divisor\n  /// @return z The quotient, ceil(x / y)\n  function unsafeDivRoundingUp(uint256 x, uint256 y) internal pure returns (uint256 z) {\n    assembly {\n      z := add(div(x, y), gt(mod(x, y), 0))\n    }\n  }\n}\n"},"contracts/AlgebraCommunityVault.sol":{"content":"// SPDX-License-Identifier: BUSL-1.1\npragma solidity =0.8.20;\n\nimport './libraries/SafeTransfer.sol';\nimport './libraries/FullMath.sol';\n\nimport './interfaces/IAlgebraFactory.sol';\nimport './interfaces/vault/IAlgebraCommunityVault.sol';\n\n/// @title Algebra community fee vault\n/// @notice Community fee from pools is sent here, if it is enabled\n/// @dev Role system is used to withdraw tokens\n/// @dev Version: Algebra Integral 1.0\ncontract AlgebraCommunityVault is IAlgebraCommunityVault {\n  /// @dev The role can be granted in AlgebraFactory\n  bytes32 public constant COMMUNITY_FEE_WITHDRAWER_ROLE = keccak256('COMMUNITY_FEE_WITHDRAWER');\n  /// @dev The role can be granted in AlgebraFactory\n  bytes32 public constant COMMUNITY_FEE_VAULT_ADMINISTRATOR = keccak256('COMMUNITY_FEE_VAULT_ADMINISTRATOR');\n  address private immutable factory;\n\n  /// @notice Address to which community fees are sent from vault\n  address public communityFeeReceiver;\n  /// @notice The percentage of the protocol fee that Algebra will receive\n  /// @dev Value in thousandths,i.e. 1e-3\n  uint16 public algebraFee;\n  /// @notice Represents whether there is a new Algebra fee proposal or not\n  bool public hasNewAlgebraFeeProposal;\n  /// @notice Suggested Algebra fee value\n  uint16 public proposedNewAlgebraFee;\n  /// @notice Address of recipient Algebra part of community fee\n  address public algebraFeeReceiver;\n  /// @notice Address of Algebra fee manager\n  address public algebraFeeManager;\n  address private _pendingAlgebraFeeManager;\n\n  uint16 private constant ALGEBRA_FEE_DENOMINATOR = 1000;\n\n  modifier onlyAdministrator() {\n    require(IAlgebraFactory(factory).hasRoleOrOwner(COMMUNITY_FEE_VAULT_ADMINISTRATOR, msg.sender), 'only administrator');\n    _;\n  }\n\n  modifier onlyWithdrawer() {\n    require(msg.sender == algebraFeeManager || IAlgebraFactory(factory).hasRoleOrOwner(COMMUNITY_FEE_WITHDRAWER_ROLE, msg.sender), 'only withdrawer');\n    _;\n  }\n\n  modifier onlyAlgebraFeeManager() {\n    require(msg.sender == algebraFeeManager, 'only algebra fee manager');\n    _;\n  }\n\n  constructor(address _factory, address _algebraFeeManager) {\n    (factory, algebraFeeManager) = (_factory, _algebraFeeManager);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function withdraw(address token, uint256 amount) external override onlyWithdrawer {\n    (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) = _readAndVerifyWithdrawSettings();\n    _withdraw(token, _communityFeeReceiver, amount, _algebraFee, _algebraFeeReceiver);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function withdrawTokens(WithdrawTokensParams[] calldata params) external override onlyWithdrawer {\n    uint256 paramsLength = params.length;\n    (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) = _readAndVerifyWithdrawSettings();\n\n    unchecked {\n      for (uint256 i; i < paramsLength; ++i) _withdraw(params[i].token, _communityFeeReceiver, params[i].amount, _algebraFee, _algebraFeeReceiver);\n    }\n  }\n\n  function _readAndVerifyWithdrawSettings() private view returns (uint16 _algebraFee, address _algebraFeeReceiver, address _communityFeeReceiver) {\n    (_algebraFee, _algebraFeeReceiver, _communityFeeReceiver) = (algebraFee, algebraFeeReceiver, communityFeeReceiver);\n    if (_algebraFee != 0) require(_algebraFeeReceiver != address(0), 'invalid algebra fee receiver');\n    require(_communityFeeReceiver != address(0), 'invalid receiver');\n  }\n\n  function _withdraw(address token, address to, uint256 amount, uint16 _algebraFee, address _algebraFeeReceiver) private {\n    uint256 withdrawAmount = amount;\n    if (_algebraFee != 0) {\n      uint256 algebraFeeAmount = FullMath.mulDivRoundingUp(withdrawAmount, _algebraFee, ALGEBRA_FEE_DENOMINATOR);\n      withdrawAmount -= algebraFeeAmount;\n      SafeTransfer.safeTransfer(token, _algebraFeeReceiver, algebraFeeAmount);\n      emit AlgebraTokensWithdrawal(token, _algebraFeeReceiver, algebraFeeAmount);\n    }\n\n    SafeTransfer.safeTransfer(token, to, withdrawAmount);\n    emit TokensWithdrawal(token, to, withdrawAmount);\n  }\n\n  // ### algebra factory owner permissioned actions ###\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function acceptAlgebraFeeChangeProposal(uint16 newAlgebraFee) external override onlyAdministrator {\n    require(hasNewAlgebraFeeProposal, 'not proposed');\n    require(newAlgebraFee == proposedNewAlgebraFee, 'invalid new fee');\n\n    // note that the new value will be used for previously accumulated tokens that have not yet been withdrawn\n    algebraFee = newAlgebraFee;\n    (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (0, false);\n    emit AlgebraFee(newAlgebraFee);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function changeCommunityFeeReceiver(address newCommunityFeeReceiver) external override onlyAdministrator {\n    require(newCommunityFeeReceiver != address(0));\n    require(newCommunityFeeReceiver != communityFeeReceiver);\n    communityFeeReceiver = newCommunityFeeReceiver;\n    emit CommunityFeeReceiver(newCommunityFeeReceiver);\n  }\n\n  // ### algebra fee manager permissioned actions ###\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function transferAlgebraFeeManagerRole(address _newAlgebraFeeManager) external override onlyAlgebraFeeManager {\n    _pendingAlgebraFeeManager = _newAlgebraFeeManager;\n    emit PendingAlgebraFeeManager(_newAlgebraFeeManager);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function acceptAlgebraFeeManagerRole() external override {\n    require(msg.sender == _pendingAlgebraFeeManager);\n    (_pendingAlgebraFeeManager, algebraFeeManager) = (address(0), msg.sender);\n    emit AlgebraFeeManager(msg.sender);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function proposeAlgebraFeeChange(uint16 newAlgebraFee) external override onlyAlgebraFeeManager {\n    require(newAlgebraFee <= ALGEBRA_FEE_DENOMINATOR);\n    require(newAlgebraFee != proposedNewAlgebraFee && newAlgebraFee != algebraFee);\n    (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (newAlgebraFee, true);\n    emit AlgebraFeeProposal(newAlgebraFee);\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function cancelAlgebraFeeChangeProposal() external override onlyAlgebraFeeManager {\n    (proposedNewAlgebraFee, hasNewAlgebraFeeProposal) = (0, false);\n    emit CancelAlgebraFeeProposal();\n  }\n\n  /// @inheritdoc IAlgebraCommunityVault\n  function changeAlgebraFeeReceiver(address newAlgebraFeeReceiver) external override onlyAlgebraFeeManager {\n    require(newAlgebraFeeReceiver != address(0));\n    require(newAlgebraFeeReceiver != algebraFeeReceiver);\n    algebraFeeReceiver = newAlgebraFeeReceiver;\n    emit AlgebraFeeReceiver(newAlgebraFeeReceiver);\n  }\n}\n"},"contracts/libraries/SafeTransfer.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.4 <0.9.0;\n\nimport '../interfaces/pool/IAlgebraPoolErrors.sol';\n\n/// @title SafeTransfer\n/// @notice Safe ERC20 transfer library that gracefully handles missing return values.\n/// @dev Credit to Solmate under MIT license: https://github.com/transmissions11/solmate/blob/ed67feda67b24fdeff8ad1032360f0ee6047ba0a/src/utils/SafeTransferLib.sol\n/// @dev Please note that this library does not check if the token has a code! That responsibility is delegated to the caller.\nlibrary SafeTransfer {\n  /// @notice Transfers tokens to a recipient\n  /// @dev Calls transfer on token contract, errors with transferFailed() if transfer fails\n  /// @param token The contract address of the token which will be transferred\n  /// @param to The recipient of the transfer\n  /// @param amount The amount of the token to transfer\n  function safeTransfer(address token, address to, uint256 amount) internal {\n    bool success;\n    assembly {\n      let freeMemoryPointer := mload(0x40) // we will need to restore 0x40 slot\n      mstore(0x00, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) // \"transfer(address,uint256)\" selector\n      mstore(0x04, and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // append cleaned \"to\" address\n      mstore(0x24, amount)\n      // now we use 0x00 - 0x44 bytes (68), freeMemoryPointer is dirty\n      success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n      success := and(\n        // set success to true if call isn't reverted and returned exactly 1 (can't just be non-zero data) or nothing\n        or(and(eq(mload(0), 1), eq(returndatasize(), 32)), iszero(returndatasize())),\n        success\n      )\n      mstore(0x40, freeMemoryPointer) // restore the freeMemoryPointer\n    }\n\n    if (!success) revert IAlgebraPoolErrors.transferFailed();\n  }\n}\n"},"contracts/interfaces/IAlgebraFactory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\npragma abicoder v2;\n\nimport './plugin/IAlgebraPluginFactory.sol';\nimport './vault/IAlgebraVaultFactory.sol';\n\n/// @title The interface for the Algebra Factory\n/// @dev Credit to Uniswap Labs under GPL-2.0-or-later license:\n/// https://github.com/Uniswap/v3-core/tree/main/contracts/interfaces\ninterface IAlgebraFactory {\n  /// @notice Emitted when a process of ownership renounce is started\n  /// @param timestamp The timestamp of event\n  /// @param finishTimestamp The timestamp when ownership renounce will be possible to finish\n  event RenounceOwnershipStart(uint256 timestamp, uint256 finishTimestamp);\n\n  /// @notice Emitted when a process of ownership renounce cancelled\n  /// @param timestamp The timestamp of event\n  event RenounceOwnershipStop(uint256 timestamp);\n\n  /// @notice Emitted when a process of ownership renounce finished\n  /// @param timestamp The timestamp of ownership renouncement\n  event RenounceOwnershipFinish(uint256 timestamp);\n\n  /// @notice Emitted when a pool is created\n  /// @param token0 The first token of the pool by address sort order\n  /// @param token1 The second token of the pool by address sort order\n  /// @param pool The address of the created pool\n  event Pool(address indexed token0, address indexed token1, address pool);\n\n  /// @notice Emitted when the default community fee is changed\n  /// @param newDefaultCommunityFee The new default community fee value\n  event DefaultCommunityFee(uint16 newDefaultCommunityFee);\n\n  /// @notice Emitted when the default tickspacing is changed\n  /// @param newDefaultTickspacing The new default tickspacing value\n  event DefaultTickspacing(int24 newDefaultTickspacing);\n\n  /// @notice Emitted when the default fee is changed\n  /// @param newDefaultFee The new default fee value\n  event DefaultFee(uint16 newDefaultFee);\n\n  /// @notice Emitted when the defaultPluginFactory address is changed\n  /// @param defaultPluginFactoryAddress The new defaultPluginFactory address\n  event DefaultPluginFactory(address defaultPluginFactoryAddress);\n\n  /// @notice Emitted when the vaultFactory address is changed\n  /// @param newVaultFactory The new vaultFactory address\n  event VaultFactory(address newVaultFactory);\n\n  /// @notice role that can change communityFee and tickspacing in pools\n  /// @return The hash corresponding to this role\n  function POOLS_ADMINISTRATOR_ROLE() external view returns (bytes32);\n\n  /// @notice Returns `true` if `account` has been granted `role` or `account` is owner.\n  /// @param role The hash corresponding to the role\n  /// @param account The address for which the role is checked\n  /// @return bool Whether the address has this role or the owner role or not\n  function hasRoleOrOwner(bytes32 role, address account) external view returns (bool);\n\n  /// @notice Returns the current owner of the factory\n  /// @dev Can be changed by the current owner via transferOwnership(address newOwner)\n  /// @return The address of the factory owner\n  function owner() external view returns (address);\n\n  /// @notice Returns the current poolDeployerAddress\n  /// @return The address of the poolDeployer\n  function poolDeployer() external view returns (address);\n\n  /// @notice Returns the default community fee\n  /// @return Fee which will be set at the creation of the pool\n  function defaultCommunityFee() external view returns (uint16);\n\n  /// @notice Returns the default fee\n  /// @return Fee which will be set at the creation of the pool\n  function defaultFee() external view returns (uint16);\n\n  /// @notice Returns the default tickspacing\n  /// @return Tickspacing which will be set at the creation of the pool\n  function defaultTickspacing() external view returns (int24);\n\n  /// @notice Return the current pluginFactory address\n  /// @dev This contract is used to automatically set a plugin address in new liquidity pools\n  /// @return Algebra plugin factory\n  function defaultPluginFactory() external view returns (IAlgebraPluginFactory);\n\n  /// @notice Return the current vaultFactory address\n  /// @dev This contract is used to automatically set a vault address in new liquidity pools\n  /// @return Algebra vault factory\n  function vaultFactory() external view returns (IAlgebraVaultFactory);\n\n  /// @notice Returns the default communityFee, tickspacing, fee and communityFeeVault for pool\n  /// @param pool the address of liquidity pool\n  /// @return communityFee which will be set at the creation of the pool\n  /// @return tickSpacing which will be set at the creation of the pool\n  /// @return fee which will be set at the creation of the pool\n  /// @return communityFeeVault the address of communityFeeVault\n  function defaultConfigurationForPool(\n    address pool\n  ) external view returns (uint16 communityFee, int24 tickSpacing, uint16 fee, address communityFeeVault);\n\n  /// @notice Deterministically computes the pool address given the token0 and token1\n  /// @dev The method does not check if such a pool has been created\n  /// @param token0 first token\n  /// @param token1 second token\n  /// @return pool The contract address of the Algebra pool\n  function computePoolAddress(address token0, address token1) external view returns (address pool);\n\n  /// @notice Returns the pool address for a given pair of tokens, or address 0 if it does not exist\n  /// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order\n  /// @param tokenA The contract address of either token0 or token1\n  /// @param tokenB The contract address of the other token\n  /// @return pool The pool address\n  function poolByPair(address tokenA, address tokenB) external view returns (address pool);\n\n  /// @notice returns keccak256 of AlgebraPool init bytecode.\n  /// @dev the hash value changes with any change in the pool bytecode\n  /// @return Keccak256 hash of AlgebraPool contract init bytecode\n  function POOL_INIT_CODE_HASH() external view returns (bytes32);\n\n  /// @return timestamp The timestamp of the beginning of the renounceOwnership process\n  function renounceOwnershipStartTimestamp() external view returns (uint256 timestamp);\n\n  /// @notice Creates a pool for the given two tokens\n  /// @param tokenA One of the two tokens in the desired pool\n  /// @param tokenB The other of the two tokens in the desired pool\n  /// @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0.\n  /// The call will revert if the pool already exists or the token arguments are invalid.\n  /// @return pool The address of the newly created pool\n  function createPool(address tokenA, address tokenB) external returns (address pool);\n\n  /// @dev updates default community fee for new pools\n  /// @param newDefaultCommunityFee The new community fee, _must_ be <= MAX_COMMUNITY_FEE\n  function setDefaultCommunityFee(uint16 newDefaultCommunityFee) external;\n\n  /// @dev updates default fee for new pools\n  /// @param newDefaultFee The new  fee, _must_ be <= MAX_DEFAULT_FEE\n  function setDefaultFee(uint16 newDefaultFee) external;\n\n  /// @dev updates default tickspacing for new pools\n  /// @param newDefaultTickspacing The new tickspacing, _must_ be <= MAX_TICK_SPACING and >= MIN_TICK_SPACING\n  function setDefaultTickspacing(int24 newDefaultTickspacing) external;\n\n  /// @dev updates pluginFactory address\n  /// @param newDefaultPluginFactory address of new plugin factory\n  function setDefaultPluginFactory(address newDefaultPluginFactory) external;\n\n  /// @dev updates vaultFactory address\n  /// @param newVaultFactory address of new vault factory\n  function setVaultFactory(address newVaultFactory) external;\n\n  /// @notice Starts process of renounceOwnership. After that, a certain period\n  /// of time must pass before the ownership renounce can be completed.\n  function startRenounceOwnership() external;\n\n  /// @notice Stops process of renounceOwnership and removes timer.\n  function stopRenounceOwnership() external;\n}\n"},"contracts/interfaces/pool/IAlgebraPoolErrors.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.8.4;\n\n/// @title Errors emitted by a pool\n/// @notice Contains custom errors emitted by the pool\n/// @dev Custom errors are separated from the common pool interface for compatibility with older versions of Solidity\ninterface IAlgebraPoolErrors {\n  // ####  pool errors  ####\n\n  /// @notice Emitted by the reentrancy guard\n  error locked();\n\n  /// @notice Emitted if arithmetic error occurred\n  error arithmeticError();\n\n  /// @notice Emitted if an attempt is made to initialize the pool twice\n  error alreadyInitialized();\n\n  /// @notice Emitted if an attempt is made to mint or swap in uninitialized pool\n  error notInitialized();\n\n  /// @notice Emitted if 0 is passed as amountRequired to swap function\n  error zeroAmountRequired();\n\n  /// @notice Emitted if invalid amount is passed as amountRequired to swap function\n  error invalidAmountRequired();\n\n  /// @notice Emitted if the pool received fewer tokens than it should have\n  error insufficientInputAmount();\n\n  /// @notice Emitted if there was an attempt to mint zero liquidity\n  error zeroLiquidityDesired();\n  /// @notice Emitted if actual amount of liquidity is zero (due to insufficient amount of tokens received)\n  error zeroLiquidityActual();\n\n  /// @notice Emitted if the pool received fewer tokens0 after flash than it should have\n  error flashInsufficientPaid0();\n  /// @notice Emitted if the pool received fewer tokens1 after flash than it should have\n  error flashInsufficientPaid1();\n\n  /// @notice Emitted if limitSqrtPrice param is incorrect\n  error invalidLimitSqrtPrice();\n\n  /// @notice Tick must be divisible by tickspacing\n  error tickIsNotSpaced();\n\n  /// @notice Emitted if a method is called that is accessible only to the factory owner or dedicated role\n  error notAllowed();\n\n  /// @notice Emitted if new tick spacing exceeds max allowed value\n  error invalidNewTickSpacing();\n  /// @notice Emitted if new community fee exceeds max allowed value\n  error invalidNewCommunityFee();\n\n  /// @notice Emitted if an attempt is made to manually change the fee value, but dynamic fee is enabled\n  error dynamicFeeActive();\n  /// @notice Emitted if an attempt is made by plugin to change the fee value, but dynamic fee is disabled\n  error dynamicFeeDisabled();\n  /// @notice Emitted if an attempt is made to change the plugin configuration, but the plugin is not connected\n  error pluginIsNotConnected();\n  /// @notice Emitted if a plugin returns invalid selector after hook call\n  /// @param expectedSelector The expected selector\n  error invalidHookResponse(bytes4 expectedSelector);\n\n  // ####  LiquidityMath errors  ####\n\n  /// @notice Emitted if liquidity underflows\n  error liquiditySub();\n  /// @notice Emitted if liquidity overflows\n  error liquidityAdd();\n\n  // ####  TickManagement errors  ####\n\n  /// @notice Emitted if the topTick param not greater then the bottomTick param\n  error topTickLowerOrEqBottomTick();\n  /// @notice Emitted if the bottomTick param is lower than min allowed value\n  error bottomTickLowerThanMIN();\n  /// @notice Emitted if the topTick param is greater than max allowed value\n  error topTickAboveMAX();\n  /// @notice Emitted if the liquidity value associated with the tick exceeds MAX_LIQUIDITY_PER_TICK\n  error liquidityOverflow();\n  /// @notice Emitted if an attempt is made to interact with an uninitialized tick\n  error tickIsNotInitialized();\n  /// @notice Emitted if there is an attempt to insert a new tick into the list of ticks with incorrect indexes of the previous and next ticks\n  error tickInvalidLinks();\n\n  // ####  SafeTransfer errors  ####\n\n  /// @notice Emitted if token transfer failed internally\n  error transferFailed();\n\n  // ####  TickMath errors  ####\n\n  /// @notice Emitted if tick is greater than the maximum or less than the minimum allowed value\n  error tickOutOfRange();\n  /// @notice Emitted if price is greater than the maximum or less than the minimum allowed value\n  error priceOutOfRange();\n}\n"},"contracts/interfaces/vault/IAlgebraVaultFactory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\n/// @title The interface for the Algebra Vault Factory\n/// @notice This contract can be used for automatic vaults creation\n/// @dev Version: Algebra Integral\ninterface IAlgebraVaultFactory {\n  /// @notice returns address of the community fee vault for the pool\n  /// @param pool the address of Algebra Integral pool\n  /// @return communityFeeVault the address of community fee vault\n  function getVaultForPool(address pool) external view returns (address communityFeeVault);\n\n  /// @notice creates the community fee vault for the pool if needed\n  /// @param pool the address of Algebra Integral pool\n  /// @return communityFeeVault the address of community fee vault\n  function createVaultForPool(address pool) external returns (address communityFeeVault);\n}\n"},"contracts/interfaces/plugin/IAlgebraPluginFactory.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\n/// @title An interface for a contract that is capable of deploying Algebra plugins\n/// @dev Such a factory is needed if the plugin should be automatically created and connected to each new pool\ninterface IAlgebraPluginFactory {\n  /// @notice Deploys new plugin contract for pool\n  /// @param pool The address of the pool for which the new plugin will be created\n  /// @param token0 First token of the pool\n  /// @param token1 Second token of the pool\n  /// @return New plugin address\n  function createPlugin(address pool, address token0, address token1) external returns (address);\n}\n"},"contracts/interfaces/vault/IAlgebraCommunityVault.sol":{"content":"// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity >=0.5.0;\n\n/// @title The interface for the Algebra community fee vault\n/// @notice Community fee from pools is sent here, if it is enabled\n/// @dev Version: Algebra Integral\ninterface IAlgebraCommunityVault {\n  /// @notice Event emitted when a fees has been claimed\n  /// @param token The address of token fee\n  /// @param to The address where claimed rewards were sent to\n  /// @param amount The amount of fees tokens claimed by communityFeeReceiver\n  event TokensWithdrawal(address indexed token, address indexed to, uint256 amount);\n\n  /// @notice Event emitted when a fees has been claimed\n  /// @param token The address of token fee\n  /// @param to The address where claimed rewards were sent to\n  /// @param amount The amount of fees tokens claimed by Algebra\n  event AlgebraTokensWithdrawal(address indexed token, address indexed to, uint256 amount);\n\n  /// @notice Emitted when a AlgebraFeeReceiver address changed\n  /// @param newAlgebraFeeReceiver New Algebra fee receiver address\n  event AlgebraFeeReceiver(address newAlgebraFeeReceiver);\n\n  /// @notice Emitted when a AlgebraFeeManager address change proposed\n  /// @param pendingAlgebraFeeManager New pending Algebra fee manager address\n  event PendingAlgebraFeeManager(address pendingAlgebraFeeManager);\n\n  /// @notice Emitted when a new Algebra fee value proposed\n  /// @param proposedNewAlgebraFee The new proposed Algebra fee value\n  event AlgebraFeeProposal(uint16 proposedNewAlgebraFee);\n\n  /// @notice Emitted when a Algebra fee proposal canceled\n  event CancelAlgebraFeeProposal();\n\n  /// @notice Emitted when a AlgebraFeeManager address changed\n  /// @param newAlgebraFeeManager New Algebra fee manager address\n  event AlgebraFeeManager(address newAlgebraFeeManager);\n\n  /// @notice Emitted when the Algebra fee is changed\n  /// @param newAlgebraFee The new Algebra fee value\n  event AlgebraFee(uint16 newAlgebraFee);\n\n  /// @notice Emitted when a CommunityFeeReceiver address changed\n  /// @param newCommunityFeeReceiver New fee receiver address\n  event CommunityFeeReceiver(address newCommunityFeeReceiver);\n\n  /// @notice Withdraw protocol fees from vault\n  /// @dev Can only be called by algebraFeeManager or communityFeeReceiver\n  /// @param token The token address\n  /// @param amount The amount of token\n  function withdraw(address token, uint256 amount) external;\n\n  struct WithdrawTokensParams {\n    address token;\n    uint256 amount;\n  }\n\n  /// @notice Withdraw protocol fees from vault. Used to claim fees for multiple tokens\n  /// @dev Can be called by algebraFeeManager or communityFeeReceiver\n  /// @param params Array of WithdrawTokensParams objects containing token addresses and amounts to withdraw\n  function withdrawTokens(WithdrawTokensParams[] calldata params) external;\n\n  // ### algebra factory owner permissioned actions ###\n\n  /// @notice Accepts the proposed new Algebra fee\n  /// @dev Can only be called by the factory owner.\n  /// The new value will also be used for previously accumulated tokens that have not yet been withdrawn\n  /// @param newAlgebraFee New Algebra fee value\n  function acceptAlgebraFeeChangeProposal(uint16 newAlgebraFee) external;\n\n  /// @notice Change community fee receiver address\n  /// @dev Can only be called by the factory owner\n  /// @param newCommunityFeeReceiver New community fee receiver address\n  function changeCommunityFeeReceiver(address newCommunityFeeReceiver) external;\n\n  // ### algebra fee manager permissioned actions ###\n\n  /// @notice Transfers Algebra fee manager role\n  /// @param _newAlgebraFeeManager new Algebra fee manager address\n  function transferAlgebraFeeManagerRole(address _newAlgebraFeeManager) external;\n\n  /// @notice accept Algebra FeeManager role\n  function acceptAlgebraFeeManagerRole() external;\n\n  /// @notice Proposes new Algebra fee value for protocol\n  /// @dev the new value will also be used for previously accumulated tokens that have not yet been withdrawn\n  /// @param newAlgebraFee new Algebra fee value\n  function proposeAlgebraFeeChange(uint16 newAlgebraFee) external;\n\n  /// @notice Cancels Algebra fee change proposal\n  function cancelAlgebraFeeChangeProposal() external;\n\n  /// @notice Change Algebra community fee part receiver\n  /// @param newAlgebraFeeReceiver The address of new Algebra fee receiver\n  function changeAlgebraFeeReceiver(address newAlgebraFeeReceiver) external;\n}\n"},"@flarenetwork/flare-periphery-contracts/flare/RewardsV2Interface.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.7.6 <0.9;\n\n/**\n * Rewards V2 long term support interface.\n */\ninterface RewardsV2Interface {\n\n    /// Claim type enum.\n    enum ClaimType { DIRECT, FEE, WNAT, MIRROR, CCHAIN }\n\n   /// Struct used for claiming rewards with Merkle proof.\n    struct RewardClaimWithProof {\n        bytes32[] merkleProof;\n        RewardClaim body;\n    }\n\n    /// Struct used in Merkle tree for storing reward claims.\n    struct RewardClaim {\n        uint24 rewardEpochId;\n        bytes20 beneficiary; // c-chain address or node id (bytes20) in case of type MIRROR\n        uint120 amount; // in wei\n        ClaimType claimType;\n    }\n\n    /// Struct used for returning state of rewards.\n    struct RewardState {\n        uint24 rewardEpochId;\n        bytes20 beneficiary; // c-chain address or node id (bytes20) in case of type MIRROR\n        uint120 amount; // in wei\n        ClaimType claimType;\n        bool initialised;\n    }\n\n    /**\n     * Claim rewards for `_rewardOwner` and transfer them to `_recipient`.\n     * It can be called by reward owner or its authorized executor.\n     * @param _rewardOwner Address of the reward owner.\n     * @param _recipient Address of the reward recipient.\n     * @param _rewardEpochId Id of the reward epoch up to which the rewards are claimed.\n     * @param _wrap Indicates if the reward should be wrapped (deposited) to the WNAT contract.\n     * @param _proofs Array of reward claims with merkle proofs.\n     * @return _rewardAmountWei Amount of rewarded native tokens (wei).\n     */\n    function claim(\n        address _rewardOwner,\n        address payable _recipient,\n        uint24 _rewardEpochId,\n        bool _wrap,\n        RewardClaimWithProof[] calldata _proofs\n    )\n        external\n        returns (uint256 _rewardAmountWei);\n\n    /**\n     * Indicates if the contract is active - claims are enabled.\n     */\n    function active() external view returns (bool);\n\n    /**\n     * Returns the start and the end of the reward epoch range for which the reward is claimable.\n     * @return _startEpochId The oldest epoch id that allows reward claiming.\n     * @return _endEpochId The newest epoch id that allows reward claiming.\n     */\n    function getRewardEpochIdsWithClaimableRewards()\n        external view\n        returns (\n            uint24 _startEpochId,\n            uint24 _endEpochId\n        );\n\n    /**\n     * Returns the next claimable reward epoch for a reward owner.\n     * @param _rewardOwner Address of the reward owner to query.\n     */\n    function getNextClaimableRewardEpochId(address _rewardOwner) external view returns (uint256);\n\n    /**\n     * Returns the state of rewards for a given address for all unclaimed reward epochs with claimable rewards.\n     * @param _rewardOwner Address of the reward owner.\n     * @return _rewardStates Array of reward states.\n     */\n    function getStateOfRewards(\n        address _rewardOwner\n    )\n        external view\n        returns (\n            RewardState[][] memory _rewardStates\n        );\n\n}"}},"language":"Solidity","settings":{"metadata":{"bytecodeHash":"none"},"libraries":{},"optimizer":{"runs":800,"enabled":true},"evmVersion":"paris","remappings":[]}},"stdJsonOutput":{"sources":{"contracts/libraries/FullMath.sol":{"id":6},"contracts/AlgebraCommunityVault.sol":{"id":0},"contracts/libraries/SafeTransfer.sol":{"id":7},"contracts/interfaces/IAlgebraFactory.sol":{"id":1},"contracts/interfaces/pool/IAlgebraPoolErrors.sol":{"id":3},"contracts/interfaces/vault/IAlgebraVaultFactory.sol":{"id":5},"contracts/interfaces/plugin/IAlgebraPluginFactory.sol":{"id":2},"contracts/interfaces/vault/IAlgebraCommunityVault.sol":{"id":4}},"contracts":{"contracts/AlgebraCommunityVault.sol":{"AlgebraCommunityVault":{"abi":[{"type":"constructor","inputs":[{"name":"_factory","type":"address","internalType":"address"},{"name":"_algebraFeeManager","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"transferFailed","type":"error","inputs":[]},{"name":"AlgebraFee","type":"event","inputs":[{"name":"newAlgebraFee","type":"uint16","indexed":false,"internalType":"uint16"}],"anonymous":false},{"name":"AlgebraFeeManager","type":"event","inputs":[{"name":"newAlgebraFeeManager","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"AlgebraFeeProposal","type":"event","inputs":[{"name":"proposedNewAlgebraFee","type":"uint16","indexed":false,"internalType":"uint16"}],"anonymous":false},{"name":"AlgebraFeeReceiver","type":"event","inputs":[{"name":"newAlgebraFeeReceiver","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"AlgebraTokensWithdrawal","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CancelAlgebraFeeProposal","type":"event","inputs":[],"anonymous":false},{"name":"CommunityFeeReceiver","type":"event","inputs":[{"name":"newCommunityFeeReceiver","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"PendingAlgebraFeeManager","type":"event","inputs":[{"name":"pendingAlgebraFeeManager","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"TokensWithdrawal","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"COMMUNITY_FEE_VAULT_ADMINISTRATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"COMMUNITY_FEE_WITHDRAWER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"acceptAlgebraFeeChangeProposal","type":"function","inputs":[{"name":"newAlgebraFee","type":"uint16","internalType":"uint16"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"acceptAlgebraFeeManagerRole","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"algebraFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"algebraFeeManager","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"algebraFeeReceiver","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"cancelAlgebraFeeChangeProposal","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"changeAlgebraFeeReceiver","type":"function","inputs":[{"name":"newAlgebraFeeReceiver","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"changeCommunityFeeReceiver","type":"function","inputs":[{"name":"newCommunityFeeReceiver","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"communityFeeReceiver","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"hasNewAlgebraFeeProposal","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"proposeAlgebraFeeChange","type":"function","inputs":[{"name":"newAlgebraFee","type":"uint16","internalType":"uint16"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proposedNewAlgebraFee","type":"function","inputs":[],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"transferAlgebraFeeManagerRole","type":"function","inputs":[{"name":"_newAlgebraFeeManager","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdraw","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"withdrawTokens","type":"function","inputs":[{"name":"params","type":"tuple[]","components":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct IAlgebraCommunityVault.WithdrawTokensParams[]"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_algebraFeeManager\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"transferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"newAlgebraFee\",\"type\":\"uint16\"}],\"name\":\"AlgebraFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAlgebraFeeManager\",\"type\":\"address\"}],\"name\":\"AlgebraFeeManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"proposedNewAlgebraFee\",\"type\":\"uint16\"}],\"name\":\"AlgebraFeeProposal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAlgebraFeeReceiver\",\"type\":\"address\"}],\"name\":\"AlgebraFeeReceiver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"AlgebraTokensWithdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"CancelAlgebraFeeProposal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newCommunityFeeReceiver\",\"type\":\"address\"}],\"name\":\"CommunityFeeReceiver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"pendingAlgebraFeeManager\",\"type\":\"address\"}],\"name\":\"PendingAlgebraFeeManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"TokensWithdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"COMMUNITY_FEE_VAULT_ADMINISTRATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COMMUNITY_FEE_WITHDRAWER_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"newAlgebraFee\",\"type\":\"uint16\"}],\"name\":\"acceptAlgebraFeeChangeProposal\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptAlgebraFeeManagerRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"algebraFee\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"algebraFeeManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"algebraFeeReceiver\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cancelAlgebraFeeChangeProposal\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAlgebraFeeReceiver\",\"type\":\"address\"}],\"name\":\"changeAlgebraFeeReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newCommunityFeeReceiver\",\"type\":\"address\"}],\"name\":\"changeCommunityFeeReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"communityFeeReceiver\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"hasNewAlgebraFeeProposal\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"newAlgebraFee\",\"type\":\"uint16\"}],\"name\":\"proposeAlgebraFeeChange\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proposedNewAlgebraFee\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAlgebraFeeManager\",\"type\":\"address\"}],\"name\":\"transferAlgebraFeeManagerRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"struct IAlgebraCommunityVault.WithdrawTokensParams[]\",\"name\":\"params\",\"type\":\"tuple[]\"}],\"name\":\"withdrawTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Role system is used to withdraw tokensVersion: Algebra Integral 1.0\",\"events\":{\"AlgebraFee(uint16)\":{\"params\":{\"newAlgebraFee\":\"The new Algebra fee value\"}},\"AlgebraFeeManager(address)\":{\"params\":{\"newAlgebraFeeManager\":\"New Algebra fee manager address\"}},\"AlgebraFeeProposal(uint16)\":{\"params\":{\"proposedNewAlgebraFee\":\"The new proposed Algebra fee value\"}},\"AlgebraFeeReceiver(address)\":{\"params\":{\"newAlgebraFeeReceiver\":\"New Algebra fee receiver address\"}},\"AlgebraTokensWithdrawal(address,address,uint256)\":{\"params\":{\"amount\":\"The amount of fees tokens claimed by Algebra\",\"to\":\"The address where claimed rewards were sent to\",\"token\":\"The address of token fee\"}},\"CommunityFeeReceiver(address)\":{\"params\":{\"newCommunityFeeReceiver\":\"New fee receiver address\"}},\"PendingAlgebraFeeManager(address)\":{\"params\":{\"pendingAlgebraFeeManager\":\"New pending Algebra fee manager address\"}},\"TokensWithdrawal(address,address,uint256)\":{\"params\":{\"amount\":\"The amount of fees tokens claimed by communityFeeReceiver\",\"to\":\"The address where claimed rewards were sent to\",\"token\":\"The address of token fee\"}}},\"kind\":\"dev\",\"methods\":{\"acceptAlgebraFeeChangeProposal(uint16)\":{\"details\":\"Can only be called by the factory owner. The new value will also be used for previously accumulated tokens that have not yet been withdrawn\",\"params\":{\"newAlgebraFee\":\"New Algebra fee value\"}},\"changeAlgebraFeeReceiver(address)\":{\"params\":{\"newAlgebraFeeReceiver\":\"The address of new Algebra fee receiver\"}},\"changeCommunityFeeReceiver(address)\":{\"details\":\"Can only be called by the factory owner\",\"params\":{\"newCommunityFeeReceiver\":\"New community fee receiver address\"}},\"proposeAlgebraFeeChange(uint16)\":{\"details\":\"the new value will also be used for previously accumulated tokens that have not yet been withdrawn\",\"params\":{\"newAlgebraFee\":\"new Algebra fee value\"}},\"transferAlgebraFeeManagerRole(address)\":{\"params\":{\"_newAlgebraFeeManager\":\"new Algebra fee manager address\"}},\"withdraw(address,uint256)\":{\"details\":\"Can only be called by algebraFeeManager or communityFeeReceiver\",\"params\":{\"amount\":\"The amount of token\",\"token\":\"The token address\"}},\"withdrawTokens((address,uint256)[])\":{\"details\":\"Can be called by algebraFeeManager or communityFeeReceiver\",\"params\":{\"params\":\"Array of WithdrawTokensParams objects containing token addresses and amounts to withdraw\"}}},\"stateVariables\":{\"COMMUNITY_FEE_VAULT_ADMINISTRATOR\":{\"details\":\"The role can be granted in AlgebraFactory\"},\"COMMUNITY_FEE_WITHDRAWER_ROLE\":{\"details\":\"The role can be granted in AlgebraFactory\"},\"algebraFee\":{\"details\":\"Value in thousandths,i.e. 1e-3\"}},\"title\":\"Algebra community fee vault\",\"version\":1},\"userdoc\":{\"errors\":{\"transferFailed()\":[{\"notice\":\"Emitted if token transfer failed internally\"}]},\"events\":{\"AlgebraFee(uint16)\":{\"notice\":\"Emitted when the Algebra fee is changed\"},\"AlgebraFeeManager(address)\":{\"notice\":\"Emitted when a AlgebraFeeManager address changed\"},\"AlgebraFeeProposal(uint16)\":{\"notice\":\"Emitted when a new Algebra fee value proposed\"},\"AlgebraFeeReceiver(address)\":{\"notice\":\"Emitted when a AlgebraFeeReceiver address changed\"},\"AlgebraTokensWithdrawal(address,address,uint256)\":{\"notice\":\"Event emitted when a fees has been claimed\"},\"CancelAlgebraFeeProposal()\":{\"notice\":\"Emitted when a Algebra fee proposal canceled\"},\"CommunityFeeReceiver(address)\":{\"notice\":\"Emitted when a CommunityFeeReceiver address changed\"},\"PendingAlgebraFeeManager(address)\":{\"notice\":\"Emitted when a AlgebraFeeManager address change proposed\"},\"TokensWithdrawal(address,address,uint256)\":{\"notice\":\"Event emitted when a fees has been claimed\"}},\"kind\":\"user\",\"methods\":{\"acceptAlgebraFeeChangeProposal(uint16)\":{\"notice\":\"Accepts the proposed new Algebra fee\"},\"acceptAlgebraFeeManagerRole()\":{\"notice\":\"accept Algebra FeeManager role\"},\"algebraFee()\":{\"notice\":\"The percentage of the protocol fee that Algebra will receive\"},\"algebraFeeManager()\":{\"notice\":\"Address of Algebra fee manager\"},\"algebraFeeReceiver()\":{\"notice\":\"Address of recipient Algebra part of community fee\"},\"cancelAlgebraFeeChangeProposal()\":{\"notice\":\"Cancels Algebra fee change proposal\"},\"changeAlgebraFeeReceiver(address)\":{\"notice\":\"Change Algebra community fee part receiver\"},\"changeCommunityFeeReceiver(address)\":{\"notice\":\"Change community fee receiver address\"},\"communityFeeReceiver()\":{\"notice\":\"Address to which community fees are sent from vault\"},\"hasNewAlgebraFeeProposal()\":{\"notice\":\"Represents whether there is a new Algebra fee proposal or not\"},\"proposeAlgebraFeeChange(uint16)\":{\"notice\":\"Proposes new Algebra fee value for protocol\"},\"proposedNewAlgebraFee()\":{\"notice\":\"Suggested Algebra fee value\"},\"transferAlgebraFeeManagerRole(address)\":{\"notice\":\"Transfers Algebra fee manager role\"},\"withdraw(address,uint256)\":{\"notice\":\"Withdraw protocol fees from vault\"},\"withdrawTokens((address,uint256)[])\":{\"notice\":\"Withdraw protocol fees from vault. Used to claim fees for multiple tokens\"}},\"notice\":\"Community fee from pools is sent here, if it is enabled\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/AlgebraCommunityVault.sol\":\"AlgebraCommunityVault\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":800},\"remappings\":[]},\"sources\":{\"contracts/AlgebraCommunityVault.sol\":{\"keccak256\":\"0x708da82829dd47bfd351dc082991f1f84649222208ee8da83489576e29d1bac7\",\"license\":\"BUSL-1.1\",\"urls\":[\"bzz-raw://7a2850248ee1d819561f980652e90f73b458af90d56f42f6dc8e5783d54be745\",\"dweb:/ipfs/QmXj4wurPvBfNmoGtw527pU2efYetTSi1dCWDocBqxpJzB\"]},\"contracts/interfaces/IAlgebraFactory.sol\":{\"keccak256\":\"0x78c785057878fdf8f969b54f522f23bf5426e0494fa63814ba3c230b48d50e34\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://62de47c96e3ccc211ef2c364633d6da40ea1478bfb7bd700c04d163793b8411a\",\"dweb:/ipfs/QmVft8RtPLSwtp7eGtYjcUQ7Fnci75uTthnuUuBaRb3d2a\"]},\"contracts/interfaces/plugin/IAlgebraPluginFactory.sol\":{\"keccak256\":\"0xd8e75579936551ecdf0cb1c50726c4f56313bf27373612448c1f974dd3cde9b1\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://645de0a900f86606825c196cebd2b4a722efc3918731aa8e7a89d1c523885e75\",\"dweb:/ipfs/Qma3MaayiN1L9vLncnK6hGJo9kbKCHT7Qs1m5iRvrUnTaw\"]},\"contracts/interfaces/pool/IAlgebraPoolErrors.sol\":{\"keccak256\":\"0xafcb8fd756f7f2df870fdceac95502c321dc1ec4b08f059a14802664822c4c35\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://6d5ca050ff8a743b858a276ff0690070b009aef7654cb79dbbbbaa7de894992b\",\"dweb:/ipfs/QmRNfEvReRsGAuxm5uDaPXZGjWVA3c5Emy6GMB4GYDaZx2\"]},\"contracts/interfaces/vault/IAlgebraCommunityVault.sol\":{\"keccak256\":\"0x24fad3648346700d372d65ca449494553db47dcb03d2cd0acaf7677a5f7b1391\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://c15473dd606ee905423bf27fba68ce7d9964b43f728611db22468dd36581caf4\",\"dweb:/ipfs/QmSa7ratHBjLQ3xrAoNXvM3pBhtLYBqRuMx8rnYy5S2se4\"]},\"contracts/interfaces/vault/IAlgebraVaultFactory.sol\":{\"keccak256\":\"0xf3ac234d4cf208d9efa204130d624823fc5b594a25a2568371b9520662ef931a\",\"license\":\"GPL-2.0-or-later\",\"urls\":[\"bzz-raw://e355b868946cbea89029bce9db7eb6cd469828a869ccabfc39f2507a3e357d99\",\"dweb:/ipfs/QmS67vkjpXQkhK3qZpg2pvnVS54kADxRPiYzC2foFWhhC7\"]},\"contracts/libraries/FullMath.sol\":{\"keccak256\":\"0x6e562130eac2d18d5527fc12115e83a3aa0955f6be89531b6d0d5977f0784cf7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e5226566361b64a277a523430449d398434aa9956ec53ab96120bdb5eed0d36c\",\"dweb:/ipfs/QmdmE85FDGgaZBFb9WDamJQpvSx6BrpYUutudSzoRVmxMv\"]},\"contracts/libraries/SafeTransfer.sol\":{\"keccak256\":\"0x14e91c94e35c50efcd97e13609f686499c1dfa726ee0b3f6078fa4b99bde9a0a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1d9a7efa21d03180ded0e99d7ba05abd5c8ebedf2439a5a78091b679eadc4064\",\"dweb:/ipfs/QmVUZPhYPTb2yY9381AL242tfVsb3iWxmE2XwqcN9HG6eW\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"transferFailed()":[{"notice":"Emitted if token transfer failed internally"}]},"events":{"AlgebraFee(uint16)":{"notice":"Emitted when the Algebra fee is changed"},"AlgebraFeeManager(address)":{"notice":"Emitted when a AlgebraFeeManager address changed"},"AlgebraFeeProposal(uint16)":{"notice":"Emitted when a new Algebra fee value proposed"},"CancelAlgebraFeeProposal()":{"notice":"Emitted when a Algebra fee proposal canceled"},"AlgebraFeeReceiver(address)":{"notice":"Emitted when a AlgebraFeeReceiver address changed"},"CommunityFeeReceiver(address)":{"notice":"Emitted when a CommunityFeeReceiver address changed"},"PendingAlgebraFeeManager(address)":{"notice":"Emitted when a AlgebraFeeManager address change proposed"},"TokensWithdrawal(address,address,uint256)":{"notice":"Event emitted when a fees has been claimed"},"AlgebraTokensWithdrawal(address,address,uint256)":{"notice":"Event emitted when a fees has been claimed"}},"notice":"Community fee from pools is sent here, if it is enabled","methods":{"algebraFee()":{"notice":"The percentage of the protocol fee that Algebra will receive"},"algebraFeeManager()":{"notice":"Address of Algebra fee manager"},"algebraFeeReceiver()":{"notice":"Address of recipient Algebra part of community fee"},"communityFeeReceiver()":{"notice":"Address to which community fees are sent from vault"},"proposedNewAlgebraFee()":{"notice":"Suggested Algebra fee value"},"withdraw(address,uint256)":{"notice":"Withdraw protocol fees from vault"},"hasNewAlgebraFeeProposal()":{"notice":"Represents whether there is a new Algebra fee proposal or not"},"acceptAlgebraFeeManagerRole()":{"notice":"accept Algebra FeeManager role"},"proposeAlgebraFeeChange(uint16)":{"notice":"Proposes new Algebra fee value for protocol"},"cancelAlgebraFeeChangeProposal()":{"notice":"Cancels Algebra fee change proposal"},"changeAlgebraFeeReceiver(address)":{"notice":"Change Algebra community fee part receiver"},"changeCommunityFeeReceiver(address)":{"notice":"Change community fee receiver address"},"withdrawTokens((address,uint256)[])":{"notice":"Withdraw protocol fees from vault. Used to claim fees for multiple tokens"},"acceptAlgebraFeeChangeProposal(uint16)":{"notice":"Accepts the proposed new Algebra fee"},"transferAlgebraFeeManagerRole(address)":{"notice":"Transfers Algebra fee manager role"}},"version":1},"devdoc":{"kind":"dev","title":"Algebra community fee vault","events":{"AlgebraFee(uint16)":{"params":{"newAlgebraFee":"The new Algebra fee value"}},"AlgebraFeeManager(address)":{"params":{"newAlgebraFeeManager":"New Algebra fee manager address"}},"AlgebraFeeProposal(uint16)":{"params":{"proposedNewAlgebraFee":"The new proposed Algebra fee value"}},"AlgebraFeeReceiver(address)":{"params":{"newAlgebraFeeReceiver":"New Algebra fee receiver address"}},"CommunityFeeReceiver(address)":{"params":{"newCommunityFeeReceiver":"New fee receiver address"}},"PendingAlgebraFeeManager(address)":{"params":{"pendingAlgebraFeeManager":"New pending Algebra fee manager address"}},"TokensWithdrawal(address,address,uint256)":{"params":{"to":"The address where claimed rewards were sent to","token":"The address of token fee","amount":"The amount of fees tokens claimed by communityFeeReceiver"}},"AlgebraTokensWithdrawal(address,address,uint256)":{"params":{"to":"The address where claimed rewards were sent to","token":"The address of token fee","amount":"The amount of fees tokens claimed by Algebra"}}},"details":"Role system is used to withdraw tokensVersion: Algebra Integral 1.0","methods":{"withdraw(address,uint256)":{"params":{"token":"The token address","amount":"The amount of token"},"details":"Can only be called by algebraFeeManager or communityFeeReceiver"},"proposeAlgebraFeeChange(uint16)":{"params":{"newAlgebraFee":"new Algebra fee value"},"details":"the new value will also be used for previously accumulated tokens that have not yet been withdrawn"},"changeAlgebraFeeReceiver(address)":{"params":{"newAlgebraFeeReceiver":"The address of new Algebra fee receiver"}},"changeCommunityFeeReceiver(address)":{"params":{"newCommunityFeeReceiver":"New community fee receiver address"},"details":"Can only be called by the factory owner"},"withdrawTokens((address,uint256)[])":{"params":{"params":"Array of WithdrawTokensParams objects containing token addresses and amounts to withdraw"},"details":"Can be called by algebraFeeManager or communityFeeReceiver"},"acceptAlgebraFeeChangeProposal(uint16)":{"params":{"newAlgebraFee":"New Algebra fee value"},"details":"Can only be called by the factory owner. The new value will also be used for previously accumulated tokens that have not yet been withdrawn"},"transferAlgebraFeeManagerRole(address)":{"params":{"_newAlgebraFeeManager":"new Algebra fee manager address"}}},"version":1,"stateVariables":{"algebraFee":{"details":"Value in thousandths,i.e. 1e-3"},"COMMUNITY_FEE_WITHDRAWER_ROLE":{"details":"The role can be granted in AlgebraFactory"},"COMMUNITY_FEE_VAULT_ADMINISTRATOR":{"details":"The role can be granted in AlgebraFactory"}}},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_uint16":{"label":"uint16","encoding":"inplace","numberOfBytes":"2"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":25,"label":"communityFeeReceiver","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"0","type":"t_uint16","astId":28,"label":"algebraFee","offset":20,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"0","type":"t_bool","astId":31,"label":"hasNewAlgebraFeeProposal","offset":22,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"0","type":"t_uint16","astId":34,"label":"proposedNewAlgebraFee","offset":23,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"1","type":"t_address","astId":37,"label":"algebraFeeReceiver","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"2","type":"t_address","astId":40,"label":"algebraFeeManager","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"},{"slot":"3","type":"t_address","astId":42,"label":"_pendingAlgebraFeeManager","offset":0,"contract":"contracts/AlgebraCommunityVault.sol:AlgebraCommunityVault"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"432:6230:0:-:0;;;2063:130;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2137:17;2127:61;;-1:-1:-1;;;;;;2127:61:0;-1:-1:-1;;;;;2127:61:0;;;;;;;;;432:6230;;14:177:8;93:13;;-1:-1:-1;;;;;135:31:8;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:293::-;275:6;283;336:2;324:9;315:7;311:23;307:32;304:52;;;352:1;349;342:12;304:52;375:40;405:9;375:40;:::i;:::-;365:50;;434:49;479:2;468:9;464:18;434:49;:::i;:::-;424:59;;196:293;;;;;:::o;:::-;432:6230:0;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"432:6230:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;546:93;;602:37;546:93;;;;;160:25:8;;;148:2;133:18;546:93:0;;;;;;;;910:35;;;;;-1:-1:-1;;;;;910:35:0;;;;;;-1:-1:-1;;;;;360:55:8;;;342:74;;330:2;315:18;910:35:0;196:226:8;1356:33:0;;;;;-1:-1:-1;;;;;1356:33:0;;;6342:318;;;;;;:::i;:::-;;:::i;:::-;;5145:228;;;;;;:::i;:::-;;:::i;1252:35::-;;;;;-1:-1:-1;;;1252:35:0;;;;;;;;;993:6:8;981:19;;;963:38;;951:2;936:18;1252:35:0;819:188:8;1438:32:0;;;;;-1:-1:-1;;;;;1438:32:0;;;1066:24;;;;;-1:-1:-1;;;1066:24:0;;;;;;5418:235;;;:::i;4713:332::-;;;;;;:::i;:::-;;:::i;696:106::-;;756:46;696:106;;1170:36;;;;;-1:-1:-1;;;1170:36:0;;;;;;;;;1177:14:8;;1170:22;1152:41;;1140:2;1125:18;1170:36:0;1012:187:8;6105:192:0;;;:::i;5698:362::-;;;;;;:::i;:::-;;:::i;2578:436::-;;;;;;:::i;:::-;;:::i;2238:295::-;;;;;;:::i;:::-;;:::i;4190:478::-;;;;;;:::i;:::-;;:::i;6342:318::-;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;;;;;;;;;-1:-1:-1;;;;;6461:35:0;::::1;6453:44;;;::::0;::::1;;6536:18;::::0;-1:-1:-1;;;;;6536:18:0;;::::1;6511:43:::0;;::::1;::::0;6503:52:::1;;;::::0;::::1;;6561:18;:42:::0;;-1:-1:-1;;;;;;6561:42:0::1;-1:-1:-1::0;;;;;6561:42:0;::::1;::::0;;::::1;::::0;;;6614:41:::1;::::0;342:74:8;;;6614:41:0::1;::::0;330:2:8;315:18;6614:41:0::1;;;;;;;;6342:318:::0;:::o;5145:228::-;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;2399:348:8;1979:68:0;5261:25:::1;:49:::0;;-1:-1:-1;;;;;;5261:49:0::1;-1:-1:-1::0;;;;;5261:49:0;::::1;::::0;;::::1;::::0;;;5321:47:::1;::::0;342:74:8;;;5321:47:0::1;::::0;330:2:8;315:18;5321:47:0::1;196:226:8::0;5418:235:0;5503:25;;-1:-1:-1;;;;;5503:25:0;5489:10;:39;5481:48;;;;;;5563:17;5535:73;;5597:10;-1:-1:-1;;;;;;5535:73:0;;;;;;;;5536:25;5535:73;;;;;;;5619:29;;342:74:8;;;5619:29:0;;330:2:8;315:18;5619:29:0;;;;;;;5418:235::o;4713:332::-;1622:86;;-1:-1:-1;;;1622:86:0;;756:46;1622:86;;;2926:25:8;1697:10:0;2967:18:8;;;2960:83;1638:7:0;-1:-1:-1;;;;;1622:39:0;;;;2899:18:8;;1622:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1614:117;;;;-1:-1:-1;;;1614:117:0;;3538:2:8;1614:117:0;;;3520:21:8;3577:2;3557:18;;;3550:30;3616:20;3596:18;;;3589:48;3654:18;;1614:117:0;3336:342:8;1614:117:0;-1:-1:-1;;;;;4832:37:0;::::1;4824:46;;;::::0;::::1;;4911:20;::::0;-1:-1:-1;;;;;4911:20:0;;::::1;4884:47:::0;;::::1;::::0;4876:56:::1;;;::::0;::::1;;4938:20;:46:::0;;-1:-1:-1;;;;;;4938:46:0::1;-1:-1:-1::0;;;;;4938:46:0;::::1;::::0;;::::1;::::0;;;4995:45:::1;::::0;342:74:8;;;4995:45:0::1;::::0;330:2:8;315:18;4995:45:0::1;196:226:8::0;6105:192:0;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;2399:348:8;1979:68:0;6246:1:::1;6193:62:::0;;-1:-1:-1;;;;6193:62:0;;;6266:26:::1;::::0;::::1;::::0;6246:1;6266:26:::1;6105:192::o:0;5698:362::-;2001:17;;-1:-1:-1;;;;;2001:17:0;1987:10;:31;1979:68;;;;-1:-1:-1;;;1979:68:0;;2601:2:8;1979:68:0;;;2583:21:8;2640:2;2620:18;;;2613:30;2679:26;2659:18;;;2652:54;2723:18;;1979:68:0;2399:348:8;1979:68:0;1570:4:::1;5807:40;::::0;::::1;;;5799:49;;;::::0;::::1;;5879:21;::::0;::::1;5862:38:::0;;::::1;-1:-1:-1::0;;;5879:21:0;;::::1;;5862:38;::::0;::::1;::::0;:69:::1;;-1:-1:-1::0;5921:10:0::1;::::0;::::1;5904:27:::0;;::::1;-1:-1:-1::0;;;5921:10:0;;::::1;;5904:27;;5862:69;5854:78;;;::::0;::::1;;5939:21;5938:73:::0;;::::1;::::0;::::1;-1:-1:-1::0;;;5938:73:0::1;-1:-1:-1::0;;;;5938:73:0;;;;-1:-1:-1;;;5938:73:0;;;6022:33:::1;::::0;::::1;::::0;::::1;::::0;5991:13;;993:6:8;981:19;;;;963:38;;951:2;936:18;;819:188;2578:436:0;1801:17;;-1:-1:-1;;;;;1801:17:0;1787:10;:31;;:117;;-1:-1:-1;1822:82:0;;-1:-1:-1;;;1822:82:0;;602:37;1822:82;;;2926:25:8;1893:10:0;2967:18:8;;;2960:83;1838:7:0;-1:-1:-1;;;;;1822:39:0;;;;2899:18:8;;1822:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1779:145;;;;-1:-1:-1;;;1779:145:0;;3885:2:8;1779:145:0;;;3867:21:8;3924:2;3904:18;;;3897:30;-1:-1:-1;;;3943:18:8;;;3936:45;3998:18;;1779:145:0;3683:339:8;1779:145:0;2704:6;2681:20:::1;::::0;;2806:32:::1;:30;:32::i;:::-;2723:115;;;;;;2868:9;2863:140;2883:12;2879:1;:16;2863:140;;;2902:101;2912:6;;2919:1;2912:9;;;;;;;:::i;:::-;:15;::::0;::::1;:9;::::0;;::::1;;:15:::0;;::::1;::::0;-1:-1:-1;2912:15:0::1;:::i;:::-;2929:21;2952:6;;2959:1;2952:9;;;;;;;:::i;:::-;;;;;;:16;;;2970:11;2983:19;2902:9;:101::i;:::-;2897:3;;2863:140;;;;2675:339;;;;2578:436:::0;;:::o;2238:295::-;1801:17;;-1:-1:-1;;;;;1801:17:0;1787:10;:31;;:117;;-1:-1:-1;1822:82:0;;-1:-1:-1;;;1822:82:0;;602:37;1822:82;;;2926:25:8;1893:10:0;2967:18:8;;;2960:83;1838:7:0;-1:-1:-1;;;;;1822:39:0;;;;2899:18:8;;1822:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1779:145;;;;-1:-1:-1;;;1779:145:0;;3885:2:8;1779:145:0;;;3867:21:8;3924:2;3904:18;;;3897:30;-1:-1:-1;;;3943:18:8;;;3936:45;3998:18;;1779:145:0;3683:339:8;1779:145:0;2327:18:::1;2347:27:::0;2376:29:::1;2409:32;:30;:32::i;:::-;2326:115;;;;;;2447:81;2457:5;2464:21;2487:6;2495:11;2508:19;2447:9;:81::i;:::-;2320:213;;;2238:295:::0;;:::o;4190:478::-;1622:86;;-1:-1:-1;;;1622:86:0;;756:46;1622:86;;;2926:25:8;1697:10:0;2967:18:8;;;2960:83;1638:7:0;-1:-1:-1;;;;;1622:39:0;;;;2899:18:8;;1622:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1614:117;;;;-1:-1:-1;;;1614:117:0;;3538:2:8;1614:117:0;;;3520:21:8;3577:2;3557:18;;;3550:30;3616:20;3596:18;;;3589:48;3654:18;;1614:117:0;3336:342:8;1614:117:0;4302:24:::1;::::0;-1:-1:-1;;;4302:24:0;::::1;;;4294:49;;;::::0;-1:-1:-1;;;4294:49:0;;4361:2:8;4294:49:0::1;::::0;::::1;4343:21:8::0;4400:2;4380:18;;;4373:30;4439:14;4419:18;;;4412:42;4471:18;;4294:49:0::1;4159:336:8::0;4294:49:0::1;4374:21;::::0;::::1;4357:38:::0;;::::1;-1:-1:-1::0;;;4374:21:0;;::::1;;4357:38;4349:66;;;::::0;-1:-1:-1;;;4349:66:0;;4702:2:8;4349:66:0::1;::::0;::::1;4684:21:8::0;4741:2;4721:18;;;4714:30;4780:17;4760:18;;;4753:45;4815:18;;4349:66:0::1;4500:339:8::0;4349:66:0::1;4533:10;:26:::0;;4565:62;;-1:-1:-1;;;4533:26:0::1;::::0;::::1;::::0;;::::1;-1:-1:-1::0;;;;4565:62:0;;;;;;;;4638:25:::1;::::0;963:38:8;;;4638:25:0::1;::::0;951:2:8;936:18;4638:25:0::1;819:188:8::0;3018:441:0;3082:18;3229:10;3241:18;;3229:10;-1:-1:-1;;;3229:10:0;;;;-1:-1:-1;;;;;3241:18:0;;;;3261:20;3292:16;;3288:96;;-1:-1:-1;;;;;3318:33:0;;3310:74;;;;-1:-1:-1;;;3310:74:0;;5046:2:8;3310:74:0;;;5028:21:8;5085:2;5065:18;;;5058:30;5124;5104:18;;;5097:58;5172:18;;3310:74:0;4844:352:8;3310:74:0;-1:-1:-1;;;;;3398:35:0;;3390:64;;;;-1:-1:-1;;;3390:64:0;;5403:2:8;3390:64:0;;;5385:21:8;5442:2;5422:18;;;5415:30;5481:18;5461;;;5454:46;5517:18;;3390:64:0;5201:340:8;3390:64:0;3018:441;;;:::o;3463:625::-;3613:6;3629:16;;;;3625:346;;3655:24;3682:79;3708:14;3682:79;;;1570:4;3682:25;:79::i;:::-;3655:106;-1:-1:-1;3769:34:0;3655:106;3769:34;;:::i;:::-;;;3811:71;3837:5;3844:19;3865:16;3811:25;:71::i;:::-;3926:19;-1:-1:-1;;;;;3895:69:0;3919:5;-1:-1:-1;;;;;3895:69:0;;3947:16;3895:69;;;;160:25:8;;148:2;133:18;;14:177;3895:69:0;;;;;;;;3647:324;3625:346;3977:52;4003:5;4010:2;4014:14;3977:25;:52::i;:::-;4064:2;-1:-1:-1;;;;;4040:43:0;4057:5;-1:-1:-1;;;;;4040:43:0;;4068:14;4040:43;;;;160:25:8;;148:2;133:18;;14:177;4040:43:0;;;;;;;;3582:506;3463:625;;;;;:::o;4485:521:6:-;4577:14;4621:6;;;:37;;-1:-1:-1;;4642:5:6;;;4656:1;4651;4642:5;4651:1;4632:20;;;;:::i;:::-;;:25;4621:37;4617:379;;;4692:1;4678:11;:15;4670:24;;;;;;4739;;;4768;;;;4765:31;;4735:62;4617:379;;;4840:25;4847:1;4850;4853:11;4840:6;:25::i;:::-;4831:34;;4907:1;4892:11;4879:25;;;;;:::i;:::-;4889:1;4886;4879:25;:29;4875:113;;;-1:-1:-1;;4930:6:6;:26;4922:35;;;;;;4969:8;;4875:113;4485:521;;;;;:::o;865:967:7:-;945:12;1011:4;1005:11;-1:-1:-1;;;1067:4:7;1060:80;-1:-1:-1;;;;;1204:2:7;1200:51;1194:4;1187:65;1303:6;1297:4;1290:20;1433:4;1430:1;1424:4;1421:1;1418;1411:5;1404;1399:39;1388:50;;1673:7;1645:16;1638:24;1632:2;1614:16;1611:24;1607:1;1603;1597:8;1594:15;1590:46;1587:76;1456:232;1445:243;;1708:17;1702:4;1695:31;;1776:7;1771:56;;1792:35;;-1:-1:-1;;;1792:35:7;;;;;;;;;;;1771:56;939:893;865:967;;;:::o;727:3488:6:-;809:14;1158:5;;;809:14;-1:-1:-1;;1162:1:6;1158;1310:20;1375:5;1371:2;1368:13;1360:5;1356:2;1352:14;1348:34;1339:43;;;1511:5;1497:11;:19;1489:28;;;;;;1586:5;1595:1;1586:10;1582:121;;-1:-1:-1;1639:23:6;;;;-1:-1:-1;1681:13:6;;1582:121;2072:11;2069:1;2066;2059:25;2322:12;2338:15;;;2337:31;;2454:22;;;;;3217:1;3198;:15;;3197:21;;3436:17;;;3432:21;;3425:28;3492:17;;;3488:21;;3481:28;3549:17;;;3545:21;;3538:28;3606:17;;;3602:21;;3595:28;3663:17;;;3659:21;;3652:28;3721:17;;;3717:21;;;3710:28;2802:12;;;;2798:23;;;2823:1;2794:31;2113:20;;;2102:32;;;2849:12;;;;2152:21;;;;2572:16;;;;2840:21;4172:11;;-1:-1:-1;727:3488:6;;;;;:::o;427:196:8:-;495:20;;-1:-1:-1;;;;;544:54:8;;534:65;;524:93;;613:1;610;603:12;524:93;427:196;;;:::o;628:186::-;687:6;740:2;728:9;719:7;715:23;711:32;708:52;;;756:1;753;746:12;708:52;779:29;798:9;779:29;:::i;1204:272::-;1262:6;1315:2;1303:9;1294:7;1290:23;1286:32;1283:52;;;1331:1;1328;1321:12;1283:52;1370:9;1357:23;1420:6;1413:5;1409:18;1402:5;1399:29;1389:57;;1442:1;1439;1432:12;1481:654;1606:6;1614;1667:2;1655:9;1646:7;1642:23;1638:32;1635:52;;;1683:1;1680;1673:12;1635:52;1723:9;1710:23;1752:18;1793:2;1785:6;1782:14;1779:34;;;1809:1;1806;1799:12;1779:34;1847:6;1836:9;1832:22;1822:32;;1892:7;1885:4;1881:2;1877:13;1873:27;1863:55;;1914:1;1911;1904:12;1863:55;1954:2;1941:16;1980:2;1972:6;1969:14;1966:34;;;1996:1;1993;1986:12;1966:34;2049:7;2044:2;2034:6;2031:1;2027:14;2023:2;2019:23;2015:32;2012:45;2009:65;;;2070:1;2067;2060:12;2009:65;2101:2;2093:11;;;;;2123:6;;-1:-1:-1;1481:654:8;;-1:-1:-1;;;;1481:654:8:o;2140:254::-;2208:6;2216;2269:2;2257:9;2248:7;2244:23;2240:32;2237:52;;;2285:1;2282;2275:12;2237:52;2308:29;2327:9;2308:29;:::i;:::-;2298:39;2384:2;2369:18;;;;2356:32;;-1:-1:-1;;;2140:254:8:o;3054:277::-;3121:6;3174:2;3162:9;3153:7;3149:23;3145:32;3142:52;;;3190:1;3187;3180:12;3142:52;3222:9;3216:16;3275:5;3268:13;3261:21;3254:5;3251:32;3241:60;;3297:1;3294;3287:12;4027:127;4088:10;4083:3;4079:20;4076:1;4069:31;4119:4;4116:1;4109:15;4143:4;4140:1;4133:15;5546:225;5613:9;;;5634:11;;;5631:134;;;5687:10;5682:3;5678:20;5675:1;5668:31;5722:4;5719:1;5712:15;5750:4;5747:1;5740:15;5631:134;5546:225;;;;:::o;5958:127::-;6019:10;6014:3;6010:20;6007:1;6000:31;6050:4;6047:1;6040:15;6074:4;6071:1;6064:15","linkReferences":{},"immutableReferences":{"22":[{"start":1274,"length":32},{"start":2073,"length":32},{"start":2455,"length":32},{"start":2730,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"acceptAlgebraFeeChangeProposal(uint16)","signatureHash4":"0xff3c43e1","signatureHash32":"0xff3c43e1e02a22487ba453afcc21398497a592598ce37c11c0173f08542512c3"},{"signature":"acceptAlgebraFeeManagerRole()","signatureHash4":"0xad6129ac","signatureHash32":"0xad6129ac8753eaff34ad8bcfbb50a0fc368cb05fe85f7e7fa716605754f43393"},{"signature":"algebraFee()","signatureHash4":"0x9f856b8d","signatureHash32":"0x9f856b8d6a0605e22df017b4c0c0d87b4cc05c1bc68c43d9699291dbb470395e"},{"signature":"algebraFeeManager()","signatureHash4":"0x9d754dde","signatureHash32":"0x9d754ddee24b3db63218f87514f17a3897c2379aab171733d1613ae58dd4de70"},{"signature":"algebraFeeReceiver()","signatureHash4":"0x4738761c","signatureHash32":"0x4738761cf9ee91e098b289be3bb5233e6cbf9fa3a86d0d6804b27f1a8bd2569e"},{"signature":"cancelAlgebraFeeChangeProposal()","signatureHash4":"0xd17bc783","signatureHash32":"0xd17bc78345718fc00ef9ce951f05d7ac87517f4e2ea8af41d0dccd0edd7b048c"},{"signature":"changeAlgebraFeeReceiver(address)","signatureHash4":"0x48a50fcf","signatureHash32":"0x48a50fcf1db573ea5780fdd1459eca793093721048782931c46978e3e4b5848a"},{"signature":"changeCommunityFeeReceiver(address)","signatureHash4":"0xb5f680ae","signatureHash32":"0xb5f680aecc247ba20492fa276fd5a35993feaab1a3ce8b65d14630e98baa37d1"},{"signature":"communityFeeReceiver()","signatureHash4":"0x371abc95","signatureHash32":"0x371abc956eaa9806623aab2c8472b0175a97b267c65fcceab5f9f093133d6949"},{"signature":"COMMUNITY_FEE_VAULT_ADMINISTRATOR()","signatureHash4":"0xbbac3b8d","signatureHash32":"0xbbac3b8df4e68d87dd078b4cfd0dae93ea9b14a26fc8242ca68d338412cfcab7"},{"signature":"COMMUNITY_FEE_WITHDRAWER_ROLE()","signatureHash4":"0x1de41613","signatureHash32":"0x1de416135642f2971ecff203f53858d66c12756d28572bb016d9a01a314c853b"},{"signature":"hasNewAlgebraFeeProposal()","signatureHash4":"0xc53b3fbe","signatureHash32":"0xc53b3fbeadb37e2bdcf89a00882b7fcf3e5b4e88cd2820d7d49420cd93c5c938"},{"signature":"proposeAlgebraFeeChange(uint16)","signatureHash4":"0xd9fb4353","signatureHash32":"0xd9fb43536fdc19af20c2e868f1e6b461c7fc6cdfb1bc6a9df573fa17501527fd"},{"signature":"proposedNewAlgebraFee()","signatureHash4":"0x62744405","signatureHash32":"0x62744405a667abfa2835dd4c8edf47a7da38c6a8bc925a3b7fb764588cd78dee"},{"signature":"transferAlgebraFeeManagerRole(address)","signatureHash4":"0x50eea0c8","signatureHash32":"0x50eea0c8df7b58b955add62c59d7454721462274c3231d16d29eb09bf4d5246b"},{"signature":"withdraw(address,uint256)","signatureHash4":"0xf3fef3a3","signatureHash32":"0xf3fef3a3f44f9c277339b67d54f015748bd8d6b77a985b0ab6e71126b018c34a"},{"signature":"withdrawTokens((address,uint256)[])","signatureHash4":"0xdfadc794","signatureHash32":"0xdfadc794ba012df0ac39c3adacd4a02e41e61b01da9996e867d757ccdf6d1371"}],"event":[{"signature":"AlgebraFeeManager(address)","signatureHash4":"0xecf97a11","signatureHash32":"0xecf97a11fb2f2bcc38d1b6881865ecc04405af2d8b953004c79b3ab398732d02"},{"signature":"AlgebraFeeProposal(uint16)","signatureHash4":"0x2d6ac59d","signatureHash32":"0x2d6ac59d6da98f80c7ea481d17c670ea310b000fff5cf1732d94d93652dd25b7"},{"signature":"AlgebraFeeReceiver(address)","signatureHash4":"0x34d1b5ef","signatureHash32":"0x34d1b5ef1c1c2c03a5000b91bef5c465790244c6751c794e5b45bed7657c38fd"},{"signature":"AlgebraFee(uint16)","signatureHash4":"0xda1e1a9a","signatureHash32":"0xda1e1a9a6410acc0398b3b64e0c0110b8df57e29bfe69a419cdd9ae12718c307"},{"signature":"AlgebraTokensWithdrawal(address,address,uint256)","signatureHash4":"0xb7ee7fc9","signatureHash32":"0xb7ee7fc9dacb957cfa93faeb8ca1826292de295e18e287a347dddfde7ab48b40"},{"signature":"CancelAlgebraFeeProposal()","signatureHash4":"0x9f4bbade","signatureHash32":"0x9f4bbade0736edbd2ec12c598bdac4573af13a3b57820ae4c7da5c61703eaaff"},{"signature":"CommunityFeeReceiver(address)","signatureHash4":"0x2f4db788","signatureHash32":"0x2f4db788b994a5908051d68a2340153f49870447185a244d2326861e60cc4186"},{"signature":"PendingAlgebraFeeManager(address)","signatureHash4":"0xab6918ba","signatureHash32":"0xab6918ba7303f2f81e46e324b5f34af4bda562577c1da710e2034980fee1e82a"},{"signature":"TokensWithdrawal(address,address,uint256)","signatureHash4":"0x7a629b77","signatureHash32":"0x7a629b77ef27ad337abe438773206187960a90abfb43607826bef77d650e84b9"}],"error":[{"signature":"transferFailed()","signatureHash4":"0xe465903e","signatureHash32":"0xe465903e6fa744d03b20fa1849b8f3e1e483810e5e9ca4b828d77eaa0d66bbb6"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0x727443a035E3A6535C979D3fD4034F1BF87A9750"}